X-Git-Url: https://git.librecmc.org/?a=blobdiff_plain;f=libbb%2Fdump.c;h=7d923083ad7e94255060e2aa79c2a4ac9788bc2e;hb=7600eec7325f0bbce1dcbf08e76c1653bf35b397;hp=10d5a8d63159790ec3bccc9c08961b922b146fe1;hpb=60281118d022a702c62c9047ba6998ef873917d4;p=oweals%2Fbusybox.git

diff --git a/libbb/dump.c b/libbb/dump.c
index 10d5a8d63..7d923083a 100644
--- a/libbb/dump.c
+++ b/libbb/dump.c
@@ -24,85 +24,82 @@
 
 #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 */
+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 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) {
@@ -112,13 +109,15 @@ void rewrite(FS *fs)
 		 */
 		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 */
@@ -134,105 +133,79 @@ void rewrite(FS *fs)
 			 */
 			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);
 					while (isdigit(*++p1));
-				}
-				else
+				} 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.
+			 * 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]) {
+				switch (p1[1]) {
 				case 'A':
 					endfu = fu;
 					fu->flags |= F_IGNORE;
@@ -240,43 +213,29 @@ sw1:				switch(fu->bcnt) {
 				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;
+					/* *p1 = 'c';   set in conv_c */
+					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;
+					/* *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.\n", p1);
 			}
 
 			/*
@@ -285,15 +244,32 @@ sw2:					switch(fu->bcnt) {
 			 */
 			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");
+			if (!(pr->flags & F_ADDRESS) && fu->bcnt && nconv++) {
+				bb_error_msg_and_die("byte count with multiple conversion characters.\n");
 			}
 		}
 		/*
@@ -306,7 +282,7 @@ sw2:					switch(fu->bcnt) {
 	}
 	/*
 	 * 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.
 	 *
@@ -314,9 +290,9 @@ sw2:					switch(fu->bcnt) {
 	 * 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->nextfu && fs->bcnt < bb_dump_blocksize &&
+			!(fu->flags & F_SETREP) && 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)
@@ -331,44 +307,43 @@ sw2:					switch(fu->bcnt) {
 	}
 }
 
-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;
+		if ((!(S_ISCHR(sbuf.st_mode) ||
+			   S_ISBLK(sbuf.st_mode) ||
+			   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;
 
 	if (argv) {
 		_argv = argv;
-		return(1);
+		return (1);
 	}
 	for (;;) {
 		if (*_argv) {
 			if (!(freopen(*_argv, "r", stdin))) {
-				perror_msg("%s", *_argv);
+				bb_perror_msg("%s", *_argv);
 				exitval = 1;
 				++_argv;
 				continue;
@@ -376,84 +351,84 @@ int next(char **argv)
 			statok = done = 1;
 		} else {
 			if (done++)
-				return(0);
+				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)
-			return(1);
+		if (!bb_dump_skip)
+			return (1);
 	}
 	/* NOTREACHED */
 }
 
-static u_char *
-get(void)
+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) {
-				return((u_char *)NULL);
+		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 ((u_char *) NULL);
 			}
-			bzero((char *)curp + nread, need);
+			bzero((char *) curp + nread, need);
 			eaddress = address + nread;
-			return(curp);
+			return (curp);
 		}
-		n = fread((char *)curp + nread, sizeof(u_char),
-		    length == -1 ? need : MIN(length, need), stdin);
+		n = fread((char *) curp + nread, sizeof(u_char),
+				  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);
+				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;
@@ -461,7 +436,7 @@ get(void)
 	}
 }
 
-static void bpad(PR *pr)
+static void bpad(PR * pr)
 {
 	register char *p1, *p2;
 
@@ -472,67 +447,59 @@ static void bpad(PR *pr)
 	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 (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);
+		(void) printf(pr->fmt, *p);
 	} else {
-		sprintf(str = buf, "%03o", (int)*p);
-strpr:
+		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");
@@ -541,118 +508,128 @@ void conv_u(PR *pr, u_char *p)
 		printf(pr->fmt, *p);
 	} else {
 		*pr->cchar = 'x';
-		printf(pr->fmt, (int)*p);
+		printf(pr->fmt, (int) *p);
 	}
 }
 
-void display(void)
+static void display(void)
 {
-//	extern FU *endfu;
+/*  extern FU *endfu; */
 	register FS *fs;
 	register FU *fu;
 	register PR *pr;
 	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;
-				fs = fs->nextfs, bp = savebp, address = saveaddress) {
-		    for (fu = fs->nextfu; fu; fu = fu->nextfu) {
+		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) {
 					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; address += pr->bcnt,
+						 bp += pr->bcnt, pr = pr->nextpr) {
+						if (eaddress && address >= 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 int) 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:
+								bcopy((char *) bp, (char *) &fval,
+									  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:
+								bcopy((char *) bp, (char *) &dval,
+									  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:
+								bcopy((char *) bp, (char *) &sval,
+									  sizeof(sval));
+								printf(pr->fmt, (int) sval);
 								break;
-							case F_STR:
-								printf(pr->fmt, (char *)bp);
+							case 4:
+								bcopy((char *) bp, (char *) &ival,
+									  sizeof(ival));
+								printf(pr->fmt, ival);
 								break;
-							case F_TEXT:
-								printf(pr->fmt);
+							}
+							break;
+						}
+						case F_P:
+							printf(pr->fmt, isprint(*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 int ival;
+							unsigned short sval;
+
+							switch (pr->bcnt) {
+							case 1:
+								printf(pr->fmt, (unsigned int) * bp);
 								break;
-							case F_U:
-								conv_u(pr, bp);
+							case 2:
+								bcopy((char *) bp, (char *) &sval,
+									  sizeof(sval));
+								printf(pr->fmt, (unsigned int) 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:
+								bcopy((char *) bp, (char *) &ival,
+									  sizeof(ival));
+								printf(pr->fmt, ival);
 								break;
 							}
+							break;
 						}
-				 	   if (cnt == 1 && pr->nospace) {
+						}
+						if (cnt == 1 && pr->nospace) {
 							*pr->nospace = savech;
 						}
 					}
@@ -662,8 +639,8 @@ void display(void)
 	}
 	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) {
@@ -672,55 +649,55 @@ void display(void)
 			eaddress = address;
 		}
 		for (pr = endfu->nextpr; pr; pr = pr->nextpr) {
-			switch(pr->flags) {
+			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);
+				(void) printf(pr->fmt);
 				break;
 			}
 		}
 	}
 }
 
-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);
 	}
 
 	next(argv);
 	display();
 
-	return(exitval);
+	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;
 	}
@@ -729,15 +706,16 @@ void add(char *fmt)
 
 	/* 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;
@@ -746,46 +724,44 @@ void add(char *fmt)
 		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);
+/*      escape(tfu->fmt); */
 
 		p1 = tfu->fmt;
 
@@ -796,39 +772,23 @@ void add(char *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);
 			}
 		}
 
 		p++;
 	}
 }
+
 /*
  * Copyright (c) 1989 The Regents of the University of California.
  * All rights reserved.
@@ -841,11 +801,7 @@ void add(char *fmt)
  * 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.
  *