+/* vi: set sw=4 ts=4: */
/*
* 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.
+ * The Regents of the University of California. 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; either version 2 of the License, or
- * (at your option) any later version.
- *
- * This program is distributed in the hope that it will 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 to the Free Software
- * Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA 02111-1307 USA
+ * Licensed under GPLv2 or later, see file LICENSE in this source tree.
*
* Original copyright notice is retained at the end of this file.
*/
-
-#include <stdlib.h>
-#include <string.h>
-#include <ctype.h> /* for isdigit() */
-#include "dump.h"
#include "libbb.h"
+#include "dump.h"
+
+static const char dot_flags_width_chars[] ALIGN1 = ".#-+ 0123456789";
+
+static const char size_conv_str[] ALIGN1 =
+"\x1\x4\x4\x4\x4\x4\x4\x8\x8\x8\x8\010cdiouxXeEfgG";
+
+static const char int_convs[] ALIGN1 = "diouxX";
+
+
+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;
+}
+
-enum _vflag vflag = FIRST;
-FS *fshead; /* head of format strings */
-extern FS *fshead; /* head of format strings */
-extern int blocksize;
-static FU *endfu;
-static char **_argv;
-static off_t savaddress; /* saved address/offset in stream */
-static off_t eaddress; /* end address */
-static off_t address; /* address/offset in stream */
-off_t skip; /* bytes to skip */
-off_t saveaddress;
-int exitval; /* final exit value */
-int blocksize; /* data block size */
-int length = -1; /* max bytes to read */
-
-
-int size(FS *fs)
+static NOINLINE int bb_dump_size(FS *fs)
{
- register FU *fu;
- register int bcnt, cursize;
- register char *fmt;
+ FU *fu;
+ int bcnt, cur_size;
+ char *fmt;
+ const char *p;
int prec;
/* figure out the data block size needed for each format unit */
- for (cursize = 0, fu = fs->nextfu; fu; fu = fu->nextfu) {
+ for (cur_size = 0, fu = fs->nextfu; fu; fu = fu->nextfu) {
if (fu->bcnt) {
- cursize += fu->bcnt * fu->reps;
+ cur_size += fu->bcnt * fu->reps;
continue;
}
for (bcnt = prec = 0, fmt = fu->fmt; *fmt; ++fmt) {
* skip any special chars -- save precision in
* case it's a %s format.
*/
- while (index(".#-+ 0123456789" + 1, *++fmt));
+ while (strchr(dot_flags_width_chars + 1, *++fmt))
+ continue;
if (*fmt == '.' && isdigit(*++fmt)) {
prec = atoi(fmt);
- while (isdigit(*++fmt));
+ while (isdigit(*++fmt))
+ continue;
}
- switch(*fmt) {
- case 'c':
- bcnt += 1;
- break;
- case 'd': case 'i': case 'o': case 'u':
- case 'x': case 'X':
- bcnt += 4;
- break;
- case 'e': case 'E': case 'f': case 'g': case 'G':
- bcnt += 8;
- break;
- case 's':
- bcnt += prec;
- break;
- case '_':
- switch(*++fmt) {
- case 'c': case 'p': case 'u':
- bcnt += 1;
- break;
+ p = strchr(size_conv_str + 12, *fmt);
+ if (!p) {
+ if (*fmt == 's') {
+ bcnt += prec;
+ }
+ if (*fmt == '_') {
+ ++fmt;
+ if ((*fmt == 'c') || (*fmt == 'p') || (*fmt == 'u')) {
+ bcnt += 1;
+ }
}
+ } else {
+ bcnt += p[-12];
}
}
- cursize += bcnt * fu->reps;
+ cur_size += bcnt * fu->reps;
}
- return(cursize);
+ return cur_size;
}
-void rewrite(FS *fs)
+static NOINLINE void rewrite(priv_dumper_t *dumper, FS *fs)
{
- enum { NOTOKAY, USEBCNT, USEPREC } sokay;
- register PR *pr, **nextpr = NULL;
- register FU *fu;
- register char *p1, *p2;
- char savech, *fmtp;
- int nconv, prec = 0;
+ FU *fu;
for (fu = fs->nextfu; fu; fu = fu->nextfu) {
+ PR *pr;
+ char *p1, *p2, *p3;
+ char *fmtp;
+ int nconv = 0;
/*
* break each format unit into print units; each
* conversion character gets its own.
*/
- for (nconv = 0, fmtp = fu->fmt; *fmtp; nextpr = &pr->nextpr) {
- /* NOSTRICT */
- pr = (PR *)xmalloc(sizeof(PR));
+ for (fmtp = fu->fmt; *fmtp; ) {
+ unsigned len;
+ const char *prec;
+ const char *byte_count_str;
+
+ /* DBU:[dvae@cray.com] zalloc so that forward ptrs start out NULL */
+ pr = xzalloc(sizeof(*pr));
if (!fu->nextpr)
fu->nextpr = pr;
- else
- *nextpr = pr;
/* skip preceding text and up to the next % sign */
- for (p1 = fmtp; *p1 && *p1 != '%'; ++p1);
-
- /* only text in the string */
- if (!*p1) {
+ p1 = strchr(fmtp, '%');
+ if (!p1) { /* only text in the string */
pr->fmt = fmtp;
pr->flags = F_TEXT;
break;
* get precision for %s -- if have a byte count, don't
* need it.
*/
+ prec = NULL;
if (fu->bcnt) {
- sokay = USEBCNT;
/* skip to conversion character */
- for (++p1; index(".#-+ 0123456789", *p1); ++p1);
+ while (strchr(dot_flags_width_chars, *++p1))
+ continue;
} else {
/* skip any special chars, field width */
- while (index(".#-+ 0123456789" + 1, *++p1));
+ while (strchr(dot_flags_width_chars + 1, *++p1))
+ continue;
if (*p1 == '.' && isdigit(*++p1)) {
- sokay = USEPREC;
- prec = atoi(p1);
- while (isdigit(*++p1));
+ prec = p1;
+ while (isdigit(*++p1))
+ continue;
}
- else
- sokay = NOTOKAY;
}
- p2 = p1 + 1; /* set end pointer */
+ p2 = p1 + 1; /* set end pointer */
/*
* figure out the byte count for each conversion;
* rewrite the format as necessary, set up blank-
* padding for end of data.
*/
- switch(*p1) {
- case 'c':
+ if (*p1 == 'c') {
pr->flags = F_CHAR;
- switch(fu->bcnt) {
- case 0: case 1:
- pr->bcnt = 1;
- break;
- default:
- p1[1] = '\0';
- error_msg_and_die("bad byte count for conversion character %s.", p1);
+ DO_BYTE_COUNT_1:
+ byte_count_str = "\001";
+ DO_BYTE_COUNT:
+ if (fu->bcnt) {
+ for (;;) {
+ if (fu->bcnt == *byte_count_str)
+ break;
+ if (*++byte_count_str == 0)
+ bb_error_msg_and_die("bad byte count for conversion character %s", p1);
+ }
}
- break;
- case 'd': case 'i':
- pr->flags = F_INT;
- goto sw1;
- case 'l':
+ /* Unlike the original, output the remainder of the format string. */
+ pr->bcnt = *byte_count_str;
+ } else
+ if (*p1 == 'l') { /* %ld etc */
+ const char *e;
+
++p2;
- switch(p1[1]) {
- case 'd': case 'i':
- ++p1;
- pr->flags = F_INT;
- goto sw1;
- case 'o': case 'u': case 'x': case 'X':
- ++p1;
+ ++p1;
+ DO_INT_CONV:
+ e = strchr(int_convs, *p1); /* "diouxX"? */
+ if (!e)
+ goto DO_BAD_CONV_CHAR;
+ pr->flags = F_INT;
+ if (e > int_convs + 1) /* not d or i? */
pr->flags = F_UINT;
- goto sw1;
- default:
- p1[2] = '\0';
- error_msg_and_die("hexdump: bad conversion character %%%s.\n", p1);
- }
- /* NOTREACHED */
- case 'o': case 'u': case 'x': case 'X':
- pr->flags = F_UINT;
-sw1: switch(fu->bcnt) {
- case 0: case 4:
- pr->bcnt = 4;
- break;
- case 1:
- pr->bcnt = 1;
- break;
- case 2:
- pr->bcnt = 2;
- break;
- default:
- p1[1] = '\0';
- error_msg_and_die("bad byte count for conversion character %s.", p1);
- }
- break;
- case 'e': case 'E': case 'f': case 'g': case 'G':
+ byte_count_str = "\004\002\001";
+ goto DO_BYTE_COUNT;
+ } else
+ if (strchr(int_convs, *p1)) { /* %d etc */
+ goto DO_INT_CONV;
+ } else
+ if (strchr("eEfgG", *p1)) { /* floating point */
pr->flags = F_DBL;
- switch(fu->bcnt) {
- case 0: case 8:
- pr->bcnt = 8;
- break;
- case 4:
- pr->bcnt = 4;
- break;
- default:
- p1[1] = '\0';
- error_msg_and_die("bad byte count for conversion character %s.", p1);
- }
- break;
- case 's':
+ byte_count_str = "\010\004";
+ goto DO_BYTE_COUNT;
+ } else
+ if (*p1 == 's') {
pr->flags = F_STR;
- switch(sokay) {
- case NOTOKAY:
- error_msg_and_die("%%s requires a precision or a byte count.");
- case USEBCNT:
- pr->bcnt = fu->bcnt;
- break;
- case USEPREC:
- pr->bcnt = prec;
- break;
+ pr->bcnt = fu->bcnt;
+ if (fu->bcnt == 0) {
+ if (!prec)
+ bb_simple_error_msg_and_die("%%s needs precision or byte count");
+ pr->bcnt = atoi(prec);
}
- break;
- case '_':
- ++p2;
- switch(p1[1]) {
- case 'A':
- endfu = fu;
+ } else
+ if (*p1 == '_') {
+ p2++; /* move past a in "%_a" */
+ switch (p1[1]) {
+ case 'A': /* %_A[dox]: print address and the end */
+ dumper->endfu = fu;
fu->flags |= F_IGNORE;
/* FALLTHROUGH */
- case 'a':
+ case 'a': /* %_a[dox]: current address */
pr->flags = F_ADDRESS;
- ++p2;
- switch(p1[2]) {
- case 'd': case 'o': case'x':
- *p1 = p1[2];
- break;
- default:
- p1[3] = '\0';
- error_msg_and_die("hexdump: bad conversion character %%%s.\n", p1);
+ p2++; /* move past x in "%_ax" */
+ if ((p1[2] != 'd') && (p1[2] != 'o') && (p1[2] != 'x')) {
+ goto DO_BAD_CONV_CHAR;
}
+ *p1 = p1[2];
break;
- case 'c':
+ case 'c': /* %_c: chars, \ooo, \n \r \t etc */
pr->flags = F_C;
- /* *p1 = 'c'; set in conv_c */
- goto sw2;
- case 'p':
+ /* *p1 = 'c'; set in conv_c */
+ goto DO_BYTE_COUNT_1;
+ case 'p': /* %_p: chars, dots for nonprintable */
pr->flags = F_P;
*p1 = 'c';
- goto sw2;
- case 'u':
+ goto DO_BYTE_COUNT_1;
+ case 'u': /* %_p: chars, 'nul', 'esc' etc for nonprintable */
pr->flags = F_U;
- /* *p1 = 'c'; set in conv_u */
-sw2: switch(fu->bcnt) {
- case 0: case 1:
- pr->bcnt = 1;
- break;
- default:
- p1[2] = '\0';
- error_msg_and_die("bad byte count for conversion character %s.", p1);
- }
- break;
+ /* *p1 = 'c'; set in conv_u */
+ goto DO_BYTE_COUNT_1;
default:
- p1[2] = '\0';
- error_msg_and_die("hexdump: bad conversion character %%%s.\n", p1);
+ goto DO_BAD_CONV_CHAR;
}
- break;
- default:
- p1[1] = '\0';
- error_msg_and_die("hexdump: bad conversion character %%%s.\n", p1);
+ } else {
+ DO_BAD_CONV_CHAR:
+ bb_error_msg_and_die("bad conversion character %%%s", p1);
}
/*
* copy to PR format string, set conversion character
* pointer, update original.
*/
- savech = *p2;
- p1[1] = '\0';
- if (!(pr->fmt = strdup(fmtp)))
- perror_msg_and_die("hexdump");
- *p2 = savech;
- pr->cchar = pr->fmt + (p1 - fmtp);
+ len = (p1 - fmtp) + 1;
+ pr->fmt = xstrndup(fmtp, len);
+ /* 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) != 0) {
+ char *d;
+ pr->fmt = d = xrealloc(pr->fmt, len + (p3 - p2) + 1);
+ d += len;
+ do {
+ *d++ = *p2++;
+ } while (p2 != p3);
+ *d = '\0';
+ /* now p2 = p3 */
+ }
+ pr->cchar = pr->fmt + len - 1; /* must be after realloc! */
fmtp = p2;
/* only one conversion character if byte count */
- if (!(pr->flags&F_ADDRESS) && fu->bcnt && nconv++) {
- error_msg_and_die("hexdump: byte count with multiple conversion characters.\n");
+ if (!(pr->flags & F_ADDRESS) && fu->bcnt && nconv++) {
+ bb_simple_error_msg_and_die("byte count with multiple conversion characters");
}
}
/*
* if format unit byte count not specified, figure it out
* so can adjust rep count later.
*/
- if (!fu->bcnt)
+ if (fu->bcnt == 0)
for (pr = fu->nextpr; pr; pr = pr->nextpr)
fu->bcnt += pr->bcnt;
}
* interprets any data at all, and has no iteration count,
* repeat it as necessary.
*
- * if, rep count is greater than 1, no trailing whitespace
+ * if rep count is greater than 1, no trailing whitespace
* gets output from the last iteration of the format unit.
*/
- for (fu = fs->nextfu;; fu = fu->nextfu) {
- if (!fu->nextfu && fs->bcnt < blocksize &&
- !(fu->flags&F_SETREP) && fu->bcnt)
- fu->reps += (blocksize - fs->bcnt) / fu->bcnt;
- if (fu->reps > 1) {
+ 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;
+ }
+ if (fu->reps > 1 && fu->nextpr) {
+ PR *pr;
+ char *p1, *p2;
+
for (pr = fu->nextpr;; pr = pr->nextpr)
if (!pr->nextpr)
break;
- for (p1 = pr->fmt, p2 = NULL; *p1; ++p1)
+ p2 = NULL;
+ for (p1 = pr->fmt; *p1; ++p1)
p2 = isspace(*p1) ? p1 : NULL;
if (p2)
pr->nospace = p2;
}
- if (!fu->nextfu)
- break;
}
}
-static void doskip(char *fname, int statok)
+static void do_skip(priv_dumper_t *dumper, const char *fname)
{
struct stat sbuf;
- if (statok) {
- if (fstat(fileno(stdin), &sbuf)) {
- perror_msg_and_die("hexdump: %s", fname);
- }
- if ( ( ! (S_ISCHR(sbuf.st_mode) ||
- S_ISBLK(sbuf.st_mode) ||
- S_ISFIFO(sbuf.st_mode)) ) &&
- skip >= sbuf.st_size) {
- /* If size valid and skip >= size */
- skip -= sbuf.st_size;
- address += sbuf.st_size;
- return;
- }
+ xfstat(STDIN_FILENO, &sbuf, fname);
+ if (S_ISREG(sbuf.st_mode)
+ && dumper->pub.dump_skip >= sbuf.st_size
+ ) {
+ /* If st_size is valid and pub.dump_skip >= st_size */
+ dumper->pub.dump_skip -= sbuf.st_size;
+ dumper->address += sbuf.st_size;
+ return;
}
- if (fseek(stdin, skip, SEEK_SET)) {
- perror_msg_and_die("hexdump: %s", fname);
+ if (fseeko(stdin, dumper->pub.dump_skip, SEEK_SET)) {
+ bb_simple_perror_msg_and_die(fname);
}
- savaddress = address += skip;
- skip = 0;
+ dumper->address += dumper->pub.dump_skip;
+ dumper->savaddress = dumper->address;
+ dumper->pub.dump_skip = 0;
}
-int next(char **argv)
+static NOINLINE int next(priv_dumper_t *dumper)
{
- static int done;
- int statok;
-
- if (argv) {
- _argv = argv;
- return(1);
- }
for (;;) {
- if (*_argv) {
- if (!(freopen(*_argv, "r", stdin))) {
- perror_msg("%s", *_argv);
- exitval = 1;
- ++_argv;
- continue;
+ const char *fname = *dumper->argv;
+
+ if (fname) {
+ dumper->argv++;
+ if (NOT_LONE_DASH(fname)) {
+ if (!freopen(fname, "r", stdin)) {
+ bb_simple_perror_msg(fname);
+ dumper->exitval = 1;
+ continue;
+ }
}
- statok = done = 1;
} else {
- if (done++)
- return(0);
- statok = 0;
+ if (dumper->next__done)
+ return 0; /* no next file */
}
- if (skip)
- doskip(statok ? *_argv : "stdin", statok);
- if (*_argv)
- ++_argv;
- if (!skip)
- return(1);
+ dumper->next__done = 1;
+ if (dumper->pub.dump_skip)
+ do_skip(dumper, fname ? fname : "stdin");
+ if (dumper->pub.dump_skip == 0)
+ return 1;
}
/* NOTREACHED */
}
-static u_char *
-get(void)
+static unsigned char *get(priv_dumper_t *dumper)
{
- static int ateof = 1;
- static u_char *curp, *savp;
- register int n;
+ int n;
int need, nread;
- u_char *tmpp;
+ int blocksize = dumper->blocksize;
- if (!curp) {
- curp = (u_char *)xmalloc(blocksize);
- savp = (u_char *)xmalloc(blocksize);
+ 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 */
} else {
- tmpp = curp;
- curp = savp;
- savp = tmpp;
- address = savaddress += blocksize;
+ unsigned char *tmp = dumper->get__curp;
+ dumper->get__curp = dumper->get__savp;
+ dumper->get__savp = tmp;
+ dumper->savaddress += blocksize;
+ dumper->address = dumper->savaddress;
}
- for (need = blocksize, nread = 0;;) {
+ need = blocksize;
+ nread = 0;
+ while (1) {
/*
* 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 (!length || (ateof && !next((char **)NULL))) {
+ if (!dumper->pub.dump_length || (dumper->get__ateof && !next(dumper))) {
if (need == blocksize) {
- return((u_char *)NULL);
+ return NULL;
}
- if (vflag != ALL && !bcmp(curp, savp, nread)) {
- if (vflag != DUP) {
- printf("*\n");
+ if (dumper->pub.dump_vflag != ALL /* not "show all"? */
+ && dumper->pub.dump_vflag != FIRST /* not first line? */
+ && memcmp(dumper->get__curp, dumper->get__savp, nread) == 0 /* same data? */
+ ) {
+ if (dumper->pub.dump_vflag != DUP) {
+ puts("*");
}
- return((u_char *)NULL);
+ return NULL;
}
- bzero((char *)curp + nread, need);
- eaddress = address + nread;
- return(curp);
+ memset(dumper->get__curp + nread, 0, need);
+ dumper->eaddress = dumper->address + nread;
+ return dumper->get__curp;
}
- n = fread((char *)curp + nread, sizeof(u_char),
- length == -1 ? need : MIN(length, need), stdin);
- if (!n) {
+ n = fread(dumper->get__curp + nread, sizeof(unsigned char),
+ dumper->pub.dump_length == -1 ? need : MIN(dumper->pub.dump_length, need), stdin);
+ if (n == 0) {
if (ferror(stdin)) {
- perror_msg("%s", _argv[-1]);
+ bb_simple_perror_msg(dumper->argv[-1]);
}
- ateof = 1;
+ dumper->get__ateof = 1;
continue;
}
- ateof = 0;
- if (length != -1) {
- length -= n;
+ dumper->get__ateof = 0;
+ if (dumper->pub.dump_length != -1) {
+ dumper->pub.dump_length -= n;
}
- if (!(need -= n)) {
- if (vflag == ALL || vflag == FIRST ||
- bcmp(curp, savp, blocksize)) {
- if (vflag == DUP || vflag == FIRST) {
- vflag = WAIT;
+ need -= n;
+ if (need == 0) {
+ if (dumper->pub.dump_vflag == ALL /* "show all"? */
+ || dumper->pub.dump_vflag == FIRST /* first line? */
+ || memcmp(dumper->get__curp, dumper->get__savp, blocksize) != 0 /* not same data? */
+ ) {
+ if (dumper->pub.dump_vflag == DUP || dumper->pub.dump_vflag == FIRST) {
+ dumper->pub.dump_vflag = WAIT;
}
- return(curp);
+ return dumper->get__curp;
}
- if (vflag == WAIT) {
- printf("*\n");
+ if (dumper->pub.dump_vflag == WAIT) {
+ puts("*");
}
- vflag = DUP;
- address = savaddress += blocksize;
+ dumper->pub.dump_vflag = DUP;
+ dumper->savaddress += blocksize;
+ dumper->address = dumper->savaddress;
need = blocksize;
nread = 0;
} else {
static void bpad(PR *pr)
{
- register char *p1, *p2;
+ char *p1, *p2;
/*
* remove all conversion flags; '-' is the only one valid
*/
pr->flags = F_BPAD;
*pr->cchar = 's';
- for (p1 = pr->fmt; *p1 != '%'; ++p1);
- for (p2 = ++p1; *p1 && index(" -0+#", *p1); ++p1);
- while ((*p2++ = *p1++) != 0) ;
+ 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;
}
-void conv_c(PR *pr, u_char *p)
+static const char conv_str[] ALIGN1 =
+ "\0" "\\""0""\0"
+ "\007""\\""a""\0" /* \a */
+ "\b" "\\""b""\0"
+ "\f" "\\""f""\0"
+ "\n" "\\""n""\0"
+ "\r" "\\""r""\0"
+ "\t" "\\""t""\0"
+ "\v" "\\""v""\0"
+ ;
+
+static void conv_c(PR *pr, unsigned char *p)
{
- char buf[10], *str;
-
- switch(*p) {
- case '\0':
- str = "\\0";
- goto strpr;
- /* case '\a': */
- case '\007':
- str = "\\a";
- goto strpr;
- case '\b':
- str = "\\b";
- goto strpr;
- case '\f':
- str = "\\f";
- goto strpr;
- case '\n':
- str = "\\n";
- goto strpr;
- case '\r':
- str = "\\r";
- goto strpr;
- case '\t':
- str = "\\t";
- goto strpr;
- case '\v':
- str = "\\v";
- goto strpr;
- default:
- break;
- }
- if (isprint(*p)) {
+ const char *str = conv_str;
+
+ do {
+ if (*p == *str) {
+ ++str;
+ goto strpr; /* map e.g. '\n' to "\\n" */
+ }
+ str += 4;
+ } while (*str);
+
+ if (isprint_asciionly(*p)) {
*pr->cchar = 'c';
- (void)printf(pr->fmt, *p);
+ printf(pr->fmt, *p);
} else {
- sprintf(str = buf, "%03o", (int)*p);
-strpr:
+ char buf[4];
+ /* gcc-8.0.1 needs lots of casts to shut up */
+ sprintf(buf, "%03o", (unsigned)(uint8_t)*p);
+ str = buf;
+ strpr:
*pr->cchar = 's';
printf(pr->fmt, str);
}
}
-void conv_u(PR *pr, u_char *p)
+static void conv_u(PR *pr, unsigned char *p)
{
- static char *list[] = {
- "nul", "soh", "stx", "etx", "eot", "enq", "ack", "bel",
- "bs", "ht", "lf", "vt", "ff", "cr", "so", "si",
- "dle", "dcl", "dc2", "dc3", "dc4", "nak", "syn", "etb",
- "can", "em", "sub", "esc", "fs", "gs", "rs", "us",
- };
+ static const char list[] ALIGN1 =
+ "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";
/* od used nl, not lf */
if (*p <= 0x1f) {
*pr->cchar = 's';
- printf(pr->fmt, list[*p]);
+ printf(pr->fmt, list + (4 * (int)*p));
} else if (*p == 0x7f) {
*pr->cchar = 's';
printf(pr->fmt, "del");
- } else if (isprint(*p)) {
+ } else if (*p < 0x7f) { /* isprint() */
*pr->cchar = 'c';
printf(pr->fmt, *p);
} else {
*pr->cchar = 'x';
- printf(pr->fmt, (int)*p);
+ printf(pr->fmt, (int) *p);
}
}
-void display(void)
+static void display(priv_dumper_t* dumper)
{
-// extern FU *endfu;
- register FS *fs;
- register FU *fu;
- register PR *pr;
- register int cnt;
- register u_char *bp;
-// off_t saveaddress;
- u_char savech = 0, *savebp;
-
- while ((bp = get()) != NULL) {
- for (fs = fshead, savebp = bp, saveaddress = address; fs;
- fs = fs->nextfs, bp = savebp, address = saveaddress) {
- for (fu = fs->nextfu; fu; fu = fu->nextfu) {
+ FS *fs;
+ FU *fu;
+ PR *pr;
+ int cnt;
+ unsigned char *bp, *savebp;
+ off_t saveaddress;
+ unsigned char savech = '\0';
+
+ while ((bp = get(dumper)) != NULL) {
+ fs = dumper->pub.fshead;
+ savebp = bp;
+ saveaddress = dumper->address;
+ for (; fs; fs = fs->nextfs, bp = savebp, dumper->address = saveaddress) {
+ for (fu = fs->nextfu; fu; fu = fu->nextfu) {
if (fu->flags & F_IGNORE) {
break;
}
for (cnt = fu->reps; cnt; --cnt) {
- for (pr = fu->nextpr; pr; address += pr->bcnt,
- bp += pr->bcnt, pr = pr->nextpr) {
- if (eaddress && address >= eaddress &&
- !(pr->flags&(F_TEXT|F_BPAD))) {
+ 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))
+ ) {
bpad(pr);
}
- if (cnt == 1 && pr->nospace) {
+ if (cnt == 1 && pr->nospace) {
savech = *pr->nospace;
*pr->nospace = '\0';
- }
-// PRINT;
- switch(pr->flags) {
- case F_ADDRESS:
- printf(pr->fmt, address);
- break;
- case F_BPAD:
- printf(pr->fmt, "");
- break;
- case F_C:
- conv_c(pr, bp);
- break;
- case F_CHAR:
- printf(pr->fmt, *bp);
+ }
+/* PRINT; */
+ switch (pr->flags) {
+ case F_ADDRESS:
+ printf(pr->fmt, (unsigned) dumper->address);
+ 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: {
+ double dval;
+ float fval;
+
+ switch (pr->bcnt) {
+ case 4:
+ memcpy(&fval, bp, sizeof(fval));
+ printf(pr->fmt, fval);
break;
- case F_DBL: {
- double dval;
- float fval;
- switch(pr->bcnt) {
- case 4:
- bcopy((char *)bp, (char *)&fval, sizeof(fval));
- printf(pr->fmt, fval);
- break;
- case 8:
- bcopy((char *)bp, (char *)&dval, sizeof(dval));
- printf(pr->fmt, dval);
- break;
- }
+ case 8:
+ memcpy(&dval, bp, sizeof(dval));
+ printf(pr->fmt, dval);
break;
}
- case F_INT: {
- int ival;
- short sval;
- switch(pr->bcnt) {
- case 1:
- printf(pr->fmt, (int)*bp);
- break;
- case 2:
- bcopy((char *)bp, (char *)&sval, sizeof(sval));
- printf(pr->fmt, (int)sval);
- break;
- case 4:
- bcopy((char *)bp, (char *)&ival, sizeof(ival));
- printf(pr->fmt, ival);
- break;
- }
+ break;
+ }
+ case F_INT: {
+ int ival;
+ short sval;
+
+ switch (pr->bcnt) {
+ case 1:
+ printf(pr->fmt, (int) *bp);
break;
- }
- case F_P:
- printf(pr->fmt, isprint(*bp) ? *bp : '.');
+ case 2:
+ memcpy(&sval, bp, sizeof(sval));
+ printf(pr->fmt, (int) sval);
break;
- case F_STR:
- printf(pr->fmt, (char *)bp);
+ case 4:
+ memcpy(&ival, bp, sizeof(ival));
+ printf(pr->fmt, ival);
break;
- case F_TEXT:
- printf(pr->fmt);
+ }
+ break;
+ }
+ case F_P:
+ printf(pr->fmt, isprint_asciionly(*bp) ? *bp : '.');
+ 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;
+
+ switch (pr->bcnt) {
+ case 1:
+ printf(pr->fmt, (unsigned) *bp);
break;
- case F_U:
- conv_u(pr, bp);
+ case 2:
+ memcpy(&sval, bp, sizeof(sval));
+ printf(pr->fmt, (unsigned) sval);
break;
- case F_UINT: {
- u_int ival;
- u_short sval;
- switch(pr->bcnt) {
- case 1:
- printf(pr->fmt, (u_int)*bp);
- break;
- case 2:
- bcopy((char *)bp, (char *)&sval, sizeof(sval));
- printf(pr->fmt, (u_int)sval);
- break;
- case 4:
- bcopy((char *)bp, (char *)&ival, sizeof(ival));
- printf(pr->fmt, ival);
- break;
- }
+ case 4:
+ memcpy(&ival, bp, sizeof(ival));
+ printf(pr->fmt, ival);
break;
}
+ break;
+ }
}
- if (cnt == 1 && pr->nospace) {
+ if (cnt == 1 && pr->nospace) {
*pr->nospace = savech;
}
}
}
}
}
- if (endfu) {
+ if (dumper->endfu) {
/*
- * if eaddress not set, error or file size was multiple of
- * blocksize, and no partial block ever found.
+ * if eaddress not set, error or file size was multiple
+ * of blocksize, and no partial block ever found.
*/
- if (!eaddress) {
- if (!address) {
+ if (!dumper->eaddress) {
+ if (!dumper->address) {
return;
}
- eaddress = address;
+ dumper->eaddress = dumper->address;
}
- for (pr = endfu->nextpr; pr; pr = pr->nextpr) {
- switch(pr->flags) {
+ for (pr = dumper->endfu->nextpr; pr; pr = pr->nextpr) {
+ switch (pr->flags) {
case F_ADDRESS:
- (void)printf(pr->fmt, eaddress);
+ printf(pr->fmt, (unsigned) dumper->eaddress);
break;
case F_TEXT:
- (void)printf(pr->fmt);
+ printf(pr->fmt);
break;
}
}
}
}
-int dump(char **argv)
+#define dumper ((priv_dumper_t*)pub_dumper)
+int FAST_FUNC bb_dump_dump(dumper_t *pub_dumper, char **argv)
{
- register FS *tfs;
+ FS *tfs;
+ int blocksize;
/* figure out the data block size */
- for (blocksize = 0, tfs = fshead; tfs; tfs = tfs->nextfs) {
- tfs->bcnt = size(tfs);
+ blocksize = 0;
+ tfs = dumper->pub.fshead;
+ while (tfs) {
+ tfs->bcnt = bb_dump_size(tfs);
if (blocksize < tfs->bcnt) {
blocksize = tfs->bcnt;
}
+ tfs = tfs->nextfs;
}
+ dumper->blocksize = blocksize;
+
/* rewrite the rules, do syntax checking */
- for (tfs = fshead; tfs; tfs = tfs->nextfs) {
- rewrite(tfs);
+ for (tfs = dumper->pub.fshead; tfs; tfs = tfs->nextfs) {
+ rewrite(dumper, tfs);
}
- next(argv);
- display();
+ dumper->argv = argv;
+ display(dumper);
- return(exitval);
+ return dumper->exitval;
}
-void add(char *fmt)
+void FAST_FUNC bb_dump_add(dumper_t* pub_dumper, const char *fmt)
{
- register char *p;
- register char *p1;
- register char *p2;
- static FS **nextfs;
+ const char *p;
FS *tfs;
- FU *tfu, **nextfu;
- char *savep;
+ FU *tfu, **nextfupp;
+ const char *savep;
/* start new linked list of format units */
- /* NOSTRICT */
- tfs = (FS *)xmalloc(sizeof(FS));
- if (!fshead) {
- fshead = tfs;
+ tfs = xzalloc(sizeof(FS)); /*DBU:[dave@cray.com] start out NULL */
+ if (!dumper->pub.fshead) {
+ dumper->pub.fshead = tfs;
} else {
- *nextfs = tfs;
+ FS *fslast = dumper->pub.fshead;
+ while (fslast->nextfs)
+ fslast = fslast->nextfs;
+ fslast->nextfs = tfs;
}
- nextfs = &tfs->nextfs;
- nextfu = &tfs->nextfu;
+ nextfupp = &tfs->nextfu;
/* take the format string and break it up into format units */
- for (p = fmt;;) {
- /* skip leading white space */
- for (; isspace(*p); ++p);
- if (!*p) {
+ p = fmt;
+ for (;;) {
+ p = skip_whitespace(p);
+ if (*p == '\0') {
break;
}
/* allocate a new format unit and link it in */
/* NOSTRICT */
- tfu = (FU *)xmalloc(sizeof(FU));
- *nextfu = tfu;
- nextfu = &tfu->nextfu;
+ /* DBU:[dave@cray.com] zalloc so that forward pointers start out NULL */
+ tfu = xzalloc(sizeof(FU));
+ *nextfupp = tfu;
+ nextfupp = &tfu->nextfu;
tfu->reps = 1;
/* if leading digit, repetition count */
if (isdigit(*p)) {
- for (savep = p; isdigit(*p); ++p);
+ for (savep = p; isdigit(*p); ++p)
+ continue;
if (!isspace(*p) && *p != '/') {
- error_msg_and_die("hexdump: bad format {%s}", fmt);
+ bb_error_msg_and_die("bad format {%s}", fmt);
}
/* may overwrite either white space or slash */
tfu->reps = atoi(savep);
tfu->flags = F_SETREP;
/* skip trailing white space */
- for (++p; isspace(*p); ++p);
+ p = skip_whitespace(++p);
}
/* skip slash and trailing white space */
if (*p == '/') {
- while (isspace(*++p));
+ p = skip_whitespace(p + 1);
}
/* byte count */
if (isdigit(*p)) {
- for (savep = p; isdigit(*p); ++p);
+// TODO: use bb_strtou
+ savep = p;
+ while (isdigit(*++p))
+ continue;
if (!isspace(*p)) {
- error_msg_and_die("hexdump: bad format {%s}", fmt);
+ bb_error_msg_and_die("bad format {%s}", fmt);
}
+// Above check prohibits formats such as '/1"%02x"' - it requires space after 1.
+// Other than this, formats can be pretty much jammed together:
+// "%07_ax:"8/2 "%04x|""\n"
+// but this space is required. The check *can* be removed, but
+// keeping it to stay compat with util-linux hexdump.
tfu->bcnt = atoi(savep);
/* skip trailing white space */
- for (++p; isspace(*p); ++p);
+ p = skip_whitespace(p + 1);
}
/* format */
if (*p != '"') {
- error_msg_and_die("hexdump: bad format {%s}", fmt);
+ bb_error_msg_and_die("bad format {%s}", fmt);
}
for (savep = ++p; *p != '"';) {
- if (*p++ == 0) {
- error_msg_and_die("hexdump: bad format {%s}", fmt);
+ if (*p++ == '\0') {
+ bb_error_msg_and_die("bad format {%s}", fmt);
}
}
- if (!(tfu->fmt = malloc(p - savep + 1))) {
- perror_msg_and_die("hexdump");
- }
- strncpy(tfu->fmt, savep, p - savep);
- tfu->fmt[p - savep] = '\0';
-// escape(tfu->fmt);
-
- p1 = tfu->fmt;
+ tfu->fmt = xstrndup(savep, p - savep);
/* alphabetic escape sequences have to be done in place */
+ strcpy_and_process_escape_sequences(tfu->fmt, tfu->fmt);
+ /* unknown mappings are not changed: "\z" -> '\\' 'z' */
+ /* trailing backslash, if any, is preserved */
+#if 0
+ char *p1;
+ char *p2;
+ p1 = tfu->fmt;
for (p2 = p1;; ++p1, ++p2) {
- if (!*p1) {
- *p2 = *p1;
+ *p2 = *p1;
+ if (*p1 == '\0')
break;
- }
+
if (*p1 == '\\') {
- switch(*++p1) {
- case 'a':
- /* *p2 = '\a'; */
- *p2 = '\007';
- break;
- case 'b':
- *p2 = '\b';
- break;
- case 'f':
- *p2 = '\f';
- break;
- case 'n':
- *p2 = '\n';
- break;
- case 'r':
- *p2 = '\r';
- break;
- case 't':
- *p2 = '\t';
- break;
- case 'v':
- *p2 = '\v';
- break;
- default:
- *p2 = *p1;
+ const char *cs;
+
+ p1++;
+ *p2 = *p1;
+ if (*p1 == '\0') {
+ /* "...\" trailing backslash. Eaten. */
break;
}
+ cs = conv_str + 4; /* skip NUL element */
+ do {
+ /* map e.g. "\n" -> '\n' */
+ if (*p1 == cs[2]) {
+ *p2 = cs[0];
+ break;
+ }
+ cs += 4;
+ } while (*cs);
+ /* unknown mappings remove bkslash: "\z" -> 'z' */
}
}
+#endif
p++;
}
}
+
/*
* Copyright (c) 1989 The Regents of the University of California.
* All rights reserved.
* 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. All advertising materials mentioning features or use of this software
- * must display the following acknowledgement:
- * This product includes software developed by the University of
- * California, Berkeley and its contributors.
- * 4. Neither the name of the University nor the names of its contributors
+ * 3. Neither the name of the University nor the names of its contributors
* 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
+ * 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
projects / oweals / busybox.git / blobdiff