#include <stdlib.h>
#include <string.h>
+#include <unistd.h>
#include <ctype.h> /* for isdigit() */
-#include "dump.h"
#include "libbb.h"
+#include "dump.h"
-enum _vflag vflag = FIRST;
-FS *fshead; /* head of format strings */
-extern FS *fshead; /* head of format strings */
-extern int blocksize;
+enum _vflag bb_dump_vflag = FIRST;
+FS *bb_dump_fshead; /* head of format strings */
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 */
+off_t bb_dump_skip; /* bytes to skip */
+static int exitval; /* final exit value */
+int bb_dump_blocksize; /* data block size */
+int bb_dump_length = -1; /* max bytes to read */
+
+static const char index_str[] = ".#-+ 0123456789";
+static const char size_conv_str[] =
+"\x1\x4\x4\x4\x4\x4\x4\x8\x8\x8\x8\010cdiouxXeEfgG";
-int size(FS * fs)
+static const char lcc[] = "diouxX";
+
+int bb_dump_size(FS * fs)
{
register FU *fu;
- register int bcnt, cursize;
+ register int bcnt, cur_size;
register 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) {
+ /* figure out the data block bb_dump_size needed for each format unit */
+ 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) {
if (*fmt != '%')
continue;
/*
- * skip any special chars -- save precision in
+ * bb_dump_skip any special chars -- save precision in
* case it's a %s format.
*/
- while (index(".#-+ 0123456789" + 1, *++fmt));
+ while (strchr(index_str + 1, *++fmt));
if (*fmt == '.' && isdigit(*++fmt)) {
prec = atoi(fmt);
while (isdigit(*++fmt));
}
- 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;
+ if (!(p = strchr(size_conv_str + 12, *fmt))) {
+ if (*fmt == 's') {
+ bcnt += prec;
+ } else if (*fmt == '_') {
+ ++fmt;
+ if ((*fmt == 'c') || (*fmt == 'p') || (*fmt == 'u')) {
+ bcnt += 1;
+ }
}
+ } else {
+ bcnt += size_conv_str[p - (size_conv_str + 12)];
}
}
- cursize += bcnt * fu->reps;
+ cur_size += bcnt * fu->reps;
}
- return (cursize);
+ return (cur_size);
}
-void rewrite(FS * fs)
+static void rewrite(FS * fs)
{
enum { NOTOKAY, USEBCNT, USEPREC } sokay;
register PR *pr, **nextpr = NULL;
register FU *fu;
- register char *p1, *p2;
+ register char *p1, *p2, *p3;
char savech, *fmtp;
+ const char *byte_count_str;
int nconv, prec = 0;
for (fu = fs->nextfu; fu; fu = fu->nextfu) {
*/
for (nconv = 0, fmtp = fu->fmt; *fmtp; nextpr = &pr->nextpr) {
/* NOSTRICT */
- pr = (PR *) xmalloc(sizeof(PR));
+ /* DBU:[dvae@cray.com] calloc so that forward ptrs start out NULL*/
+ pr = (PR *) xcalloc(1,sizeof(PR));
if (!fu->nextpr)
fu->nextpr = pr;
- else
- *nextpr = pr;
+ /* ignore nextpr -- its unused inside the loop and is
+ * uninitialized 1st time thru.
+ */
- /* skip preceding text and up to the next % sign */
+ /* bb_dump_skip preceding text and up to the next % sign */
for (p1 = fmtp; *p1 && *p1 != '%'; ++p1);
/* only text in the string */
*/
if (fu->bcnt) {
sokay = USEBCNT;
- /* skip to conversion character */
- for (++p1; index(".#-+ 0123456789", *p1); ++p1);
+ /* bb_dump_skip to conversion character */
+ for (++p1; strchr(index_str, *p1); ++p1);
} else {
- /* skip any special chars, field width */
- while (index(".#-+ 0123456789" + 1, *++p1));
+ /* bb_dump_skip any special chars, field width */
+ while (strchr(index_str + 1, *++p1));
if (*p1 == '.' && isdigit(*++p1)) {
sokay = USEPREC;
prec = atoi(p1);
/*
* figure out the byte count for each conversion;
* rewrite the format as necessary, set up blank-
- * padding for end of data.
+ * pbb_dump_adding 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) {
+ do {
+ if (fu->bcnt == *byte_count_str) {
+ break;
+ }
+ } while (*++byte_count_str);
}
- break;
- case 'd':
- case 'i':
- pr->flags = F_INT;
- goto sw1;
- case 'l':
+ /* 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);
+ }
+ pr->bcnt = *byte_count_str;
+ } else if (*p1 == 'l') {
++p2;
- switch (p1[1]) {
- case 'd':
- case 'i':
- ++p1;
+ ++p1;
+ DO_INT_CONV:
+ {
+ const char *e;
+ if (!(e = strchr(lcc, *p1))) {
+ goto DO_BAD_CONV_CHAR;
+ }
pr->flags = F_INT;
- goto sw1;
- case 'o':
- case 'u':
- case 'x':
- case 'X':
- ++p1;
- pr->flags = F_UINT;
- goto sw1;
- default:
- p1[2] = '\0';
- error_msg_and_die
- ("hexdump: bad conversion character %%%s.\n", p1);
+ if (e > lcc + 1) {
+ pr->flags = F_UINT;
+ }
+ byte_count_str = "\004\002\001";
+ goto DO_BYTE_COUNT;
}
/* 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':
+ } else if (strchr(lcc, *p1)) {
+ goto DO_INT_CONV;
+ } else if (strchr("eEfgG", *p1)) {
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:
+ if (sokay == USEBCNT) {
pr->bcnt = fu->bcnt;
- break;
- case USEPREC:
+ } else if (sokay == USEPREC) {
pr->bcnt = prec;
- break;
+ } else { /* NOTOKAY */
+ bb_error_msg_and_die("%%s requires a precision or a byte count.");
}
- break;
- case '_':
+ } else if (*p1 == '_') {
++p2;
switch (p1[1]) {
case 'A':
case 'a':
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);
+ if ((p1[2] != 'd') && (p1[2] != 'o') && (p1[2] != 'x')) {
+ goto DO_BAD_CONV_CHAR;
}
+ *p1 = p1[2];
break;
case 'c':
pr->flags = F_C;
/* *p1 = 'c'; set in conv_c */
- goto sw2;
+ goto DO_BYTE_COUNT_1;
case 'p':
pr->flags = F_P;
*p1 = 'c';
- goto sw2;
+ goto DO_BYTE_COUNT_1;
case 'u':
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;
+ 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.\n", p1);
}
/*
*/
savech = *p2;
p1[1] = '\0';
- if (!(pr->fmt = strdup(fmtp)))
- perror_msg_and_die("hexdump");
+ pr->fmt = bb_xstrdup(fmtp);
*p2 = savech;
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++);
+ if (p3 > p2)
+ {
+ savech = *p3;
+ *p3 = '\0';
+ if (!(pr->fmt = realloc(pr->fmt, strlen(pr->fmt)+(p3-p2)+1)))
+ bb_perror_msg_and_die("hexdump");
+ strcat(pr->fmt, p2);
+ *p3 = savech;
+ p2 = p3;
+ }
+
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");
+ bb_error_msg_and_die("byte count with multiple conversion characters.\n");
}
}
/*
}
/*
* if the format string interprets any data at all, and it's
- * not the same as the blocksize, and its last format unit
+ * not the same as the bb_dump_blocksize, and its last format unit
* interprets any data at all, and has no iteration count,
* repeat it as necessary.
*
* gets output from the last iteration of the format unit.
*/
for (fu = fs->nextfu;; fu = fu->nextfu) {
- if (!fu->nextfu && fs->bcnt < blocksize &&
+ if (!fu->nextfu && fs->bcnt < bb_dump_blocksize &&
!(fu->flags & F_SETREP) && fu->bcnt)
- fu->reps += (blocksize - fs->bcnt) / fu->bcnt;
+ fu->reps += (bb_dump_blocksize - fs->bcnt) / fu->bcnt;
if (fu->reps > 1) {
for (pr = fu->nextpr;; pr = pr->nextpr)
if (!pr->nextpr)
}
}
-static void doskip(char *fname, int statok)
+static void do_skip(char *fname, int statok)
{
struct stat sbuf;
if (statok) {
- if (fstat(fileno(stdin), &sbuf)) {
- perror_msg_and_die("hexdump: %s", fname);
+ if (fstat(STDIN_FILENO, &sbuf)) {
+ bb_perror_msg_and_die("%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;
+ S_ISFIFO(sbuf.st_mode))) && bb_dump_skip >= sbuf.st_size) {
+ /* If bb_dump_size valid and bb_dump_skip >= size */
+ bb_dump_skip -= sbuf.st_size;
address += sbuf.st_size;
return;
}
}
- if (fseek(stdin, skip, SEEK_SET)) {
- perror_msg_and_die("hexdump: %s", fname);
+ if (fseek(stdin, bb_dump_skip, SEEK_SET)) {
+ bb_perror_msg_and_die("%s", fname);
}
- savaddress = address += skip;
- skip = 0;
+ savaddress = address += bb_dump_skip;
+ bb_dump_skip = 0;
}
-int next(char **argv)
+static int next(char **argv)
{
static int done;
int statok;
for (;;) {
if (*_argv) {
if (!(freopen(*_argv, "r", stdin))) {
- perror_msg("%s", *_argv);
+ bb_perror_msg("%s", *_argv);
exitval = 1;
++_argv;
continue;
return (0);
statok = 0;
}
- if (skip)
- doskip(statok ? *_argv : "stdin", statok);
+ if (bb_dump_skip)
+ do_skip(statok ? *_argv : "stdin", statok);
if (*_argv)
++_argv;
- if (!skip)
+ if (!bb_dump_skip)
return (1);
}
/* NOTREACHED */
static u_char *get(void)
{
static int ateof = 1;
- static u_char *curp, *savp;
+ static u_char *curp=NULL, *savp; /*DBU:[dave@cray.com]initialize curp */
register int n;
int need, nread;
u_char *tmpp;
if (!curp) {
- curp = (u_char *) xmalloc(blocksize);
- savp = (u_char *) xmalloc(blocksize);
+ address = (off_t)0; /*DBU:[dave@cray.com] initialize,initialize..*/
+ curp = (u_char *) xmalloc(bb_dump_blocksize);
+ savp = (u_char *) xmalloc(bb_dump_blocksize);
} else {
tmpp = curp;
curp = savp;
savp = tmpp;
- address = savaddress += blocksize;
+ address = savaddress += bb_dump_blocksize;
}
- for (need = blocksize, nread = 0;;) {
+ for (need = bb_dump_blocksize, nread = 0;;) {
/*
* 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 (need == blocksize) {
+ if (!bb_dump_length || (ateof && !next((char **) NULL))) {
+ if (need == bb_dump_blocksize) {
return ((u_char *) NULL);
}
- if (vflag != ALL && !bcmp(curp, savp, nread)) {
- if (vflag != DUP) {
+ if (bb_dump_vflag != ALL && !bcmp(curp, savp, nread)) {
+ if (bb_dump_vflag != DUP) {
printf("*\n");
}
return ((u_char *) NULL);
return (curp);
}
n = fread((char *) curp + nread, sizeof(u_char),
- length == -1 ? need : MIN(length, need), stdin);
+ bb_dump_length == -1 ? need : MIN(bb_dump_length, need), stdin);
if (!n) {
if (ferror(stdin)) {
- perror_msg("%s", _argv[-1]);
+ bb_perror_msg("%s", _argv[-1]);
}
ateof = 1;
continue;
}
ateof = 0;
- if (length != -1) {
- length -= n;
+ if (bb_dump_length != -1) {
+ bb_dump_length -= n;
}
if (!(need -= n)) {
- if (vflag == ALL || vflag == FIRST || bcmp(curp, savp, blocksize)) {
- if (vflag == DUP || vflag == FIRST) {
- vflag = WAIT;
+ if (bb_dump_vflag == ALL || bb_dump_vflag == FIRST
+ || bcmp(curp, savp, bb_dump_blocksize)) {
+ if (bb_dump_vflag == DUP || bb_dump_vflag == FIRST) {
+ bb_dump_vflag = WAIT;
}
return (curp);
}
- if (vflag == WAIT) {
+ if (bb_dump_vflag == WAIT) {
printf("*\n");
}
- vflag = DUP;
- address = savaddress += blocksize;
- need = blocksize;
+ bb_dump_vflag = DUP;
+ address = savaddress += bb_dump_blocksize;
+ need = bb_dump_blocksize;
nread = 0;
} else {
nread += n;
pr->flags = F_BPAD;
*pr->cchar = 's';
for (p1 = pr->fmt; *p1 != '%'; ++p1);
- for (p2 = ++p1; *p1 && index(" -0+#", *p1); ++p1);
+ for (p2 = ++p1; *p1 && strchr(" -0+#", *p1); ++p1);
while ((*p2++ = *p1++) != 0);
}
-void conv_c(PR * pr, u_char * p)
+static const char conv_str[] =
+ "\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"
+ "\0";
+
+
+static void conv_c(PR * pr, u_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;
- }
+ const char *str = conv_str;
+ char buf[10];
+
+ do {
+ if (*p == *str) {
+ ++str;
+ goto strpr;
+ }
+ str += 4;
+ } while (*str);
+
if (isprint(*p)) {
*pr->cchar = 'c';
(void) printf(pr->fmt, *p);
} else {
- sprintf(str = buf, "%03o", (int) *p);
+ sprintf(buf, "%03o", (int) *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, u_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[] =
+ "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");
}
}
-void display(void)
+static void display(void)
{
/* extern FU *endfu; */
register FS *fs;
register int cnt;
register u_char *bp;
-/* off_t saveaddress; */
+ off_t saveaddress;
u_char savech = 0, *savebp;
while ((bp = get()) != NULL) {
- for (fs = fshead, savebp = bp, saveaddress = address; fs;
+ for (fs = bb_dump_fshead, savebp = bp, saveaddress = address; fs;
fs = fs->nextfs, bp = savebp, address = saveaddress) {
for (fu = fs->nextfu; fu; fu = fu->nextfu) {
if (fu->flags & F_IGNORE) {
/* PRINT; */
switch (pr->flags) {
case F_ADDRESS:
- printf(pr->fmt, address);
+ printf(pr->fmt, (unsigned int) address);
break;
case F_BPAD:
printf(pr->fmt, "");
conv_u(pr, bp);
break;
case F_UINT:{
- u_int ival;
- u_short sval;
+ unsigned int ival;
+ unsigned short sval;
switch (pr->bcnt) {
case 1:
- printf(pr->fmt, (u_int) * bp);
+ printf(pr->fmt, (unsigned int) * bp);
break;
case 2:
bcopy((char *) bp, (char *) &sval,
sizeof(sval));
- printf(pr->fmt, (u_int) sval);
+ printf(pr->fmt, (unsigned int) sval);
break;
case 4:
bcopy((char *) bp, (char *) &ival,
}
if (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 bb_dump_size was multiple of
+ * bb_dump_blocksize, and no partial block ever found.
*/
if (!eaddress) {
if (!address) {
for (pr = endfu->nextpr; pr; pr = pr->nextpr) {
switch (pr->flags) {
case F_ADDRESS:
- (void) printf(pr->fmt, eaddress);
+ (void) printf(pr->fmt, (unsigned int) eaddress);
break;
case F_TEXT:
(void) printf(pr->fmt);
}
}
-int dump(char **argv)
+int bb_dump_dump(char **argv)
{
register FS *tfs;
- /* figure out the data block size */
- for (blocksize = 0, tfs = fshead; tfs; tfs = tfs->nextfs) {
- tfs->bcnt = size(tfs);
- if (blocksize < tfs->bcnt) {
- blocksize = tfs->bcnt;
+ /* figure out the data block bb_dump_size */
+ for (bb_dump_blocksize = 0, tfs = bb_dump_fshead; tfs; tfs = tfs->nextfs) {
+ tfs->bcnt = bb_dump_size(tfs);
+ if (bb_dump_blocksize < tfs->bcnt) {
+ bb_dump_blocksize = tfs->bcnt;
}
}
/* rewrite the rules, do syntax checking */
- for (tfs = fshead; tfs; tfs = tfs->nextfs) {
+ for (tfs = bb_dump_fshead; tfs; tfs = tfs->nextfs) {
rewrite(tfs);
}
return (exitval);
}
-void add(char *fmt)
+void bb_dump_add(const char *fmt)
{
- register char *p;
+ register const char *p;
register char *p1;
register char *p2;
static FS **nextfs;
FS *tfs;
FU *tfu, **nextfu;
- char *savep;
+ const char *savep;
/* start new linked list of format units */
/* NOSTRICT */
- tfs = (FS *) xmalloc(sizeof(FS));
- if (!fshead) {
- fshead = tfs;
+ tfs = (FS *) xcalloc(1,sizeof(FS)); /*DBU:[dave@cray.com] start out NULL */
+ if (!bb_dump_fshead) {
+ bb_dump_fshead = tfs;
} else {
*nextfs = tfs;
}
/* take the format string and break it up into format units */
for (p = fmt;;) {
- /* skip leading white space */
- for (; isspace(*p); ++p);
+ /* bb_dump_skip leading white space */
+ p = bb_skip_whitespace(p);
if (!*p) {
break;
}
/* allocate a new format unit and link it in */
/* NOSTRICT */
- tfu = (FU *) xmalloc(sizeof(FU));
+ /* DBU:[dave@cray.com] calloc so that forward pointers start out NULL */
+ tfu = (FU *) xcalloc(1,sizeof(FU));
*nextfu = tfu;
nextfu = &tfu->nextfu;
tfu->reps = 1;
if (isdigit(*p)) {
for (savep = p; isdigit(*p); ++p);
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);
+ /* bb_dump_skip trailing white space */
+ p = bb_skip_whitespace(++p);
}
- /* skip slash and trailing white space */
+ /* bb_dump_skip slash and trailing white space */
if (*p == '/') {
- while (isspace(*++p));
+ p = bb_skip_whitespace(++p);
}
/* byte count */
if (isdigit(*p)) {
for (savep = p; isdigit(*p); ++p);
if (!isspace(*p)) {
- error_msg_and_die("hexdump: bad format {%s}", fmt);
+ bb_error_msg_and_die("bad format {%s}", fmt);
}
tfu->bcnt = atoi(savep);
- /* skip trailing white space */
- for (++p; isspace(*p); ++p);
+ /* bb_dump_skip trailing white space */
+ p = bb_skip_whitespace(++p);
}
/* 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);
+ bb_error_msg_and_die("bad format {%s}", fmt);
}
}
- if (!(tfu->fmt = malloc(p - savep + 1))) {
- perror_msg_and_die("hexdump");
- }
+ tfu->fmt = xmalloc(p - savep + 1);
strncpy(tfu->fmt, savep, p - savep);
tfu->fmt[p - savep] = '\0';
/* escape(tfu->fmt); */
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;
- break;
- }
+ const char *cs = conv_str + 4;
+ ++p1;
+ *p2 = *p1;
+ do {
+ if (*p1 == cs[2]) {
+ *p2 = cs[0];
+ break;
+ }
+ cs += 4;
+ } while (*cs);
}
}
projects / oweals / busybox.git / blobdiff