[thirdparty/xfsprogs-dev.git] / db / print.c

/*
 * Copyright (c) 2000-2002,2005 Silicon Graphics, Inc.
 * All Rights Reserved.
 *
 * This program is free software; you can redistribute it and/or
 * modify it under the terms of the GNU General Public License as
 * published by the Free Software Foundation.
 *
 * This program is distributed in the hope that it would be useful,
 * but WITHOUT ANY WARRANTY; without even the implied warranty of
 * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
 * GNU General Public License for more details.
 *
 * You should have received a copy of the GNU General Public License
 * along with this program; if not, write the Free Software Foundation,
 * Inc.,  51 Franklin St, Fifth Floor, Boston, MA  02110-1301  USA
 */

#include "libxfs.h"
#include "command.h"
#include "type.h"
#include "faddr.h"
#include "fprint.h"
#include "field.h"
#include "io.h"
#include "print.h"
#include "bit.h"
#include "flist.h"
#include "strvec.h"
#include "output.h"
#include "sig.h"
#include "write.h"

static void	print_allfields(const struct field *fields);
static int	print_f(int argc, char **argv);
static void	print_flist_1(struct flist *flist, char **pfx, int parentoff);
static void	print_somefields(const struct field *fields, int argc,
				 char **argv);

static const cmdinfo_t	print_cmd =
	{ "print", "p", print_f, 0, -1, 0, N_("[value]..."),
	  N_("print field values"), NULL };

static void
print_allfields(
	const field_t	*fields)
{
	flist_t		*flist;
#ifdef DEBUG
	int		i;
#endif

	flist = flist_make("");
	flist->fld = fields;
#ifndef DEBUG
	(void)flist_parse(fields, flist, iocur_top->data, 0);
#else
	i = flist_parse(fields, flist, iocur_top->data, 0);
	ASSERT(i == 1);
#endif
	flist_print(flist);
	print_flist(flist);
	flist_free(flist);
}

static int
print_f(
	int	argc,
	char	**argv)
{
	pfunc_t	pf;

	if (cur_typ == NULL) {
		dbprintf(_("no current type\n"));
		return 0;
	}
	pf = cur_typ->pfunc;
	if (pf == NULL) {
		dbprintf(_("no print function for type %s\n"), cur_typ->name);
		return 0;
	}
	argc--;
	argv++;
	(*pf)(DB_READ, cur_typ->fields, argc, argv);
	return 0;
}

void
print_flist(
	flist_t	*flist)
{
	char	**pfx;

	pfx = new_strvec(0);
	print_flist_1(flist, pfx, 0);
	free_strvec(pfx);
}

static void
print_flist_1(
	flist_t		*flist,
	char		**ppfx,
	int		parentoff)
{
	char		buf[16];
	const field_t	*f;
	const ftattr_t	*fa;
	flist_t		*fl;
	int		low;
	int		count;
	int		neednl;
	char		**pfx;

	for (fl = flist; fl && !seenint(); fl = fl->sibling) {
		pfx = copy_strvec(ppfx);
		if (fl->name[0])
			add_strvec(&pfx, fl->name);
		if (fl->flags & FL_OKLOW) {
			add_strvec(&pfx, "[");
			snprintf(buf, sizeof(buf), "%d", fl->low);
			add_strvec(&pfx, buf);
			if (fl->low != fl->high) {
				add_strvec(&pfx, "-");
				snprintf(buf, sizeof(buf), "%d", fl->high);
				add_strvec(&pfx, buf);
			}
			add_strvec(&pfx, "]");
		}
		if (fl->child) {
			if (fl->name[0])
				add_strvec(&pfx, ".");
			print_flist_1(fl->child, pfx, fl->offset);
		} else {
			f = fl->fld;
			fa = &ftattrtab[f->ftyp];
			ASSERT(fa->ftyp == f->ftyp);
			print_strvec(pfx);
			dbprintf(" = ");
			if (fl->flags & FL_OKLOW)
				low = fl->low;
			else
				low = 0;
			count = fcount(f, iocur_top->data, parentoff);
			if (fl->flags & FL_OKHIGH)
				count = min(count, fl->high - low + 1);
			if (fa->prfunc) {
				int	fsz;
				int	bitlen;

				/* Don't read an array off the end of the buffer */
				fsz = fsize(f, iocur_top->data, parentoff, 0);
				bitlen = iocur_top->len * NBBY;
				if ((f->flags & FLD_ARRAY) &&
				    fl->offset + (count * fsz) > bitlen) {
					count = (bitlen - fl->offset) / fsz;
				}

				neednl = fa->prfunc(iocur_top->data, fl->offset,
					count, fa->fmtstr, fsz, fa->arg, low,
					(f->flags & FLD_ARRAY) != 0);
				if (neednl)
					dbprintf("\n");
			} else {
				ASSERT(fa->arg & FTARG_OKEMPTY);
				dbprintf(_("(empty)\n"));
			}
		}
		free_strvec(pfx);
	}
}

