4 files changed, 222 insertions, 200 deletions

diff --git a/coreutils/od.c b/coreutils/od.c
index 94a6b95..e4179a3 100644
--- a/coreutils/od.c
+++ b/coreutils/od.c
@@ -24,7 +24,7 @@
 #define ishexdigit(c) (isxdigit)(c)
 
 static void
-odoffset(int argc, char ***argvp)
+odoffset(dumper_t *dumper, int argc, char ***argvp)
 {
 	char *num, *p;
 	int base;
@@ -57,7 +57,7 @@ odoffset(int argc, char ***argvp)
 
 	base = 0;
 	/*
-	 * bb_dump_skip over leading '+', 'x[0-9a-fA-f]' or '0x', and
+	 * skip over leading '+', 'x[0-9a-fA-f]' or '0x', and
 	 * set base.
 	 */
 	if (p[0] == '+')
@@ -70,11 +70,13 @@ odoffset(int argc, char ***argvp)
 		base = 16;
 	}
 
-	/* bb_dump_skip over the number */
+	/* skip over the number */
 	if (base == 16)
-		for (num = p; ishexdigit(*p); ++p);
+		for (num = p; ishexdigit(*p); ++p)
+			continue;
 	else
-		for (num = p; isdecdigit(*p); ++p);
+		for (num = p; isdecdigit(*p); ++p)
+			continue;
 
 	/* check for no number */
 	if (num == p)
@@ -87,23 +89,23 @@ odoffset(int argc, char ***argvp)
 		base = 10;
 	}
 
-	bb_dump_skip = strtol(num, &end, base ? base : 8);
+	dumper->dump_skip = strtol(num, &end, base ? base : 8);
 
 	/* if end isn't the same as p, we got a non-octal digit */
 	if (end != p)
-		bb_dump_skip = 0;
+		dumper->dump_skip = 0;
 	else {
 		if (*p) {
 			if (*p == 'b') {
-				bb_dump_skip *= 512;
+				dumper->dump_skip *= 512;
 				++p;
 			} else if (*p == 'B') {
-				bb_dump_skip *= 1024;
+				dumper->dump_skip *= 1024;
 				++p;
 			}
 		}
 		if (*p)
-			bb_dump_skip = 0;
+			dumper->dump_skip = 0;
 		else {
 			++*argvp;
 			/*
@@ -120,9 +122,9 @@ odoffset(int argc, char ***argvp)
 				}
 				if (base == 10) {
 					x_or_d = 'd';
-				DO_X_OR_D:
-					bb_dump_fshead->nextfu->fmt[TYPE_OFFSET]
-						= bb_dump_fshead->nextfs->nextfu->fmt[TYPE_OFFSET]
+ DO_X_OR_D:
+					dumper->fshead->nextfu->fmt[TYPE_OFFSET]
+						= dumper->fshead->nextfs->nextfu->fmt[TYPE_OFFSET]
 						= x_or_d;
 				}
 			}
@@ -161,36 +163,35 @@ int od_main(int argc, char **argv)
 	int ch;
 	int first = 1;
 	char *p;
-	bb_dump_vflag = FIRST;
-	bb_dump_length = -1;
+	dumper_t *dumper = alloc_dumper();
 
 	while ((ch = getopt(argc, argv, od_opts)) > 0) {
 		if (ch == 'v') {
-			bb_dump_vflag = ALL;
+			dumper->dump_vflag = ALL;
 		} else if (((p = strchr(od_opts, ch)) != NULL) && (*p != '\0')) {
 			if (first) {
 				first = 0;
-				bb_dump_add("\"%07.7_Ao\n\"");
-				bb_dump_add("\"%07.7_ao  \"");
+				bb_dump_add(dumper, "\"%07.7_Ao\n\"");
+				bb_dump_add(dumper, "\"%07.7_ao  \"");
 			} else {
-				bb_dump_add("\"         \"");
+				bb_dump_add(dumper, "\"         \"");
 			}
-			bb_dump_add(add_strings[(int)od_o2si[(p-od_opts)]]);
+			bb_dump_add(dumper, add_strings[(int)od_o2si[(p - od_opts)]]);
 		} else {	/* P, p, s, w, or other unhandled */
 			bb_show_usage();
 		}
 	}
