aboutsummaryrefslogtreecommitdiff
path: root/libbb/dump.c
diff options
context:
space:
mode:
Diffstat (limited to 'libbb/dump.c')
-rw-r--r--libbb/dump.c398
1 files changed, 222 insertions, 176 deletions
diff --git a/libbb/dump.c b/libbb/dump.c
index 8bd683f44..1afad83fd 100644
--- a/libbb/dump.c
+++ b/libbb/dump.c
@@ -30,21 +30,21 @@
30 30
31enum _vflag vflag = FIRST; 31enum _vflag vflag = FIRST;
32FS *fshead; /* head of format strings */ 32FS *fshead; /* head of format strings */
33extern FS *fshead; /* head of format strings */ 33extern FS *fshead; /* head of format strings */
34extern int blocksize; 34extern int blocksize;
35static FU *endfu; 35static FU *endfu;
36static char **_argv; 36static char **_argv;
37static off_t savaddress; /* saved address/offset in stream */ 37static off_t savaddress; /* saved address/offset in stream */
38static off_t eaddress; /* end address */ 38static off_t eaddress; /* end address */
39static off_t address; /* address/offset in stream */ 39static off_t address; /* address/offset in stream */
40off_t skip; /* bytes to skip */ 40off_t skip; /* bytes to skip */
41off_t saveaddress; 41off_t saveaddress;
42int exitval; /* final exit value */ 42int exitval; /* final exit value */
43int blocksize; /* data block size */ 43int blocksize; /* data block size */
44int length = -1; /* max bytes to read */ 44int length = -1; /* max bytes to read */
45 45
46 46
47int size(FS *fs) 47int size(FS * fs)
48{ 48{
49 register FU *fu; 49 register FU *fu;
50 register int bcnt, cursize; 50 register int bcnt, cursize;
@@ -69,23 +69,33 @@ int size(FS *fs)
69 prec = atoi(fmt); 69 prec = atoi(fmt);
70 while (isdigit(*++fmt)); 70 while (isdigit(*++fmt));
71 } 71 }
72 switch(*fmt) { 72 switch (*fmt) {
73 case 'c': 73 case 'c':
74 bcnt += 1; 74 bcnt += 1;
75 break; 75 break;
76 case 'd': case 'i': case 'o': case 'u': 76 case 'd':
77 case 'x': case 'X': 77 case 'i':
78 case 'o':
79 case 'u':
80 case 'x':
81 case 'X':
78 bcnt += 4; 82 bcnt += 4;
79 break; 83 break;
80 case 'e': case 'E': case 'f': case 'g': case 'G': 84 case 'e':
85 case 'E':
86 case 'f':
87 case 'g':
88 case 'G':
81 bcnt += 8; 89 bcnt += 8;
82 break; 90 break;
83 case 's': 91 case 's':
84 bcnt += prec; 92 bcnt += prec;
85 break; 93 break;
86 case '_': 94 case '_':
87 switch(*++fmt) { 95 switch (*++fmt) {
88 case 'c': case 'p': case 'u': 96 case 'c':
97 case 'p':
98 case 'u':
89 bcnt += 1; 99 bcnt += 1;
90 break; 100 break;
91 } 101 }
@@ -93,10 +103,10 @@ int size(FS *fs)
93 } 103 }
94 cursize += bcnt * fu->reps; 104 cursize += bcnt * fu->reps;
95 } 105 }
96 return(cursize); 106 return (cursize);
97} 107}
98 108
99void rewrite(FS *fs) 109void rewrite(FS * fs)
100{ 110{
101 enum { NOTOKAY, USEBCNT, USEPREC } sokay; 111 enum { NOTOKAY, USEBCNT, USEPREC } sokay;
102 register PR *pr, **nextpr = NULL; 112 register PR *pr, **nextpr = NULL;
@@ -112,7 +122,7 @@ void rewrite(FS *fs)
112 */ 122 */
113 for (nconv = 0, fmtp = fu->fmt; *fmtp; nextpr = &pr->nextpr) { 123 for (nconv = 0, fmtp = fu->fmt; *fmtp; nextpr = &pr->nextpr) {
114 /* NOSTRICT */ 124 /* NOSTRICT */
115 pr = (PR *)xmalloc(sizeof(PR)); 125 pr = (PR *) xmalloc(sizeof(PR));
116 if (!fu->nextpr) 126 if (!fu->nextpr)
117 fu->nextpr = pr; 127 fu->nextpr = pr;
118 else 128 else
@@ -143,53 +153,64 @@ void rewrite(FS *fs)
143 sokay = USEPREC; 153 sokay = USEPREC;
144 prec = atoi(p1); 154 prec = atoi(p1);
145 while (isdigit(*++p1)); 155 while (isdigit(*++p1));
146 } 156 } else
147 else
148 sokay = NOTOKAY; 157 sokay = NOTOKAY;
149 } 158 }
150 159
151 p2 = p1 + 1; /* set end pointer */ 160 p2 = p1 + 1; /* set end pointer */
152 161
153 /* 162 /*
154 * figure out the byte count for each conversion; 163 * figure out the byte count for each conversion;
155 * rewrite the format as necessary, set up blank- 164 * rewrite the format as necessary, set up blank-
156 * padding for end of data. 165 * padding for end of data.
157 */ 166 */
158 switch(*p1) { 167 switch (*p1) {
159 case 'c': 168 case 'c':
160 pr->flags = F_CHAR; 169 pr->flags = F_CHAR;
161 switch(fu->bcnt) { 170 switch (fu->bcnt) {
162 case 0: case 1: 171 case 0:
172 case 1:
163 pr->bcnt = 1; 173 pr->bcnt = 1;
164 break; 174 break;
165 default: 175 default:
166 p1[1] = '\0'; 176 p1[1] = '\0';
167 error_msg_and_die("bad byte count for conversion character %s.", p1); 177 error_msg_and_die
178 ("bad byte count for conversion character %s.", p1);
168 } 179 }
169 break; 180 break;
170 case 'd': case 'i': 181 case 'd':
182 case 'i':
171 pr->flags = F_INT; 183 pr->flags = F_INT;
172 goto sw1; 184 goto sw1;
173 case 'l': 185 case 'l':
174 ++p2; 186 ++p2;
175 switch(p1[1]) { 187 switch (p1[1]) {
176 case 'd': case 'i': 188 case 'd':
189 case 'i':
177 ++p1; 190 ++p1;
178 pr->flags = F_INT; 191 pr->flags = F_INT;
179 goto sw1; 192 goto sw1;
180 case 'o': case 'u': case 'x': case 'X': 193 case 'o':
194 case 'u':
195 case 'x':
196 case 'X':
181 ++p1; 197 ++p1;
182 pr->flags = F_UINT; 198 pr->flags = F_UINT;
183 goto sw1; 199 goto sw1;
184 default: 200 default:
185 p1[2] = '\0'; 201 p1[2] = '\0';
186 error_msg_and_die("hexdump: bad conversion character %%%s.\n", p1); 202 error_msg_and_die
203 ("hexdump: bad conversion character %%%s.\n", p1);
187 } 204 }
188 /* NOTREACHED */ 205 /* NOTREACHED */
189 case 'o': case 'u': case 'x': case 'X': 206 case 'o':
207 case 'u':
208 case 'x':
209 case 'X':
190 pr->flags = F_UINT; 210 pr->flags = F_UINT;
191sw1: switch(fu->bcnt) { 211 sw1:switch (fu->bcnt) {
192 case 0: case 4: 212 case 0:
213 case 4:
193 pr->bcnt = 4; 214 pr->bcnt = 4;
194 break; 215 break;
195 case 1: 216 case 1:
@@ -200,13 +221,19 @@ sw1: switch(fu->bcnt) {
200 break; 221 break;
201 default: 222 default:
202 p1[1] = '\0'; 223 p1[1] = '\0';
203 error_msg_and_die("bad byte count for conversion character %s.", p1); 224 error_msg_and_die
225 ("bad byte count for conversion character %s.", p1);
204 } 226 }
205 break; 227 break;
206 case 'e': case 'E': case 'f': case 'g': case 'G': 228 case 'e':
229 case 'E':
230 case 'f':
231 case 'g':
232 case 'G':
207 pr->flags = F_DBL; 233 pr->flags = F_DBL;
208 switch(fu->bcnt) { 234 switch (fu->bcnt) {
209 case 0: case 8: 235 case 0:
236 case 8:
210 pr->bcnt = 8; 237 pr->bcnt = 8;
211 break; 238 break;
212 case 4: 239 case 4:
@@ -214,14 +241,16 @@ sw1: switch(fu->bcnt) {
214 break; 241 break;
215 default: 242 default:
216 p1[1] = '\0'; 243 p1[1] = '\0';
217 error_msg_and_die("bad byte count for conversion character %s.", p1); 244 error_msg_and_die
245 ("bad byte count for conversion character %s.", p1);
218 } 246 }
219 break; 247 break;
220 case 's': 248 case 's':
221 pr->flags = F_STR; 249 pr->flags = F_STR;
222 switch(sokay) { 250 switch (sokay) {
223 case NOTOKAY: 251 case NOTOKAY:
224 error_msg_and_die("%%s requires a precision or a byte count."); 252 error_msg_and_die
253 ("%%s requires a precision or a byte count.");
225 case USEBCNT: 254 case USEBCNT:
226 pr->bcnt = fu->bcnt; 255 pr->bcnt = fu->bcnt;
227 break; 256 break;
@@ -232,7 +261,7 @@ sw1: switch(fu->bcnt) {
232 break; 261 break;
233 case '_': 262 case '_':
234 ++p2; 263 ++p2;
235 switch(p1[1]) { 264 switch (p1[1]) {
236 case 'A': 265 case 'A':
237 endfu = fu; 266 endfu = fu;
238 fu->flags |= F_IGNORE; 267 fu->flags |= F_IGNORE;
@@ -240,18 +269,21 @@ sw1: switch(fu->bcnt) {
240 case 'a': 269 case 'a':
241 pr->flags = F_ADDRESS; 270 pr->flags = F_ADDRESS;
242 ++p2; 271 ++p2;
243 switch(p1[2]) { 272 switch (p1[2]) {
244 case 'd': case 'o': case'x': 273 case 'd':
274 case 'o':
275 case 'x':
245 *p1 = p1[2]; 276 *p1 = p1[2];
246 break; 277 break;
247 default: 278 default:
248 p1[3] = '\0'; 279 p1[3] = '\0';
249 error_msg_and_die("hexdump: bad conversion character %%%s.\n", p1); 280 error_msg_and_die
281 ("hexdump: bad conversion character %%%s.\n", p1);
250 } 282 }
251 break; 283 break;
252 case 'c': 284 case 'c':
253 pr->flags = F_C; 285 pr->flags = F_C;
254 /* *p1 = 'c'; set in conv_c */ 286 /* *p1 = 'c'; set in conv_c */
255 goto sw2; 287 goto sw2;
256 case 'p': 288 case 'p':
257 pr->flags = F_P; 289 pr->flags = F_P;
@@ -259,24 +291,29 @@ sw1: switch(fu->bcnt) {
259 goto sw2; 291 goto sw2;
260 case 'u': 292 case 'u':
261 pr->flags = F_U; 293 pr->flags = F_U;
262 /* *p1 = 'c'; set in conv_u */ 294 /* *p1 = 'c'; set in conv_u */
263sw2: switch(fu->bcnt) { 295 sw2:switch (fu->bcnt) {
264 case 0: case 1: 296 case 0:
297 case 1:
265 pr->bcnt = 1; 298 pr->bcnt = 1;
266 break; 299 break;
267 default: 300 default:
268 p1[2] = '\0'; 301 p1[2] = '\0';
269 error_msg_and_die("bad byte count for conversion character %s.", p1); 302 error_msg_and_die
303 ("bad byte count for conversion character %s.",
304 p1);
270 } 305 }
271 break; 306 break;
272 default: 307 default:
273 p1[2] = '\0'; 308 p1[2] = '\0';
274 error_msg_and_die("hexdump: bad conversion character %%%s.\n", p1); 309 error_msg_and_die
310 ("hexdump: bad conversion character %%%s.\n", p1);
275 } 311 }
276 break; 312 break;
277 default: 313 default:
278 p1[1] = '\0'; 314 p1[1] = '\0';
279 error_msg_and_die("hexdump: bad conversion character %%%s.\n", p1); 315 error_msg_and_die("hexdump: bad conversion character %%%s.\n",
316 p1);
280 } 317 }
281 318
282 /* 319 /*
@@ -292,8 +329,9 @@ sw2: switch(fu->bcnt) {
292 fmtp = p2; 329 fmtp = p2;
293 330
294 /* only one conversion character if byte count */ 331 /* only one conversion character if byte count */
295 if (!(pr->flags&F_ADDRESS) && fu->bcnt && nconv++) { 332 if (!(pr->flags & F_ADDRESS) && fu->bcnt && nconv++) {
296 error_msg_and_die("hexdump: byte count with multiple conversion characters.\n"); 333 error_msg_and_die
334 ("hexdump: byte count with multiple conversion characters.\n");
297 } 335 }
298 } 336 }
299 /* 337 /*
@@ -315,7 +353,7 @@ sw2: switch(fu->bcnt) {
315 */ 353 */
316 for (fu = fs->nextfu;; fu = fu->nextfu) { 354 for (fu = fs->nextfu;; fu = fu->nextfu) {
317 if (!fu->nextfu && fs->bcnt < blocksize && 355 if (!fu->nextfu && fs->bcnt < blocksize &&
318 !(fu->flags&F_SETREP) && fu->bcnt) 356 !(fu->flags & F_SETREP) && fu->bcnt)
319 fu->reps += (blocksize - fs->bcnt) / fu->bcnt; 357 fu->reps += (blocksize - fs->bcnt) / fu->bcnt;
320 if (fu->reps > 1) { 358 if (fu->reps > 1) {
321 for (pr = fu->nextpr;; pr = pr->nextpr) 359 for (pr = fu->nextpr;; pr = pr->nextpr)
@@ -339,11 +377,10 @@ static void doskip(char *fname, int statok)
339 if (fstat(fileno(stdin), &sbuf)) { 377 if (fstat(fileno(stdin), &sbuf)) {
340 perror_msg_and_die("hexdump: %s", fname); 378 perror_msg_and_die("hexdump: %s", fname);
341 } 379 }
342 if ( ( ! (S_ISCHR(sbuf.st_mode) || 380 if ((!(S_ISCHR(sbuf.st_mode) ||
343 S_ISBLK(sbuf.st_mode) || 381 S_ISBLK(sbuf.st_mode) ||
344 S_ISFIFO(sbuf.st_mode)) ) && 382 S_ISFIFO(sbuf.st_mode))) && skip >= sbuf.st_size) {
345 skip >= sbuf.st_size) { 383 /* If size valid and skip >= size */
346 /* If size valid and skip >= size */
347 skip -= sbuf.st_size; 384 skip -= sbuf.st_size;
348 address += sbuf.st_size; 385 address += sbuf.st_size;
349 return; 386 return;
@@ -363,7 +400,7 @@ int next(char **argv)
363 400
364 if (argv) { 401 if (argv) {
365 _argv = argv; 402 _argv = argv;
366 return(1); 403 return (1);
367 } 404 }
368 for (;;) { 405 for (;;) {
369 if (*_argv) { 406 if (*_argv) {
@@ -376,7 +413,7 @@ int next(char **argv)
376 statok = done = 1; 413 statok = done = 1;
377 } else { 414 } else {
378 if (done++) 415 if (done++)
379 return(0); 416 return (0);
380 statok = 0; 417 statok = 0;
381 } 418 }
382 if (skip) 419 if (skip)
@@ -384,13 +421,12 @@ int next(char **argv)
384 if (*_argv) 421 if (*_argv)
385 ++_argv; 422 ++_argv;
386 if (!skip) 423 if (!skip)
387 return(1); 424 return (1);
388 } 425 }
389 /* NOTREACHED */ 426 /* NOTREACHED */
390} 427}
391 428
392static u_char * 429static u_char *get(void)
393get(void)
394{ 430{
395 static int ateof = 1; 431 static int ateof = 1;
396 static u_char *curp, *savp; 432 static u_char *curp, *savp;
@@ -399,8 +435,8 @@ get(void)
399 u_char *tmpp; 435 u_char *tmpp;
400 436
401 if (!curp) { 437 if (!curp) {
402 curp = (u_char *)xmalloc(blocksize); 438 curp = (u_char *) xmalloc(blocksize);
403 savp = (u_char *)xmalloc(blocksize); 439 savp = (u_char *) xmalloc(blocksize);
404 } else { 440 } else {
405 tmpp = curp; 441 tmpp = curp;
406 curp = savp; 442 curp = savp;
@@ -413,22 +449,22 @@ get(void)
413 * and no other files are available, zero-pad the rest of the 449 * and no other files are available, zero-pad the rest of the
414 * block and set the end flag. 450 * block and set the end flag.
415 */ 451 */
416 if (!length || (ateof && !next((char **)NULL))) { 452 if (!length || (ateof && !next((char **) NULL))) {
417 if (need == blocksize) { 453 if (need == blocksize) {
418 return((u_char *)NULL); 454 return ((u_char *) NULL);
419 } 455 }
420 if (vflag != ALL && !bcmp(curp, savp, nread)) { 456 if (vflag != ALL && !bcmp(curp, savp, nread)) {
421 if (vflag != DUP) { 457 if (vflag != DUP) {
422 printf("*\n"); 458 printf("*\n");
423 } 459 }
424 return((u_char *)NULL); 460 return ((u_char *) NULL);
425 } 461 }
426 bzero((char *)curp + nread, need); 462 bzero((char *) curp + nread, need);
427 eaddress = address + nread; 463 eaddress = address + nread;
428 return(curp); 464 return (curp);
429 } 465 }
430 n = fread((char *)curp + nread, sizeof(u_char), 466 n = fread((char *) curp + nread, sizeof(u_char),
431 length == -1 ? need : MIN(length, need), stdin); 467 length == -1 ? need : MIN(length, need), stdin);
432 if (!n) { 468 if (!n) {
433 if (ferror(stdin)) { 469 if (ferror(stdin)) {
434 perror_msg("%s", _argv[-1]); 470 perror_msg("%s", _argv[-1]);
@@ -441,12 +477,11 @@ get(void)
441 length -= n; 477 length -= n;
442 } 478 }
443 if (!(need -= n)) { 479 if (!(need -= n)) {
444 if (vflag == ALL || vflag == FIRST || 480 if (vflag == ALL || vflag == FIRST || bcmp(curp, savp, blocksize)) {
445 bcmp(curp, savp, blocksize)) {
446 if (vflag == DUP || vflag == FIRST) { 481 if (vflag == DUP || vflag == FIRST) {
447 vflag = WAIT; 482 vflag = WAIT;
448 } 483 }
449 return(curp); 484 return (curp);
450 } 485 }
451 if (vflag == WAIT) { 486 if (vflag == WAIT) {
452 printf("*\n"); 487 printf("*\n");
@@ -461,7 +496,7 @@ get(void)
461 } 496 }
462} 497}
463 498
464static void bpad(PR *pr) 499static void bpad(PR * pr)
465{ 500{
466 register char *p1, *p2; 501 register char *p1, *p2;
467 502
@@ -473,18 +508,18 @@ static void bpad(PR *pr)
473 *pr->cchar = 's'; 508 *pr->cchar = 's';
474 for (p1 = pr->fmt; *p1 != '%'; ++p1); 509 for (p1 = pr->fmt; *p1 != '%'; ++p1);
475 for (p2 = ++p1; *p1 && index(" -0+#", *p1); ++p1); 510 for (p2 = ++p1; *p1 && index(" -0+#", *p1); ++p1);
476 while ((*p2++ = *p1++) != 0) ; 511 while ((*p2++ = *p1++) != 0);
477} 512}
478 513
479void conv_c(PR *pr, u_char *p) 514void conv_c(PR * pr, u_char * p)
480{ 515{
481 char buf[10], *str; 516 char buf[10], *str;
482 517
483 switch(*p) { 518 switch (*p) {
484 case '\0': 519 case '\0':
485 str = "\\0"; 520 str = "\\0";
486 goto strpr; 521 goto strpr;
487 /* case '\a': */ 522 /* case '\a': */
488 case '\007': 523 case '\007':
489 str = "\\a"; 524 str = "\\a";
490 goto strpr; 525 goto strpr;
@@ -511,22 +546,22 @@ void conv_c(PR *pr, u_char *p)
511 } 546 }
512 if (isprint(*p)) { 547 if (isprint(*p)) {
513 *pr->cchar = 'c'; 548 *pr->cchar = 'c';
514 (void)printf(pr->fmt, *p); 549 (void) printf(pr->fmt, *p);
515 } else { 550 } else {
516 sprintf(str = buf, "%03o", (int)*p); 551 sprintf(str = buf, "%03o", (int) *p);
517strpr: 552 strpr:
518 *pr->cchar = 's'; 553 *pr->cchar = 's';
519 printf(pr->fmt, str); 554 printf(pr->fmt, str);
520 } 555 }
521} 556}
522 557
523void conv_u(PR *pr, u_char *p) 558void conv_u(PR * pr, u_char * p)
524{ 559{
525 static char *list[] = { 560 static char *list[] = {
526 "nul", "soh", "stx", "etx", "eot", "enq", "ack", "bel", 561 "nul", "soh", "stx", "etx", "eot", "enq", "ack", "bel",
527 "bs", "ht", "lf", "vt", "ff", "cr", "so", "si", 562 "bs", "ht", "lf", "vt", "ff", "cr", "so", "si",
528 "dle", "dcl", "dc2", "dc3", "dc4", "nak", "syn", "etb", 563 "dle", "dcl", "dc2", "dc3", "dc4", "nak", "syn", "etb",
529 "can", "em", "sub", "esc", "fs", "gs", "rs", "us", 564 "can", "em", "sub", "esc", "fs", "gs", "rs", "us",
530 }; 565 };
531 566
532 /* od used nl, not lf */ 567 /* od used nl, not lf */
@@ -541,118 +576,128 @@ void conv_u(PR *pr, u_char *p)
541 printf(pr->fmt, *p); 576 printf(pr->fmt, *p);
542 } else { 577 } else {
543 *pr->cchar = 'x'; 578 *pr->cchar = 'x';
544 printf(pr->fmt, (int)*p); 579 printf(pr->fmt, (int) *p);
545 } 580 }
546} 581}
547 582
548void display(void) 583void display(void)
549{ 584{
550// extern FU *endfu; 585/* extern FU *endfu; */
551 register FS *fs; 586 register FS *fs;
552 register FU *fu; 587 register FU *fu;
553 register PR *pr; 588 register PR *pr;
554 register int cnt; 589 register int cnt;
555 register u_char *bp; 590 register u_char *bp;
556// off_t saveaddress; 591
592/* off_t saveaddress; */
557 u_char savech = 0, *savebp; 593 u_char savech = 0, *savebp;
558 594
559 while ((bp = get()) != NULL) { 595 while ((bp = get()) != NULL) {
560 for (fs = fshead, savebp = bp, saveaddress = address; fs; 596 for (fs = fshead, savebp = bp, saveaddress = address; fs;
561 fs = fs->nextfs, bp = savebp, address = saveaddress) { 597 fs = fs->nextfs, bp = savebp, address = saveaddress) {
562 for (fu = fs->nextfu; fu; fu = fu->nextfu) { 598 for (fu = fs->nextfu; fu; fu = fu->nextfu) {
563 if (fu->flags & F_IGNORE) { 599 if (fu->flags & F_IGNORE) {
564 break; 600 break;
565 } 601 }
566 for (cnt = fu->reps; cnt; --cnt) { 602 for (cnt = fu->reps; cnt; --cnt) {
567 for (pr = fu->nextpr; pr; address += pr->bcnt, 603 for (pr = fu->nextpr; pr; address += pr->bcnt,
568 bp += pr->bcnt, pr = pr->nextpr) { 604 bp += pr->bcnt, pr = pr->nextpr) {
569 if (eaddress && address >= eaddress && 605 if (eaddress && address >= eaddress &&
570 !(pr->flags&(F_TEXT|F_BPAD))) { 606 !(pr->flags & (F_TEXT | F_BPAD))) {
571 bpad(pr); 607 bpad(pr);
572 } 608 }
573 if (cnt == 1 && pr->nospace) { 609 if (cnt == 1 && pr->nospace) {
574 savech = *pr->nospace; 610 savech = *pr->nospace;
575 *pr->nospace = '\0'; 611 *pr->nospace = '\0';
576 } 612 }
577// PRINT; 613/* PRINT; */
578 switch(pr->flags) { 614 switch (pr->flags) {
579 case F_ADDRESS: 615 case F_ADDRESS:
580 printf(pr->fmt, address); 616 printf(pr->fmt, address);
581 break; 617 break;
582 case F_BPAD: 618 case F_BPAD:
583 printf(pr->fmt, ""); 619 printf(pr->fmt, "");
584 break; 620 break;
585 case F_C: 621 case F_C:
586 conv_c(pr, bp); 622 conv_c(pr, bp);
587 break; 623 break;
588 case F_CHAR: 624 case F_CHAR:
589 printf(pr->fmt, *bp); 625 printf(pr->fmt, *bp);
626 break;
627 case F_DBL:{
628 double dval;
629 float fval;
630
631 switch (pr->bcnt) {
632 case 4:
633 bcopy((char *) bp, (char *) &fval,
634 sizeof(fval));
635 printf(pr->fmt, fval);
590 break; 636 break;
591 case F_DBL: { 637 case 8:
592 double dval; 638 bcopy((char *) bp, (char *) &dval,
593 float fval; 639 sizeof(dval));
594 switch(pr->bcnt) { 640 printf(pr->fmt, dval);
595 case 4:
596 bcopy((char *)bp, (char *)&fval, sizeof(fval));
597 printf(pr->fmt, fval);
598 break;
599 case 8:
600 bcopy((char *)bp, (char *)&dval, sizeof(dval));
601 printf(pr->fmt, dval);
602 break;
603 }
604 break; 641 break;
605 } 642 }
606 case F_INT: { 643 break;
607 int ival; 644 }
608 short sval; 645 case F_INT:{
609 switch(pr->bcnt) { 646 int ival;
610 case 1: 647 short sval;
611 printf(pr->fmt, (int)*bp); 648
612 break; 649 switch (pr->bcnt) {
613 case 2: 650 case 1:
614 bcopy((char *)bp, (char *)&sval, sizeof(sval)); 651 printf(pr->fmt, (int) *bp);
615 printf(pr->fmt, (int)sval);
616 break;
617 case 4:
618 bcopy((char *)bp, (char *)&ival, sizeof(ival));
619 printf(pr->fmt, ival);
620 break;
621 }
622 break; 652 break;
623 } 653 case 2:
624 case F_P: 654 bcopy((char *) bp, (char *) &sval,
625 printf(pr->fmt, isprint(*bp) ? *bp : '.'); 655 sizeof(sval));
656 printf(pr->fmt, (int) sval);
626 break; 657 break;
627 case F_STR: 658 case 4:
628 printf(pr->fmt, (char *)bp); 659 bcopy((char *) bp, (char *) &ival,
660 sizeof(ival));
661 printf(pr->fmt, ival);
629 break; 662 break;
630 case F_TEXT: 663 }
631 printf(pr->fmt); 664 break;
665 }
666 case F_P:
667 printf(pr->fmt, isprint(*bp) ? *bp : '.');
668 break;
669 case F_STR:
670 printf(pr->fmt, (char *) bp);
671 break;
672 case F_TEXT:
673 printf(pr->fmt);
674 break;
675 case F_U:
676 conv_u(pr, bp);
677 break;
678 case F_UINT:{
679 u_int ival;
680 u_short sval;
681
682 switch (pr->bcnt) {
683 case 1:
684 printf(pr->fmt, (u_int) * bp);
632 break; 685 break;
633 case F_U: 686 case 2:
634 conv_u(pr, bp); 687 bcopy((char *) bp, (char *) &sval,
688 sizeof(sval));
689 printf(pr->fmt, (u_int) sval);
635 break; 690 break;
636 case F_UINT: { 691 case 4:
637 u_int ival; 692 bcopy((char *) bp, (char *) &ival,
638 u_short sval; 693 sizeof(ival));
639 switch(pr->bcnt) { 694 printf(pr->fmt, ival);
640 case 1:
641 printf(pr->fmt, (u_int)*bp);
642 break;
643 case 2:
644 bcopy((char *)bp, (char *)&sval, sizeof(sval));
645 printf(pr->fmt, (u_int)sval);
646 break;
647 case 4:
648 bcopy((char *)bp, (char *)&ival, sizeof(ival));
649 printf(pr->fmt, ival);
650 break;
651 }
652 break; 695 break;
653 } 696 }
697 break;
654 } 698 }
655 if (cnt == 1 && pr->nospace) { 699 }
700 if (cnt == 1 && pr->nospace) {
656 *pr->nospace = savech; 701 *pr->nospace = savech;
657 } 702 }
658 } 703 }
@@ -672,12 +717,12 @@ void display(void)
672 eaddress = address; 717 eaddress = address;
673 } 718 }
674 for (pr = endfu->nextpr; pr; pr = pr->nextpr) { 719 for (pr = endfu->nextpr; pr; pr = pr->nextpr) {
675 switch(pr->flags) { 720 switch (pr->flags) {
676 case F_ADDRESS: 721 case F_ADDRESS:
677 (void)printf(pr->fmt, eaddress); 722 (void) printf(pr->fmt, eaddress);
678 break; 723 break;
679 case F_TEXT: 724 case F_TEXT:
680 (void)printf(pr->fmt); 725 (void) printf(pr->fmt);
681 break; 726 break;
682 } 727 }
683 } 728 }
@@ -703,7 +748,7 @@ int dump(char **argv)
703 next(argv); 748 next(argv);
704 display(); 749 display();
705 750
706 return(exitval); 751 return (exitval);
707} 752}
708 753
709void add(char *fmt) 754void add(char *fmt)
@@ -718,7 +763,7 @@ void add(char *fmt)
718 763
719 /* start new linked list of format units */ 764 /* start new linked list of format units */
720 /* NOSTRICT */ 765 /* NOSTRICT */
721 tfs = (FS *)xmalloc(sizeof(FS)); 766 tfs = (FS *) xmalloc(sizeof(FS));
722 if (!fshead) { 767 if (!fshead) {
723 fshead = tfs; 768 fshead = tfs;
724 } else { 769 } else {
@@ -737,7 +782,7 @@ void add(char *fmt)
737 782
738 /* allocate a new format unit and link it in */ 783 /* allocate a new format unit and link it in */
739 /* NOSTRICT */ 784 /* NOSTRICT */
740 tfu = (FU *)xmalloc(sizeof(FU)); 785 tfu = (FU *) xmalloc(sizeof(FU));
741 *nextfu = tfu; 786 *nextfu = tfu;
742 nextfu = &tfu->nextfu; 787 nextfu = &tfu->nextfu;
743 tfu->reps = 1; 788 tfu->reps = 1;
@@ -785,7 +830,7 @@ void add(char *fmt)
785 } 830 }
786 strncpy(tfu->fmt, savep, p - savep); 831 strncpy(tfu->fmt, savep, p - savep);
787 tfu->fmt[p - savep] = '\0'; 832 tfu->fmt[p - savep] = '\0';
788// escape(tfu->fmt); 833/* escape(tfu->fmt); */
789 834
790 p1 = tfu->fmt; 835 p1 = tfu->fmt;
791 836
@@ -796,9 +841,9 @@ void add(char *fmt)
796 break; 841 break;
797 } 842 }
798 if (*p1 == '\\') { 843 if (*p1 == '\\') {
799 switch(*++p1) { 844 switch (*++p1) {
800 case 'a': 845 case 'a':
801 /* *p2 = '\a'; */ 846 /* *p2 = '\a'; */
802 *p2 = '\007'; 847 *p2 = '\007';
803 break; 848 break;
804 case 'b': 849 case 'b':
@@ -829,6 +874,7 @@ void add(char *fmt)
829 p++; 874 p++;
830 } 875 }
831} 876}
877
832/* 878/*
833 * Copyright (c) 1989 The Regents of the University of California. 879 * Copyright (c) 1989 The Regents of the University of California.
834 * All rights reserved. 880 * All rights reserved.
generated by cgit v1.2.3-55-g6feb (git 2.39.1) at 2025-08-13 12:50:37 +0000