void
print_init(void)
{
	add_command(&print_cmd);
}

void
print_sarray(
	void		*obj,
	int		bit,
	int		count,
	int		size,
	int		base,
	int		array,
	const field_t	*flds,
	int		skipnms)
{
	int		bitoff;
	const field_t	*f;
	const ftattr_t	*fa;
	int		first;
	int		i;

	ASSERT(bitoffs(bit) == 0);
	if (skipnms == 0) {
		for (f = flds, first = 1; f->name; f++) {
			if (f->flags & FLD_SKIPALL)
				continue;
			dbprintf("%c%s", first ? '[' : ',', f->name);
			first = 0;
		}
		dbprintf("] ");
	}
	for (i = 0, bitoff = bit;
	     i < count && !seenint();
	     i++, bitoff += size) {
		if (array)
			dbprintf("\n%d:", i + base);
		for (f = flds, first = 1; f->name; f++) {
			if (f->flags & FLD_SKIPALL)
				continue;
			fa = &ftattrtab[f->ftyp];
			ASSERT(fa->ftyp == f->ftyp);
			dbprintf("%c", first ? '[' : ',');
			first = 0;
			if (fa->prfunc)
				fa->prfunc(obj,
					bitoff +
					    bitoffset(f, obj, bitoff, i + base),
					fcount(f, obj, bitoff), fa->fmtstr,
					fsize(f, obj, bitoff, i + base),
					fa->arg, (f->flags & FLD_ABASE1) != 0,
					f->flags & FLD_ARRAY);
			else {
				ASSERT(fa->arg & FTARG_OKEMPTY);
				dbprintf(_("(empty)"));
			}
		}
		dbprintf("]");
		if (i < count - 1)
			dbprintf(" ");
	}
}

static void
print_somefields(
	const field_t	*fields,
	int		argc,
	char		**argv)
{
	const ftattr_t	*fa;
	flist_t		*fl;
	flist_t		*lfl;
	flist_t		*nfl;

	fl = lfl = NULL;
	while (argc > 0) {
		nfl = flist_scan(*argv);
		if (!nfl) {
			if (fl)
				flist_free(fl);
			return;
		}
		if (lfl)
			lfl->sibling = nfl;
		else
			fl = nfl;
		lfl = nfl;
		argc--;
		argv++;
	}
	if (fields->name[0] == '\0') {
		fa = &ftattrtab[fields->ftyp];
		ASSERT(fa->ftyp == fields->ftyp);
		fields = fa->subfld;
	}
	if (!flist_parse(fields, fl, iocur_top->data, 0)) {
		flist_free(fl);
		return;
	}
	flist_print(fl);
	print_flist(fl);
	flist_free(fl);
}

/*ARGSUSED*/
void
print_string(
	const field_t	*fields,
	int		argc,
	char		**argv)
{
	char		*cp;

	if (argc != 0)
		dbprintf(_("no arguments allowed\n"));
	dbprintf("\"");
	for (cp = iocur_top->data;
	     cp < (char *)iocur_top->data + iocur_top->len && *cp &&
		     !seenint();
	     cp++)
		dbprintf("%c", *cp);
	dbprintf("\"\n");
}

void
print_struct(
	const field_t	*fields,
	int		argc,
	char		**argv)
{
	if (argc == 0)
		print_allfields(fields);
	else
		print_somefields(fields, argc, argv);
}
Commit	Line	Data
2bd0ea18	1	/*
da23017d NS	2	* Copyright (c) 2000-2002,2005 Silicon Graphics, Inc.
da23017d NS	3	* All Rights Reserved.
dfc130f3	4	*
da23017d NS	5	* This program is free software; you can redistribute it and/or
da23017d NS	6	* modify it under the terms of the GNU General Public License as
2bd0ea18	7	* published by the Free Software Foundation.
dfc130f3	8	*
da23017d NS	9	* This program is distributed in the hope that it would be useful,
	10	* but WITHOUT ANY WARRANTY; without even the implied warranty of
	11	* MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
	12	* GNU General Public License for more details.
dfc130f3	13	*
da23017d NS	14	* You should have received a copy of the GNU General Public License
	15	* along with this program; if not, write the Free Software Foundation,
	16	* Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301 USA
2bd0ea18 NS	17	*/
2bd0ea18 NS	18
6b803e5a	19	#include "libxfs.h"
2bd0ea18	20	#include "command.h"
2bd0ea18 NS	21	#include "type.h"
	22	#include "faddr.h"
	23	#include "fprint.h"
	24	#include "field.h"
	25	#include "io.h"
	26	#include "print.h"
	27	#include "bit.h"
	28	#include "flist.h"
	29	#include "strvec.h"
	30	#include "output.h"
	31	#include "sig.h"
	32	#include "write.h"
	33
	34	static void print_allfields(const struct field *fields);
	35	static int print_f(int argc, char **argv);
	36	static void print_flist_1(struct flist flist, char *pfx, int parentoff);
	37	static void print_somefields(const struct field *fields, int argc,
	38	char **argv);
	39
	40	static const cmdinfo_t print_cmd =