-	if (!bb_dump_fshead) {
-		bb_dump_add("\"%07.7_Ao\n\"");
-		bb_dump_add("\"%07.7_ao  \" 8/2 \"%06o \" \"\\n\"");
+	if (!dumper->fshead) {
+		bb_dump_add(dumper, "\"%07.7_Ao\n\"");
+		bb_dump_add(dumper, "\"%07.7_ao  \" 8/2 \"%06o \" \"\\n\"");
 	}
 
 	argc -= optind;
 	argv += optind;
 
-	odoffset(argc, &argv);
+	odoffset(dumper, argc, &argv);
 
-	return bb_dump_dump(argv);
+	return bb_dump_dump(dumper, argv);
 }
 #endif /* ENABLE_DESKTOP */
 
diff --git a/include/dump.h b/include/dump.h
index da3e66d..44f2082 100644
--- a/include/dump.h
+++ b/include/dump.h
@@ -18,10 +18,10 @@
 #define	F_UINT		0x200		/* %[ouXx] */
 #define	F_TEXT		0x400		/* no conversions */
 
-enum _vflag { ALL, DUP, FIRST, WAIT };	/* -v values */
+enum dump_vflag_t { ALL, DUP, FIRST, WAIT };	/* -v values */
 
-typedef struct _pr {
-	struct _pr *nextpr;		/* next print unit */
+typedef struct PR {
+	struct PR *nextpr;		/* next print unit */
 	unsigned flags;			/* flag values */
 	int bcnt;			/* byte count */
 	char *cchar;			/* conversion character */
@@ -29,30 +29,31 @@ typedef struct _pr {
 	char *nospace;			/* no whitespace version */
 } PR;
 
-typedef struct _fu {
-	struct _fu *nextfu;		/* next format unit */
-	struct _pr *nextpr;		/* next print unit */
+typedef struct FU {
+	struct FU *nextfu;		/* next format unit */
+	struct PR *nextpr;		/* next print unit */
 	unsigned flags;			/* flag values */
 	int reps;			/* repetition count */
 	int bcnt;			/* byte count */
 	char *fmt;			/* format string */
 } FU;
 
-typedef struct _fs {			/* format strings */
-	struct _fs *nextfs;		/* linked list of format strings */
-	struct _fu *nextfu;		/* linked list of format units */
+typedef struct FS {			/* format strings */
+	struct FS *nextfs;		/* linked list of format strings */
+	struct FU *nextfu;		/* linked list of format units */
 	int bcnt;
 } FS;
 
-extern void bb_dump_add(const char *fmt) FAST_FUNC;
-extern int bb_dump_dump(char **argv) FAST_FUNC;
-extern int bb_dump_size(FS * fs) FAST_FUNC;
+typedef struct dumper_t {
+	off_t dump_skip;                /* bytes to skip */
+	int dump_length;                /* max bytes to read */
+	smallint dump_vflag; /*enum dump_vflag_t*/
+	FS *fshead;
+} dumper_t;
 
-extern FS *bb_dump_fshead;              /* head of format strings */
-extern int bb_dump_blocksize;           /* data block size */
-extern int bb_dump_length;              /* max bytes to read */
-extern smallint /*enum _vflag*/ bb_dump_vflag;
-extern off_t bb_dump_skip;              /* bytes to skip */
+dumper_t* alloc_dumper(void) FAST_FUNC;
+extern void bb_dump_add(dumper_t *dumper, const char *fmt) FAST_FUNC;
+extern int bb_dump_dump(dumper_t *dumper, char **argv) FAST_FUNC;
 
 #if __GNUC_PREREQ(4,1)
 # pragma GCC visibility pop
diff --git a/libbb/dump.c b/libbb/dump.c
index 29c2c85..0d553d4 100644
--- a/libbb/dump.c
+++ b/libbb/dump.c
@@ -14,19 +14,6 @@
 #include "libbb.h"
 #include "dump.h"
 
-FS *bb_dump_fshead;             /* head of format strings */
-off_t bb_dump_skip;             /* bytes to skip */
-int bb_dump_blocksize;          /* data block size */
-int bb_dump_length = -1;        /* max bytes to read */
-smallint /*enum _vflag*/ bb_dump_vflag = FIRST;
-
-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 */
-static int exitval;             /* final exit value */
-
 static const char index_str[] ALIGN1 = ".#-+ 0123456789";
 
 static const char size_conv_str[] ALIGN1 =
@@ -34,7 +21,36 @@ static const char size_conv_str[] ALIGN1 =
 
 static const char lcc[] ALIGN1 = "diouxX";
 
-int FAST_FUNC bb_dump_size(FS *fs)
+
+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)
 {
 	FU *fu;
 	int bcnt, cur_size;
@@ -52,13 +68,14 @@ int FAST_FUNC bb_dump_size(FS *fs)
 			if (*fmt != '%')
 				continue;
 			/*
-			 * bb_dump_skip any special chars -- save precision in
+			 * skip any special chars -- save precision in
 			 * case it's a %s format.
 			 */
 			while (strchr(index_str + 1, *++fmt));
 			if (*fmt == '.' && isdigit(*++fmt)) {
 				prec = atoi(fmt);
-				while (isdigit(*++fmt));
+				while (isdigit(*++fmt))
+					continue;
 			}
 			p = strchr(size_conv_str + 12, *fmt);
 			if (!p) {
@@ -79,7 +96,7 @@ int FAST_FUNC bb_dump_size(FS *fs)
 	return cur_size;
 }
 
-static void rewrite(FS *fs)
+static void rewrite(priv_dumper_t *dumper, FS *fs)
 {
 	enum { NOTOKAY, USEBCNT, USEPREC } sokay;
 	PR *pr, **nextpr = NULL;
@@ -104,7 +121,7 @@ static void rewrite(FS *fs)
 			 * uninitialized 1st time through.
 			 */
 
-			/* bb_dump_skip preceding text and up to the next % sign */
+			/* skip preceding text and up to the next % sign */
 			for (p1 = fmtp; *p1 && *p1 != '%'; ++p1)
 				continue;
 
@@ -121,11 +138,11 @@ static void rewrite(FS *fs)
 			 */
 			if (fu->bcnt) {
 				sokay = USEBCNT;
-				/* bb_dump_skip to conversion character */
+				/* skip to conversion character */
 				for (++p1; strchr(index_str, *p1); ++p1)
 					continue;
 			} else {
-				/* bb_dump_skip any special chars, field width */
+				/* skip any special chars, field width */
 				while (strchr(index_str + 1, *++p1))
 					continue;
 				if (*p1 == '.' && isdigit(*++p1)) {
@@ -137,7 +154,7 @@ static void rewrite(FS *fs)
 					sokay = NOTOKAY;
 			}
 
-			p2 = p1 + 1;	/* set end pointer */
+			p2 = p1 + 1; /* set end pointer */
 
 			/*
 			 * figure out the byte count for each conversion;
@@ -198,7 +215,7 @@ static void rewrite(FS *fs)
 				++p2;
 				switch (p1[1]) {
 				case 'A':
-					endfu = fu;
+					dumper->endfu = fu;
 					fu->flags |= F_IGNORE;
 					/* FALLTHROUGH */
 				case 'a':
@@ -274,7 +291,7 @@ static void rewrite(FS *fs)
 	}
 	/*
 	 * if the format string interprets any data at all, and it's
-	 * not the same as the bb_dump_blocksize, and its last format unit
+	 * not the same as the blocksize, and its last format unit
 	 * interprets any data at all, and has no iteration count,
 	 * repeat it as necessary.
 	 *
@@ -282,10 +299,10 @@ static void rewrite(FS *fs)
 	 * gets output from the last iteration of the format unit.
 	 */
 	for (fu = fs->nextfu;; fu = fu->nextfu) {
-		if (!fu->nextfu && fs->bcnt < bb_dump_blocksize
+		if (!fu->nextfu && fs->bcnt < dumper->blocksize
 		 && !(fu->flags & F_SETREP) && fu->bcnt
 		) {
-			fu->reps += (bb_dump_blocksize - fs->bcnt) / fu->bcnt;
+			fu->reps += (dumper->blocksize - fs->bcnt) / fu->bcnt;
 		}
 		if (fu->reps > 1) {
 			for (pr = fu->nextpr;; pr = pr->nextpr)
@@ -301,7 +318,7 @@ static void rewrite(FS *fs)
 	}
 }
 
-static void do_skip(const char *fname, int statok)
+static void do_skip(priv_dumper_t *dumper, const char *fname, int statok)
 {
 	struct stat sbuf;
 
@@ -309,125 +326,122 @@ static void do_skip(const char *fname, int statok)
 		if (fstat(STDIN_FILENO, &sbuf)) {
 			bb_simple_perror_msg_and_die(fname);
 		}
-		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;
+		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;
 			return;
 		}
 	}
-	if (fseek(stdin, bb_dump_skip, SEEK_SET)) {
+	if (fseek(stdin, dumper->pub.dump_skip, SEEK_SET)) {
 		bb_simple_perror_msg_and_die(fname);
 	}
-	savaddress = address += bb_dump_skip;
-	bb_dump_skip = 0;
+	dumper->address += dumper->pub.dump_skip;
+	dumper->savaddress = dumper->address;
+	dumper->pub.dump_skip = 0;
 }
 
-static int next(char **argv)
+static NOINLINE int next(priv_dumper_t *dumper)
 {
-	static smallint done;
-
 	int statok;
 
-	if (argv) {
-		_argv = argv;
-		return 1;
-	}
 	for (;;) {
-		if (*_argv) {
-			if (!(freopen(*_argv, "r", stdin))) {
-				bb_simple_perror_msg(*_argv);
-				exitval = 1;
-				++_argv;
+		if (*dumper->argv) {
+			if (!(freopen(*dumper->argv, "r", stdin))) {
+				bb_simple_perror_msg(*dumper->argv);
+				dumper->exitval = 1;
+				++dumper->argv;
 				continue;
 			}
-			done = statok = 1;
+			dumper->next__done = statok = 1;
 		} else {
-			if (done)
+			if (dumper->next__done)
 				return 0;
-			done = 1;
+			dumper->next__done = 1;
 			statok = 0;
 		}
-		if (bb_dump_skip)
-			do_skip(statok ? *_argv : "stdin", statok);
-		if (*_argv)
-			++_argv;
-		if (!bb_dump_skip)
+		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;
 	}
 	/* NOTREACHED */
 }
 
-static unsigned char *get(void)
+static unsigned char *get(priv_dumper_t *dumper)
 {
-	static smallint ateof = 1;
-	static unsigned char *curp = NULL, *savp; /*DBU:[dave@cray.com]initialize curp */
-
 	int n;
 	int need, nread;
 	unsigned char *tmpp;
+	int blocksize = dumper->blocksize;
 
-	if (!curp) {
-		address = (off_t)0; /*DBU:[dave@cray.com] initialize,initialize..*/
-		curp = xmalloc(bb_dump_blocksize);
-		savp = xmalloc(bb_dump_blocksize);
+	if (!dumper->get__curp) {
+		dumper->address = (off_t)0; /*DBU:[dave@cray.com] initialize,initialize..*/
+		dumper->get__curp = xmalloc(blocksize);
+		dumper->get__savp = xmalloc(blocksize);
 	} else {
-		tmpp = curp;
-		curp = savp;
-		savp = tmpp;
-		address = savaddress += bb_dump_blocksize;
+		tmpp = dumper->get__curp;
+		dumper->get__curp = dumper->get__savp;
+		dumper->get__savp = tmpp;
+		dumper->savaddress += blocksize;
+		dumper->address = dumper->savaddress;
 	}
-	for (need = bb_dump_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 (!bb_dump_length || (ateof && !next(NULL))) {
-			if (need == bb_dump_blocksize) {
+		if (!dumper->pub.dump_length || (dumper->get__ateof && !next(dumper))) {
+			if (need == blocksize) {
 				return NULL;
 			}
-			if (bb_dump_vflag != ALL && !memcmp(curp, savp, nread)) {
-				if (bb_dump_vflag != DUP) {
+			if (dumper->pub.dump_vflag != ALL && !memcmp(dumper->get__curp, dumper->get__savp, nread)) {
+				if (dumper->pub.dump_vflag != DUP) {
 					puts("*");
 				}
 				return NULL;
 			}
-			memset(curp + nread, 0, need);
-			eaddress = address + nread;
-			return curp;
+			memset(dumper->get__curp + nread, 0, need);
+			dumper->eaddress = dumper->address + nread;
+			return dumper->get__curp;
 		}
-		n = fread(curp + nread, sizeof(unsigned char),
-				bb_dump_length == -1 ? need : MIN(bb_dump_length, need), stdin);
+		n = fread(dumper->get__curp + nread, sizeof(unsigned char),
+				dumper->pub.dump_length == -1 ? need : MIN(dumper->pub.dump_length, need), stdin);
 		if (!n) {
 			if (ferror(stdin)) {
-				bb_simple_perror_msg(_argv[-1]);
+				bb_simple_perror_msg(dumper->argv[-1]);
 			}
-			ateof = 1;
+			dumper->get__ateof = 1;
 			continue;
 		}
-		ateof = 0;
-		if (bb_dump_length != -1) {
-			bb_dump_length -= n;
+		dumper->get__ateof = 0;
+		if (dumper->pub.dump_length != -1) {
+			dumper->pub.dump_length -= n;
 		}
 		need -= n;
 		if (!need) {
-			if (bb_dump_vflag == ALL || bb_dump_vflag == FIRST
-			 || memcmp(curp, savp, bb_dump_blocksize)
+			if (dumper->pub.dump_vflag == ALL || dumper->pub.dump_vflag == FIRST
+			 || memcmp(dumper->get__curp, dumper->get__savp, blocksize)
 			) {
-				if (bb_dump_vflag == DUP || bb_dump_vflag == FIRST) {
-					bb_dump_vflag = WAIT;
+				if (dumper->pub.dump_vflag == DUP || dumper->pub.dump_vflag == FIRST) {
+					dumper->pub.dump_vflag = WAIT;
 				}
-				return curp;
+				return dumper->get__curp;
 			}
-			if (bb_dump_vflag == WAIT) {
+			if (dumper->pub.dump_vflag == WAIT) {
 				puts("*");
 			}
-			bb_dump_vflag = DUP;
-			address = savaddress += bb_dump_blocksize;
-			need = bb_dump_blocksize;
+			dumper->pub.dump_vflag = DUP;
+			dumper->savaddress += blocksize;
+			dumper->address = dumper->savaddress;
+			need = blocksize;
 			nread = 0;
 		} else {
 			nread += n;
@@ -515,29 +529,31 @@ static void conv_u(PR *pr, unsigned char *p)
 	}
 }
 
-static void display(void)
+static void display(priv_dumper_t* dumper)
 {
-/*  extern FU *endfu; */
 	FS *fs;
 	FU *fu;
 	PR *pr;
 	int cnt;
-	unsigned char *bp;
+	unsigned char *bp, *savebp;
 	off_t saveaddress;
-	unsigned char savech = 0, *savebp;
+	unsigned char savech = '\0';
 
-	while ((bp = get()) != NULL) {
-		for (fs = bb_dump_fshead, savebp = bp, saveaddress = address; fs;
-			 fs = fs->nextfs, bp = savebp, address = saveaddress) {
+	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) {
@@ -547,7 +563,7 @@ static void display(void)
 /*                      PRINT; */
 						switch (pr->flags) {
 						case F_ADDRESS:
-							printf(pr->fmt, (unsigned) address);
+							printf(pr->fmt, (unsigned) dumper->address);
 							break;
 						case F_BPAD:
 							printf(pr->fmt, "");
@@ -558,7 +574,7 @@ static void display(void)
 						case F_CHAR:
 							printf(pr->fmt, *bp);
 							break;
-						case F_DBL:{
+						case F_DBL: {
 							double dval;
 							float fval;
 
@@ -574,7 +590,7 @@ static void display(void)
 							}
 							break;
 						}
-						case F_INT:{
+						case F_INT: {
 							int ival;
 							short sval;
 
@@ -605,7 +621,7 @@ static void display(void)
 						case F_U:
 							conv_u(pr, bp);
 							break;
-						case F_UINT:{
+						case F_UINT: {
 							unsigned ival;
 							unsigned short sval;
 
@@ -633,21 +649,21 @@ static void display(void)
 			}
 		}
 	}
-	if (endfu) {
+	if (dumper->endfu) {
 		/*
-		 * if eaddress not set, error or file bb_dump_size was multiple of
-		 * bb_dump_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) {
+		for (pr = dumper->endfu->nextpr; pr; pr = pr->nextpr) {
 			switch (pr->flags) {
 			case F_ADDRESS:
-				printf(pr->fmt, (unsigned) eaddress);
+				printf(pr->fmt, (unsigned) dumper->eaddress);
 				break;
 			case F_TEXT:
 				printf(pr->fmt);
@@ -657,52 +673,58 @@ static void display(void)
 	}
 }
 
-int FAST_FUNC bb_dump_dump(char **argv)
+#define dumper ((priv_dumper_t*)pub_dumper)
+int FAST_FUNC bb_dump_dump(dumper_t *pub_dumper, char **argv)
 {
 	FS *tfs;
+	int blocksize;
 
 	/* figure out the data block bb_dump_size */
-	for (bb_dump_blocksize = 0, tfs = bb_dump_fshead; tfs; tfs = tfs->nextfs) {
+	blocksize = 0;
+	tfs = dumper->pub.fshead;
+	while (tfs) {
 		tfs->bcnt = bb_dump_size(tfs);
-		if (bb_dump_blocksize < tfs->bcnt) {
-			bb_dump_blocksize = tfs->bcnt;
+		if (blocksize < tfs->bcnt) {
+			blocksize = tfs->bcnt;
 		}
+		tfs = tfs->nextfs;
 	}
+	dumper->blocksize = blocksize;
+
 	/* rewrite the rules, do syntax checking */
-	for (tfs = bb_dump_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 FAST_FUNC bb_dump_add(const char *fmt)
+void FAST_FUNC bb_dump_add(dumper_t* pub_dumper, const char *fmt)
 {
-	static FS **nextfs;
-
 	const char *p;
 	char *p1;
 	char *p2;
 	FS *tfs;
-	FU *tfu, **nextfu;
+	FU *tfu, **nextfupp;
 	const char *savep;
 
 	/* start new linked list of format units */
 	tfs = xzalloc(sizeof(FS)); /*DBU:[dave@cray.com] start out NULL */
-	if (!bb_dump_fshead) {
-		bb_dump_fshead = tfs;
+	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;;) {
-		/* bb_dump_skip leading white space */
 		p = skip_whitespace(p);
 		if (!*p) {
 			break;
@@ -712,8 +734,8 @@ void FAST_FUNC bb_dump_add(const char *fmt)
 		/* NOSTRICT */
 		/* DBU:[dave@cray.com] zalloc so that forward pointers start out NULL */
 		tfu = xzalloc(sizeof(FU));
-		*nextfu = tfu;
-		nextfu = &tfu->nextfu;
+		*nextfupp = tfu;
+		nextfupp = &tfu->nextfu;
 		tfu->reps = 1;
 
 		/* if leading digit, repetition count */
@@ -726,11 +748,11 @@ void FAST_FUNC bb_dump_add(const char *fmt)
 			/* may overwrite either white space or slash */
 			tfu->reps = atoi(savep);
 			tfu->flags = F_SETREP;
-			/* bb_dump_skip trailing white space */
+			/* skip trailing white space */
 			p = skip_whitespace(++p);
 		}
 
-		/* bb_dump_skip slash and trailing white space */
+		/* skip slash and trailing white space */
 		if (*p == '/') {
 			p = skip_whitespace(++p);
 		}
@@ -745,7 +767,7 @@ void FAST_FUNC bb_dump_add(const char *fmt)
 				bb_error_msg_and_die("bad format {%s}", fmt);
 			}
 			tfu->bcnt = atoi(savep);
-			/* bb_dump_skip trailing white space */
+			/* skip trailing white space */
 			p = skip_whitespace(++p);
 		}
 
diff --git a/util-linux/hexdump.c b/util-linux/hexdump.c
index 7630153..4d2b059 100644
--- a/util-linux/hexdump.c
+++ b/util-linux/hexdump.c
@@ -15,7 +15,7 @@
 /* This is a NOEXEC applet. Be very careful! */
 
 
-static void bb_dump_addfile(char *name)
+static void bb_dump_addfile(dumper_t *dumper, char *name)
 {
 	char *p;
 	FILE *fp;
@@ -27,7 +27,7 @@ static void bb_dump_addfile(char *name)
 		p = skip_whitespace(buf);
 
 		if (*p && (*p != '#')) {
-			bb_dump_add(p);
+			bb_dump_add(dumper, p);
 		}
 		free(buf);
 	}
@@ -56,6 +56,7 @@ static const struct suffix_mult suffixes[] = {
 int hexdump_main(int argc, char **argv) MAIN_EXTERNALLY_VISIBLE;
 int hexdump_main(int argc, char **argv)
 {
+	dumper_t *dumper = alloc_dumper();
 	const char *p;
 	int ch;
 #if ENABLE_FEATURE_HEXDUMP_REVERSE
@@ -63,9 +64,6 @@ int hexdump_main(int argc, char **argv)
 	smallint rdump = 0;
 #endif
 
-	bb_dump_vflag = FIRST;
-	bb_dump_length = -1;
-
 	if (ENABLE_HD && !applet_name[2]) { /* we are "hd" */
 		ch = 'C';
 		goto hd_applet;
@@ -78,30 +76,30 @@ int hexdump_main(int argc, char **argv)
 		if (!p)
 			bb_show_usage();
 		if ((p - hexdump_opts) < 5) {
-			bb_dump_add(add_first);
-			bb_dump_add(add_strings[(int)(p - hexdump_opts)]);
+			bb_dump_add(dumper, add_first);
+			bb_dump_add(dumper, add_strings[(int)(p - hexdump_opts)]);
 		}
 		/* Save a little bit of space below by omitting the 'else's. */
 		if (ch == 'C') {
  hd_applet:
-			bb_dump_add("\"%08.8_Ax\n\"");
-			bb_dump_add("\"%08.8_ax  \" 8/1 \"%02x \" \"  \" 8/1 \"%02x \" ");
-			bb_dump_add("\"  |\" 16/1 \"%_p\" \"|\\n\"");
+			bb_dump_add(dumper, "\"%08.8_Ax\n\"");
+			bb_dump_add(dumper, "\"%08.8_ax  \" 8/1 \"%02x \" \"  \" 8/1 \"%02x \" ");
+			bb_dump_add(dumper, "\"  |\" 16/1 \"%_p\" \"|\\n\"");
 		}
 		if (ch == 'e') {
-			bb_dump_add(optarg);
+			bb_dump_add(dumper, optarg);
 		} /* else */
 		if (ch == 'f') {
-			bb_dump_addfile(optarg);
+			bb_dump_addfile(dumper, optarg);
 		} /* else */
 		if (ch == 'n') {
-			bb_dump_length = xatoi_u(optarg);
+			dumper->dump_length = xatoi_u(optarg);
 		} /* else */
 		if (ch == 's') {
-			bb_dump_skip = xatoul_range_sfx(optarg, 0, LONG_MAX, suffixes);
+			dumper->dump_skip = xatoul_range_sfx(optarg, 0, LONG_MAX, suffixes);
 		} /* else */
 		if (ch == 'v') {
-			bb_dump_vflag = ALL;
+			dumper->dump_vflag = ALL;
 		}
 #if ENABLE_FEATURE_HEXDUMP_REVERSE
 		if (ch == 'R') {
@@ -110,18 +108,18 @@ int hexdump_main(int argc, char **argv)
 #endif
 	}
 
-	if (!bb_dump_fshead) {
-		bb_dump_add(add_first);
-		bb_dump_add("\"%07.7_ax \" 8/2 \"%04x \" \"\\n\"");
+	if (!dumper->fshead) {
+		bb_dump_add(dumper, add_first);
+		bb_dump_add(dumper, "\"%07.7_ax \" 8/2 \"%04x \" \"\\n\"");
 	}
 
 	argv += optind;
 
 #if !ENABLE_FEATURE_HEXDUMP_REVERSE
-	return bb_dump_dump(argv);
+	return bb_dump_dump(dumper, argv);
 #else
 	if (!rdump) {
-		return bb_dump_dump(argv);
+		return bb_dump_dump(dumper, argv);
 	}
 
 	/* -R: reverse of 'hexdump -Cv' */