hush/libbb/dump.c

840 lines
20 KiB
C
Raw Normal View History

/* vi: set sw=4 ts=4: */
2001-11-02 11:39:46 +00:00
/*
* Support code for the hexdump and od applets,
* based on code from util-linux v 2.11l
*
* Copyright (c) 1989
* The Regents of the University of California. All rights reserved.
*
* Licensed under GPLv2 or later, see file LICENSE in this tarball for details.
2001-11-02 11:39:46 +00:00
*
* Original copyright notice is retained at the end of this file.
*/
#include "libbb.h"
2003-03-19 09:13:01 +00:00
#include "dump.h"
2001-11-02 11:39:46 +00:00
static const char index_str[] ALIGN1 = ".#-+ 0123456789";
2001-11-02 11:39:46 +00:00
static const char size_conv_str[] ALIGN1 =
2003-03-19 09:13:01 +00:00
"\x1\x4\x4\x4\x4\x4\x4\x8\x8\x8\x8\010cdiouxXeEfgG";
2001-11-02 11:39:46 +00:00
static const char lcc[] ALIGN1 = "diouxX";
2003-03-19 09:13:01 +00:00
typedef struct priv_dumper_t {
dumper_t pub;
char **argv;
FU *endfu;
off_t savaddress; /* saved address/offset in stream */
off_t eaddress; /* end address */
off_t address; /* address/offset in stream */
int blocksize;
smallint exitval; /* final exit value */
/* former statics */
smallint next__done;
smallint get__ateof; // = 1;
unsigned char *get__curp;
unsigned char *get__savp;
} priv_dumper_t;
dumper_t* FAST_FUNC alloc_dumper(void)
{
priv_dumper_t *dumper = xzalloc(sizeof(*dumper));
dumper->pub.dump_length = -1;
dumper->pub.dump_vflag = FIRST;
dumper->get__ateof = 1;
return &dumper->pub;
}
static NOINLINE int bb_dump_size(FS *fs)
2001-11-02 11:39:46 +00:00
{
FU *fu;
int bcnt, cur_size;
char *fmt;
2003-03-19 09:13:01 +00:00
const char *p;
2001-11-02 11:39:46 +00:00
int prec;
2003-03-19 09:13:01 +00:00
/* figure out the data block bb_dump_size needed for each format unit */
for (cur_size = 0, fu = fs->nextfu; fu; fu = fu->nextfu) {
2001-11-02 11:39:46 +00:00
if (fu->bcnt) {
2003-03-19 09:13:01 +00:00
cur_size += fu->bcnt * fu->reps;
2001-11-02 11:39:46 +00:00
continue;
}
for (bcnt = prec = 0, fmt = fu->fmt; *fmt; ++fmt) {
if (*fmt != '%')
continue;
/*
* skip any special chars -- save precision in
2001-11-02 11:39:46 +00:00
* case it's a %s format.
*/
2003-03-19 09:13:01 +00:00
while (strchr(index_str + 1, *++fmt));
2001-11-02 11:39:46 +00:00
if (*fmt == '.' && isdigit(*++fmt)) {
prec = atoi(fmt);
while (isdigit(*++fmt))
continue;
2001-11-02 11:39:46 +00:00
}
p = strchr(size_conv_str + 12, *fmt);
if (!p) {
2003-03-19 09:13:01 +00:00
if (*fmt == 's') {
bcnt += prec;
} else if (*fmt == '_') {
++fmt;
if ((*fmt == 'c') || (*fmt == 'p') || (*fmt == 'u')) {
bcnt += 1;
}
2001-11-02 11:39:46 +00:00
}
2003-03-19 09:13:01 +00:00
} else {
bcnt += size_conv_str[p - (size_conv_str + 12)];
2001-11-02 11:39:46 +00:00
}
}
2003-03-19 09:13:01 +00:00
cur_size += bcnt * fu->reps;
2001-11-02 11:39:46 +00:00
}
return cur_size;
2001-11-02 11:39:46 +00:00
}
static NOINLINE void rewrite(priv_dumper_t *dumper, FS *fs)
2001-11-02 11:39:46 +00:00
{
enum { NOTOKAY, USEBCNT, USEPREC } sokay;
PR *pr, **nextpr = NULL;
FU *fu;
char *p1, *p2, *p3;
2001-11-02 11:39:46 +00:00
char savech, *fmtp;
2003-03-19 09:13:01 +00:00
const char *byte_count_str;
2001-11-02 11:39:46 +00:00
int nconv, prec = 0;
for (fu = fs->nextfu; fu; fu = fu->nextfu) {
/*
* break each format unit into print units; each
* conversion character gets its own.
*/
for (nconv = 0, fmtp = fu->fmt; *fmtp; nextpr = &pr->nextpr) {
/* NOSTRICT */
/* DBU:[dvae@cray.com] zalloc so that forward ptrs start out NULL*/
pr = xzalloc(sizeof(PR));
2001-11-02 11:39:46 +00:00
if (!fu->nextpr)
fu->nextpr = pr;
/* ignore nextpr -- its unused inside the loop and is
2008-02-11 11:44:38 +00:00
* uninitialized 1st time through.
*/
2001-11-02 11:39:46 +00:00
/* skip preceding text and up to the next % sign */
for (p1 = fmtp; *p1 && *p1 != '%'; ++p1)
continue;
2001-11-02 11:39:46 +00:00
/* only text in the string */
if (!*p1) {
pr->fmt = fmtp;
pr->flags = F_TEXT;
break;
}
/*
* get precision for %s -- if have a byte count, don't
* need it.
*/
if (fu->bcnt) {
sokay = USEBCNT;
/* skip to conversion character */
for (++p1; strchr(index_str, *p1); ++p1)
continue;
2001-11-02 11:39:46 +00:00
} else {
/* skip any special chars, field width */
while (strchr(index_str + 1, *++p1))
continue;
2001-11-02 11:39:46 +00:00
if (*p1 == '.' && isdigit(*++p1)) {
sokay = USEPREC;
prec = atoi(p1);
while (isdigit(*++p1))
continue;
2002-08-22 18:41:20 +00:00
} else
2001-11-02 11:39:46 +00:00
sokay = NOTOKAY;
}
p2 = p1 + 1; /* set end pointer */
2001-11-02 11:39:46 +00:00
/*
* figure out the byte count for each conversion;
* rewrite the format as necessary, set up blank-
2003-03-19 09:13:01 +00:00
* pbb_dump_adding for end of data.
2001-11-02 11:39:46 +00:00
*/
2003-03-19 09:13:01 +00:00
if (*p1 == 'c') {
2001-11-02 11:39:46 +00:00
pr->flags = F_CHAR;
DO_BYTE_COUNT_1:
2003-03-19 09:13:01 +00:00
byte_count_str = "\001";
DO_BYTE_COUNT:
2003-03-19 09:13:01 +00:00
if (fu->bcnt) {
do {
if (fu->bcnt == *byte_count_str) {
break;
}
} while (*++byte_count_str);
2001-11-02 11:39:46 +00:00
}
2003-03-19 09:13:01 +00:00
/* Unlike the original, output the remainder of the format string. */
if (!*byte_count_str) {
bb_error_msg_and_die("bad byte count for conversion character %s", p1);
2003-03-19 09:13:01 +00:00
}
pr->bcnt = *byte_count_str;
} else if (*p1 == 'l') {
2001-11-02 11:39:46 +00:00
++p2;
2003-03-19 09:13:01 +00:00
++p1;
DO_INT_CONV:
2003-03-19 09:13:01 +00:00
{
const char *e;
e = strchr(lcc, *p1);
if (!e) {
2003-03-19 09:13:01 +00:00
goto DO_BAD_CONV_CHAR;
}
2001-11-02 11:39:46 +00:00
pr->flags = F_INT;
2003-03-19 09:13:01 +00:00
if (e > lcc + 1) {
pr->flags = F_UINT;
}
byte_count_str = "\004\002\001";
goto DO_BYTE_COUNT;
2001-11-02 11:39:46 +00:00
}
/* NOTREACHED */
2003-03-19 09:13:01 +00:00
} else if (strchr(lcc, *p1)) {
goto DO_INT_CONV;
} else if (strchr("eEfgG", *p1)) {
2001-11-02 11:39:46 +00:00
pr->flags = F_DBL;
2003-03-19 09:13:01 +00:00
byte_count_str = "\010\004";
goto DO_BYTE_COUNT;
} else if (*p1 == 's') {
2001-11-02 11:39:46 +00:00
pr->flags = F_STR;
2003-03-19 09:13:01 +00:00
if (sokay == USEBCNT) {
2001-11-02 11:39:46 +00:00
pr->bcnt = fu->bcnt;
2003-03-19 09:13:01 +00:00
} else if (sokay == USEPREC) {
2001-11-02 11:39:46 +00:00
pr->bcnt = prec;
2003-03-19 09:13:01 +00:00
} else { /* NOTOKAY */
bb_error_msg_and_die("%%s requires a precision or a byte count");
2001-11-02 11:39:46 +00:00
}
2003-03-19 09:13:01 +00:00
} else if (*p1 == '_') {
2001-11-02 11:39:46 +00:00
++p2;
2002-08-22 18:41:20 +00:00
switch (p1[1]) {
2001-11-02 11:39:46 +00:00
case 'A':
dumper->endfu = fu;
2001-11-02 11:39:46 +00:00
fu->flags |= F_IGNORE;
/* FALLTHROUGH */
case 'a':
pr->flags = F_ADDRESS;
++p2;
2003-03-19 09:13:01 +00:00
if ((p1[2] != 'd') && (p1[2] != 'o') && (p1[2] != 'x')) {
goto DO_BAD_CONV_CHAR;
2001-11-02 11:39:46 +00:00
}
2003-03-19 09:13:01 +00:00
*p1 = p1[2];
2001-11-02 11:39:46 +00:00
break;
case 'c':
pr->flags = F_C;
2002-08-22 18:41:20 +00:00
/* *p1 = 'c'; set in conv_c */
2003-03-19 09:13:01 +00:00
goto DO_BYTE_COUNT_1;
2001-11-02 11:39:46 +00:00
case 'p':
pr->flags = F_P;
*p1 = 'c';
2003-03-19 09:13:01 +00:00
goto DO_BYTE_COUNT_1;
2001-11-02 11:39:46 +00:00
case 'u':
pr->flags = F_U;
2002-08-22 18:41:20 +00:00
/* *p1 = 'c'; set in conv_u */
2003-03-19 09:13:01 +00:00
goto DO_BYTE_COUNT_1;
2001-11-02 11:39:46 +00:00
default:
2003-03-19 09:13:01 +00:00
goto DO_BAD_CONV_CHAR;
2001-11-02 11:39:46 +00:00
}
2003-03-19 09:13:01 +00:00
} else {
DO_BAD_CONV_CHAR:
bb_error_msg_and_die("bad conversion character %%%s", p1);
2001-11-02 11:39:46 +00:00
}
/*
* copy to PR format string, set conversion character
* pointer, update original.
*/
savech = *p2;
p1[1] = '\0';
pr->fmt = xstrdup(fmtp);
2001-11-02 11:39:46 +00:00
*p2 = savech;
//Too early! xrealloc can move pr->fmt!
//pr->cchar = pr->fmt + (p1 - fmtp);
/* DBU:[dave@cray.com] w/o this, trailing fmt text, space is lost.
* Skip subsequent text and up to the next % sign and tack the
* additional text onto fmt: eg. if fmt is "%x is a HEX number",
* we lose the " is a HEX number" part of fmt.
*/
for (p3 = p2; *p3 && *p3 != '%'; p3++)
continue;
if (p3 > p2) {
savech = *p3;
*p3 = '\0';
pr->fmt = xrealloc(pr->fmt, strlen(pr->fmt) + (p3-p2) + 1);
strcat(pr->fmt, p2);
*p3 = savech;
p2 = p3;
}
pr->cchar = pr->fmt + (p1 - fmtp);
2001-11-02 11:39:46 +00:00
fmtp = p2;
/* only one conversion character if byte count */
2002-08-22 18:41:20 +00:00
if (!(pr->flags & F_ADDRESS) && fu->bcnt && nconv++) {
bb_error_msg_and_die("byte count with multiple conversion characters");
2001-11-02 11:39:46 +00:00
}
}
/*
* if format unit byte count not specified, figure it out
* so can adjust rep count later.
*/
if (!fu->bcnt)
for (pr = fu->nextpr; pr; pr = pr->nextpr)
fu->bcnt += pr->bcnt;
}
/*
* if the format string interprets any data at all, and it's
* not the same as the blocksize, and its last format unit
2001-11-02 11:39:46 +00:00
* interprets any data at all, and has no iteration count,
* repeat it as necessary.
*
* if, rep count is greater than 1, no trailing whitespace
* gets output from the last iteration of the format unit.
*/
2008-08-23 23:15:48 +00:00
for (fu = fs->nextfu; fu; fu = fu->nextfu) {
if (!fu->nextfu && fs->bcnt < dumper->blocksize
&& !(fu->flags & F_SETREP) && fu->bcnt
) {
fu->reps += (dumper->blocksize - fs->bcnt) / fu->bcnt;
}
2001-11-02 11:39:46 +00:00
if (fu->reps > 1) {
for (pr = fu->nextpr;; pr = pr->nextpr)
if (!pr->nextpr)
break;
for (p1 = pr->fmt, p2 = NULL; *p1; ++p1)
p2 = isspace(*p1) ? p1 : NULL;
if (p2)
pr->nospace = p2;
}
if (!fu->nextfu)
break;
}
}
static void do_skip(priv_dumper_t *dumper, const char *fname, int statok)
2001-11-02 11:39:46 +00:00
{
struct stat sbuf;
if (statok) {
if (fstat(STDIN_FILENO, &sbuf)) {
bb_simple_perror_msg_and_die(fname);
2001-11-02 11:39:46 +00:00
}
if (!(S_ISCHR(sbuf.st_mode) || S_ISBLK(sbuf.st_mode) || S_ISFIFO(sbuf.st_mode))
&& dumper->pub.dump_skip >= sbuf.st_size
) {
/* If bb_dump_size valid and pub.dump_skip >= size */
dumper->pub.dump_skip -= sbuf.st_size;
dumper->address += sbuf.st_size;
2001-11-02 11:39:46 +00:00
return;
}
}
if (fseek(stdin, dumper->pub.dump_skip, SEEK_SET)) {
bb_simple_perror_msg_and_die(fname);
2001-11-02 11:39:46 +00:00
}
dumper->address += dumper->pub.dump_skip;
dumper->savaddress = dumper->address;
dumper->pub.dump_skip = 0;
2001-11-02 11:39:46 +00:00
}
static NOINLINE int next(priv_dumper_t *dumper)
2001-11-02 11:39:46 +00:00
{
int statok;
for (;;) {
if (*dumper->argv) {
dumper->next__done = statok = 1;
if (!(freopen(*dumper->argv, "r", stdin))) {
bb_simple_perror_msg(*dumper->argv);
dumper->exitval = 1;
++dumper->argv;
2001-11-02 11:39:46 +00:00
continue;
}
} else {
if (dumper->next__done)
return 0; /* no next file */
dumper->next__done = 1;
2001-11-02 11:39:46 +00:00
statok = 0;
}
if (dumper->pub.dump_skip)
do_skip(dumper, statok ? *dumper->argv : "stdin", statok);
if (*dumper->argv)
++dumper->argv;
if (!dumper->pub.dump_skip)
return 1;
2001-11-02 11:39:46 +00:00
}
/* NOTREACHED */
}
static unsigned char *get(priv_dumper_t *dumper)
2001-11-02 11:39:46 +00:00
{
int n;
2001-11-02 11:39:46 +00:00
int need, nread;
int blocksize = dumper->blocksize;
2001-11-02 11:39:46 +00:00
if (!dumper->get__curp) {
dumper->address = (off_t)0; /*DBU:[dave@cray.com] initialize,initialize..*/
dumper->get__curp = xmalloc(blocksize);
dumper->get__savp = xzalloc(blocksize); /* need to be initialized */
2001-11-02 11:39:46 +00:00
} else {
unsigned char *tmp = dumper->get__curp;
dumper->get__curp = dumper->get__savp;
dumper->get__savp = tmp;
dumper->savaddress += blocksize;
dumper->address = dumper->savaddress;
2001-11-02 11:39:46 +00:00
}
need = blocksize;
nread = 0;
while (1) {
2001-11-02 11:39:46 +00:00
/*
* if read the right number of bytes, or at EOF for one file,
* and no other files are available, zero-pad the rest of the
* block and set the end flag.
*/
if (!dumper->pub.dump_length || (dumper->get__ateof && !next(dumper))) {
if (need == blocksize) {
return NULL;
2001-11-02 11:39:46 +00:00
}
if (dumper->pub.dump_vflag != ALL && !memcmp(dumper->get__curp, dumper->get__savp, nread)) {
if (dumper->pub.dump_vflag != DUP) {
puts("*");
2001-11-02 11:39:46 +00:00
}
return NULL;
2001-11-02 11:39:46 +00:00
}
memset(dumper->get__curp + nread, 0, need);
dumper->eaddress = dumper->address + nread;
return dumper->get__curp;
2001-11-02 11:39:46 +00:00
}
n = fread(dumper->get__curp + nread, sizeof(unsigned char),
dumper->pub.dump_length == -1 ? need : MIN(dumper->pub.dump_length, need), stdin);
2001-11-02 11:39:46 +00:00
if (!n) {
if (ferror(stdin)) {
bb_simple_perror_msg(dumper->argv[-1]);
2001-11-02 11:39:46 +00:00
}
dumper->get__ateof = 1;
2001-11-02 11:39:46 +00:00
continue;
}
dumper->get__ateof = 0;
if (dumper->pub.dump_length != -1) {
dumper->pub.dump_length -= n;
2001-11-02 11:39:46 +00:00
}
need -= n;
if (!need) {
if (dumper->pub.dump_vflag == ALL || dumper->pub.dump_vflag == FIRST
|| memcmp(dumper->get__curp, dumper->get__savp, blocksize)
) {
if (dumper->pub.dump_vflag == DUP || dumper->pub.dump_vflag == FIRST) {
dumper->pub.dump_vflag = WAIT;
2001-11-02 11:39:46 +00:00
}
return dumper->get__curp;
2001-11-02 11:39:46 +00:00
}
if (dumper->pub.dump_vflag == WAIT) {
puts("*");
2001-11-02 11:39:46 +00:00
}
dumper->pub.dump_vflag = DUP;
dumper->savaddress += blocksize;
dumper->address = dumper->savaddress;
need = blocksize;
2001-11-02 11:39:46 +00:00
nread = 0;
} else {
nread += n;
}
}
}
static void bpad(PR *pr)
2001-11-02 11:39:46 +00:00
{
char *p1, *p2;
2001-11-02 11:39:46 +00:00
/*
* remove all conversion flags; '-' is the only one valid
* with %s, and it's not useful here.
*/
pr->flags = F_BPAD;
*pr->cchar = 's';
for (p1 = pr->fmt; *p1 != '%'; ++p1)
continue;
for (p2 = ++p1; *p1 && strchr(" -0+#", *p1); ++p1)
if (pr->nospace)
pr->nospace--;
while ((*p2++ = *p1++) != 0)
continue;
2001-11-02 11:39:46 +00:00
}
static const char conv_str[] ALIGN1 =
2003-03-19 09:13:01 +00:00
"\0\\0\0"
"\007\\a\0" /* \a */
"\b\\b\0"
"\f\\b\0"
"\n\\n\0"
"\r\\r\0"
"\t\\t\0"
"\v\\v\0"
;
2003-03-19 09:13:01 +00:00
static void conv_c(PR *pr, unsigned char *p)
2001-11-02 11:39:46 +00:00
{
2003-03-19 09:13:01 +00:00
const char *str = conv_str;
char buf[10];
do {
if (*p == *str) {
++str;
goto strpr;
}
str += 4;
} while (*str);
if (isprint_asciionly(*p)) {
2001-11-02 11:39:46 +00:00
*pr->cchar = 'c';
printf(pr->fmt, *p);
2001-11-02 11:39:46 +00:00
} else {
2003-03-19 09:13:01 +00:00
sprintf(buf, "%03o", (int) *p);
str = buf;
strpr:
2001-11-02 11:39:46 +00:00
*pr->cchar = 's';
printf(pr->fmt, str);
}
}
static void conv_u(PR *pr, unsigned char *p)
2001-11-02 11:39:46 +00:00
{
static const char list[] ALIGN1 =
2003-03-19 09:13:01 +00:00
"nul\0soh\0stx\0etx\0eot\0enq\0ack\0bel\0"
"bs\0_ht\0_lf\0_vt\0_ff\0_cr\0_so\0_si\0_"
"dle\0dcl\0dc2\0dc3\0dc4\0nak\0syn\0etb\0"
"can\0em\0_sub\0esc\0fs\0_gs\0_rs\0_us";
2001-11-02 11:39:46 +00:00
/* od used nl, not lf */
if (*p <= 0x1f) {
*pr->cchar = 's';
printf(pr->fmt, list + (4 * (int)*p));
2001-11-02 11:39:46 +00:00
} else if (*p == 0x7f) {
*pr->cchar = 's';
printf(pr->fmt, "del");
} else if (*p < 0x7f) { /* isprint() */
2001-11-02 11:39:46 +00:00
*pr->cchar = 'c';
printf(pr->fmt, *p);
} else {
*pr->cchar = 'x';
2002-08-22 18:41:20 +00:00
printf(pr->fmt, (int) *p);
2001-11-02 11:39:46 +00:00
}
}
static void display(priv_dumper_t* dumper)
2001-11-02 11:39:46 +00:00
{
FS *fs;
FU *fu;
PR *pr;
int cnt;
unsigned char *bp, *savebp;
2003-03-19 09:13:01 +00:00
off_t saveaddress;
unsigned char savech = '\0';
2001-11-02 11:39:46 +00:00
while ((bp = get(dumper)) != NULL) {
fs = dumper->pub.fshead;
savebp = bp;
saveaddress = dumper->address;
for (; fs; fs = fs->nextfs, bp = savebp, dumper->address = saveaddress) {
2002-08-22 18:41:20 +00:00
for (fu = fs->nextfu; fu; fu = fu->nextfu) {
2001-11-02 11:39:46 +00:00
if (fu->flags & F_IGNORE) {
break;
}
for (cnt = fu->reps; cnt; --cnt) {
for (pr = fu->nextpr; pr; dumper->address += pr->bcnt,
bp += pr->bcnt, pr = pr->nextpr) {
if (dumper->eaddress && dumper->address >= dumper->eaddress
&& !(pr->flags & (F_TEXT | F_BPAD))
) {
2001-11-02 11:39:46 +00:00
bpad(pr);
}
2002-08-22 18:41:20 +00:00
if (cnt == 1 && pr->nospace) {
2001-11-02 11:39:46 +00:00
savech = *pr->nospace;
*pr->nospace = '\0';
2002-08-22 18:41:20 +00:00
}
/* PRINT; */
switch (pr->flags) {
case F_ADDRESS:
printf(pr->fmt, (unsigned) dumper->address);
2002-08-22 18:41:20 +00:00
break;
case F_BPAD:
printf(pr->fmt, "");
break;
case F_C:
conv_c(pr, bp);
break;
case F_CHAR:
printf(pr->fmt, *bp);
break;
case F_DBL: {
2002-08-22 18:41:20 +00:00
double dval;
float fval;
switch (pr->bcnt) {
case 4:
memcpy(&fval, bp, sizeof(fval));
2002-08-22 18:41:20 +00:00
printf(pr->fmt, fval);
2001-11-02 11:39:46 +00:00
break;
2002-08-22 18:41:20 +00:00
case 8:
memcpy(&dval, bp, sizeof(dval));
2002-08-22 18:41:20 +00:00
printf(pr->fmt, dval);
2001-11-02 11:39:46 +00:00
break;
}
2002-08-22 18:41:20 +00:00
break;
}
case F_INT: {
2002-08-22 18:41:20 +00:00
int ival;
short sval;
switch (pr->bcnt) {
case 1:
printf(pr->fmt, (int) *bp);
2001-11-02 11:39:46 +00:00
break;
2002-08-22 18:41:20 +00:00
case 2:
memcpy(&sval, bp, sizeof(sval));
2002-08-22 18:41:20 +00:00
printf(pr->fmt, (int) sval);
2001-11-02 11:39:46 +00:00
break;
2002-08-22 18:41:20 +00:00
case 4:
memcpy(&ival, bp, sizeof(ival));
2002-08-22 18:41:20 +00:00
printf(pr->fmt, ival);
2001-11-02 11:39:46 +00:00
break;
2002-08-22 18:41:20 +00:00
}
break;
}
case F_P:
printf(pr->fmt, isprint_asciionly(*bp) ? *bp : '.');
2002-08-22 18:41:20 +00:00
break;
case F_STR:
printf(pr->fmt, (char *) bp);
break;
case F_TEXT:
printf(pr->fmt);
break;
case F_U:
conv_u(pr, bp);
break;
case F_UINT: {
unsigned ival;
unsigned short sval;
2002-08-22 18:41:20 +00:00
switch (pr->bcnt) {
case 1:
printf(pr->fmt, (unsigned) *bp);
2001-11-02 11:39:46 +00:00
break;
2002-08-22 18:41:20 +00:00
case 2:
memcpy(&sval, bp, sizeof(sval));
printf(pr->fmt, (unsigned) sval);
2001-11-02 11:39:46 +00:00
break;
2002-08-22 18:41:20 +00:00
case 4:
memcpy(&ival, bp, sizeof(ival));
2002-08-22 18:41:20 +00:00
printf(pr->fmt, ival);
2001-11-02 11:39:46 +00:00
break;
}
2002-08-22 18:41:20 +00:00
break;
2001-11-02 11:39:46 +00:00
}
2002-08-22 18:41:20 +00:00
}
if (cnt == 1 && pr->nospace) {
2001-11-02 11:39:46 +00:00
*pr->nospace = savech;
}
}
}
}
}
}
if (dumper->endfu) {
2001-11-02 11:39:46 +00:00
/*
* if eaddress not set, error or file size was multiple
* of blocksize, and no partial block ever found.
2001-11-02 11:39:46 +00:00
*/
if (!dumper->eaddress) {
if (!dumper->address) {
2001-11-02 11:39:46 +00:00
return;
}
dumper->eaddress = dumper->address;
2001-11-02 11:39:46 +00:00
}
for (pr = dumper->endfu->nextpr; pr; pr = pr->nextpr) {
2002-08-22 18:41:20 +00:00
switch (pr->flags) {
2001-11-02 11:39:46 +00:00
case F_ADDRESS:
printf(pr->fmt, (unsigned) dumper->eaddress);
2001-11-02 11:39:46 +00:00
break;
case F_TEXT:
printf(pr->fmt);
2001-11-02 11:39:46 +00:00
break;
}
}
}
}
#define dumper ((priv_dumper_t*)pub_dumper)
int FAST_FUNC bb_dump_dump(dumper_t *pub_dumper, char **argv)
2001-11-02 11:39:46 +00:00
{
FS *tfs;
int blocksize;
2001-11-02 11:39:46 +00:00
2003-03-19 09:13:01 +00:00
/* figure out the data block bb_dump_size */
blocksize = 0;
tfs = dumper->pub.fshead;
while (tfs) {
2003-03-19 09:13:01 +00:00
tfs->bcnt = bb_dump_size(tfs);
if (blocksize < tfs->bcnt) {
blocksize = tfs->bcnt;
2001-11-02 11:39:46 +00:00
}
tfs = tfs->nextfs;
2001-11-02 11:39:46 +00:00
}
dumper->blocksize = blocksize;
2001-11-02 11:39:46 +00:00
/* rewrite the rules, do syntax checking */
for (tfs = dumper->pub.fshead; tfs; tfs = tfs->nextfs) {
rewrite(dumper, tfs);
2001-11-02 11:39:46 +00:00
}
dumper->argv = argv;
display(dumper);
2001-11-02 11:39:46 +00:00
return dumper->exitval;
2001-11-02 11:39:46 +00:00
}
void FAST_FUNC bb_dump_add(dumper_t* pub_dumper, const char *fmt)
2001-11-02 11:39:46 +00:00
{
const char *p;
char *p1;
char *p2;
2001-11-02 11:39:46 +00:00
FS *tfs;
FU *tfu, **nextfupp;
2003-03-19 09:13:01 +00:00
const char *savep;
2001-11-02 11:39:46 +00:00
/* start new linked list of format units */
tfs = xzalloc(sizeof(FS)); /*DBU:[dave@cray.com] start out NULL */
if (!dumper->pub.fshead) {
dumper->pub.fshead = tfs;
2001-11-02 11:39:46 +00:00
} else {
FS *fslast = dumper->pub.fshead;
while (fslast->nextfs)
fslast = fslast->nextfs;
fslast->nextfs = tfs;
2001-11-02 11:39:46 +00:00
}
nextfupp = &tfs->nextfu;
2001-11-02 11:39:46 +00:00
/* take the format string and break it up into format units */
2008-08-23 23:15:48 +00:00
p = fmt;
for (;;) {
p = skip_whitespace(p);
2001-11-02 11:39:46 +00:00
if (!*p) {
break;
}
/* allocate a new format unit and link it in */
/* NOSTRICT */
/* DBU:[dave@cray.com] zalloc so that forward pointers start out NULL */
tfu = xzalloc(sizeof(FU));
*nextfupp = tfu;
nextfupp = &tfu->nextfu;
2001-11-02 11:39:46 +00:00
tfu->reps = 1;
/* if leading digit, repetition count */
if (isdigit(*p)) {
for (savep = p; isdigit(*p); ++p)
continue;
2001-11-02 11:39:46 +00:00
if (!isspace(*p) && *p != '/') {
2003-03-19 09:13:01 +00:00
bb_error_msg_and_die("bad format {%s}", fmt);
2001-11-02 11:39:46 +00:00
}
/* may overwrite either white space or slash */
tfu->reps = atoi(savep);
tfu->flags = F_SETREP;
/* skip trailing white space */
p = skip_whitespace(++p);
2001-11-02 11:39:46 +00:00
}
/* skip slash and trailing white space */
2001-11-02 11:39:46 +00:00
if (*p == '/') {
p = skip_whitespace(++p);
2001-11-02 11:39:46 +00:00
}
/* byte count */
if (isdigit(*p)) {
2006-12-26 02:51:29 +00:00
// TODO: use bb_strtou
savep = p;
while (isdigit(*++p))
continue;
2001-11-02 11:39:46 +00:00
if (!isspace(*p)) {
2003-03-19 09:13:01 +00:00
bb_error_msg_and_die("bad format {%s}", fmt);
2001-11-02 11:39:46 +00:00
}
tfu->bcnt = atoi(savep);
/* skip trailing white space */
p = skip_whitespace(++p);
2001-11-02 11:39:46 +00:00
}
/* format */
if (*p != '"') {
2003-03-19 09:13:01 +00:00
bb_error_msg_and_die("bad format {%s}", fmt);
2001-11-02 11:39:46 +00:00
}
for (savep = ++p; *p != '"';) {
if (*p++ == 0) {
2003-03-19 09:13:01 +00:00
bb_error_msg_and_die("bad format {%s}", fmt);
2001-11-02 11:39:46 +00:00
}
}
tfu->fmt = xstrndup(savep, p - savep);
2002-08-22 18:41:20 +00:00
/* escape(tfu->fmt); */
2001-11-02 11:39:46 +00:00
p1 = tfu->fmt;
/* alphabetic escape sequences have to be done in place */
for (p2 = p1;; ++p1, ++p2) {
if (!*p1) {
*p2 = *p1;
break;
}
if (*p1 == '\\') {
2003-03-19 09:13:01 +00:00
const char *cs = conv_str + 4;
++p1;
*p2 = *p1;
do {
if (*p1 == cs[2]) {
*p2 = cs[0];
break;
}
cs += 4;
} while (*cs);
2001-11-02 11:39:46 +00:00
}
}
p++;
}
}
2002-08-22 18:41:20 +00:00
2001-11-02 11:39:46 +00:00
/*
* Copyright (c) 1989 The Regents of the University of California.
* All rights reserved.
*
* Redistribution and use in source and binary forms, with or without
* modification, are permitted provided that the following conditions
* are met:
* 1. Redistributions of source code must retain the above copyright
* notice, this list of conditions and the following disclaimer.
* 2. Redistributions in binary form must reproduce the above copyright
* notice, this list of conditions and the following disclaimer in the
* documentation and/or other materials provided with the distribution.
* 3. Neither the name of the University nor the names of its contributors
2001-11-02 11:39:46 +00:00
* may be used to endorse or promote products derived from this software
* without specific prior written permission.
*
* THIS SOFTWARE IS PROVIDED BY THE REGENTS AND CONTRIBUTORS ``AS IS'' AND
* ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
* IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE
* ARE DISCLAIMED. IN NO EVENT SHALL THE REGENTS OR CONTRIBUTORS BE LIABLE
* FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL
* DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS
* OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION)
* HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT
* LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY
* OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF
* SUCH DAMAGE.
*/