9ee7055c AM	41	{ "print", "p", print_f, 0, -1, 0, N_("[value]..."),
9ee7055c AM	42	N_("print field values"), NULL };
2bd0ea18 NS	43
	44	static void
	45	print_allfields(
	46	const field_t *fields)
	47	{
	48	flist_t *flist;
	49	#ifdef DEBUG
	50	int i;
	51	#endif
	52
	53	flist = flist_make("");
	54	flist->fld = fields;
	55	#ifndef DEBUG
	56	(void)flist_parse(fields, flist, iocur_top->data, 0);
	57	#else
	58	i = flist_parse(fields, flist, iocur_top->data, 0);
	59	ASSERT(i == 1);
	60	#endif
	61	flist_print(flist);
	62	print_flist(flist);
	63	flist_free(flist);
	64	}
	65
	66	static int
	67	print_f(
	68	int argc,
	69	char **argv)
	70	{
	71	pfunc_t pf;
	72
	73	if (cur_typ == NULL) {
9ee7055c	74	dbprintf(_("no current type\n"));
2bd0ea18 NS	75	return 0;
	76	}
	77	pf = cur_typ->pfunc;
	78	if (pf == NULL) {
9ee7055c	79	dbprintf(_("no print function for type %s\n"), cur_typ->name);
2bd0ea18 NS	80	return 0;
	81	}
	82	argc--;
	83	argv++;
	84	(*pf)(DB_READ, cur_typ->fields, argc, argv);
	85	return 0;
	86	}
	87
	88	void
	89	print_flist(
	90	flist_t *flist)
	91	{
	92	char **pfx;
	93
	94	pfx = new_strvec(0);
	95	print_flist_1(flist, pfx, 0);
	96	free_strvec(pfx);
	97	}
	98
	99	static void
	100	print_flist_1(
	101	flist_t *flist,
	102	char **ppfx,
	103	int parentoff)
	104	{
	105	char buf[16];
	106	const field_t *f;
	107	const ftattr_t *fa;
	108	flist_t *fl;
	109	int low;
0ebbf1d5	110	int count;
2bd0ea18 NS	111	int neednl;
	112	char **pfx;
	113
	114	for (fl = flist; fl && !seenint(); fl = fl->sibling) {
	115	pfx = copy_strvec(ppfx);
	116	if (fl->name[0])
	117	add_strvec(&pfx, fl->name);
	118	if (fl->flags & FL_OKLOW) {
	119	add_strvec(&pfx, "[");
2d9475a4	120	snprintf(buf, sizeof(buf), "%d", fl->low);
2bd0ea18 NS	121	add_strvec(&pfx, buf);
	122	if (fl->low != fl->high) {
	123	add_strvec(&pfx, "-");
2d9475a4	124	snprintf(buf, sizeof(buf), "%d", fl->high);
2bd0ea18 NS	125	add_strvec(&pfx, buf);
	126	}
	127	add_strvec(&pfx, "]");
	128	}
	129	if (fl->child) {
	130	if (fl->name[0])
	131	add_strvec(&pfx, ".");
	132	print_flist_1(fl->child, pfx, fl->offset);
	133	} else {
	134	f = fl->fld;
	135	fa = &ftattrtab[f->ftyp];
	136	ASSERT(fa->ftyp == f->ftyp);
	137	print_strvec(pfx);
	138	dbprintf(" = ");
	139	if (fl->flags & FL_OKLOW)
	140	low = fl->low;
	141	else
	142	low = 0;
0ebbf1d5 DC	143	count = fcount(f, iocur_top->data, parentoff);
	144	if (fl->flags & FL_OKHIGH)
	145	count = min(count, fl->high - low + 1);
2bd0ea18	146	if (fa->prfunc) {
966ef874 DW	147	int fsz;
	148	int bitlen;
	149
	150	/* Don't read an array off the end of the buffer */
	151	fsz = fsize(f, iocur_top->data, parentoff, 0);
	152	bitlen = iocur_top->len * NBBY;
	153	if ((f->flags & FLD_ARRAY) &&
	154	fl->offset + (count * fsz) > bitlen) {
	155	count = (bitlen - fl->offset) / fsz;
	156	}
	157
2bd0ea18	158	neednl = fa->prfunc(iocur_top->data, fl->offset,
966ef874	159	count, fa->fmtstr, fsz, fa->arg, low,
2bd0ea18 NS	160	(f->flags & FLD_ARRAY) != 0);
	161	if (neednl)
	162	dbprintf("\n");
	163	} else {
	164	ASSERT(fa->arg & FTARG_OKEMPTY);
9ee7055c	165	dbprintf(_("(empty)\n"));
2bd0ea18 NS	166	}
	167	}
	168	free_strvec(pfx);
	169	}
	170	}
	171
	172	void
	173	print_init(void)
	174	{
	175	add_command(&print_cmd);
	176	}
	177
	178	void
	179	print_sarray(
	180	void *obj,
	181	int bit,
	182	int count,
	183	int size,
	184	int base,
	185	int array,
	186	const field_t *flds,
	187	int skipnms)
	188	{
	189	int bitoff;
	190	const field_t *f;
	191	const ftattr_t *fa;
	192	int first;
	193	int i;
	194
	195	ASSERT(bitoffs(bit) == 0);
	196	if (skipnms == 0) {
	197	for (f = flds, first = 1; f->name; f++) {
	198	if (f->flags & FLD_SKIPALL)
	199	continue;
	200	dbprintf("%c%s", first ? '[' : ',', f->name);
	201	first = 0;
	202	}
	203	dbprintf("] ");
	204	}
	205	for (i = 0, bitoff = bit;
	206	i < count && !seenint();
	207	i++, bitoff += size) {
	208	if (array)
38428355	209	dbprintf("\n%d:", i + base);
2bd0ea18 NS	210	for (f = flds, first = 1; f->name; f++) {
	211	if (f->flags & FLD_SKIPALL)
	212	continue;
	213	fa = &ftattrtab[f->ftyp];
	214	ASSERT(fa->ftyp == f->ftyp);
	215	dbprintf("%c", first ? '[' : ',');
	216	first = 0;
	217	if (fa->prfunc)
	218	fa->prfunc(obj,
	219	bitoff +
	220	bitoffset(f, obj, bitoff, i + base),
	221	fcount(f, obj, bitoff), fa->fmtstr,
	222	fsize(f, obj, bitoff, i + base),
	223	fa->arg, (f->flags & FLD_ABASE1) != 0,
	224	f->flags & FLD_ARRAY);
	225	else {
	226	ASSERT(fa->arg & FTARG_OKEMPTY);
9ee7055c	227	dbprintf(_("(empty)"));
2bd0ea18 NS	228	}
	229	}
	230	dbprintf("]");
	231	if (i < count - 1)
	232	dbprintf(" ");
	233	}
	234	}
	235
	236	static void
	237	print_somefields(
	238	const field_t *fields,
	239	int argc,
	240	char **argv)
	241	{
	242	const ftattr_t *fa;
	243	flist_t *fl;
	244	flist_t *lfl;
	245	flist_t *nfl;
	246
	247	fl = lfl = NULL;
	248	while (argc > 0) {
	249	nfl = flist_scan(*argv);
	250	if (!nfl) {
	251	if (fl)
	252	flist_free(fl);
	253	return;
	254	}
	255	if (lfl)
	256	lfl->sibling = nfl;
	257	else
	258	fl = nfl;
	259	lfl = nfl;
	260	argc--;
	261	argv++;
	262	}
	263	if (fields->name[0] == '\0') {
	264	fa = &ftattrtab[fields->ftyp];
	265	ASSERT(fa->ftyp == fields->ftyp);
	266	fields = fa->subfld;
	267	}
	268	if (!flist_parse(fields, fl, iocur_top->data, 0)) {
	269	flist_free(fl);
	270	return;
	271	}
	272	flist_print(fl);
	273	print_flist(fl);
	274	flist_free(fl);
	275	}
	276
	277	/ARGSUSED/
	278	void
	279	print_string(
	280	const field_t *fields,
	281	int argc,
	282	char **argv)
	283	{
	284	char *cp;
	285
	286	if (argc != 0)
9ee7055c	287	dbprintf(_("no arguments allowed\n"));
2bd0ea18 NS	288	dbprintf("\"");
	289	for (cp = iocur_top->data;
	290	cp < (char )iocur_top->data + iocur_top->len && cp &&
	291	!seenint();
	292	cp++)
	293	dbprintf("%c", *cp);
	294	dbprintf("\"\n");
	295	}
	296
	297	void
	298	print_struct(
	299	const field_t *fields,
	300	int argc,
	301	char **argv)
	302	{
	303	if (argc == 0)
	304	print_allfields(fields);
	305	else
	306	print_somefields(fields, argc, argv);
	307	}