libbb/dump.c

   1 /* vi: set sw=4 ts=4: */
   2 /*
   3  * Support code for the hexdump and od applets,
   4  * based on code from util-linux v 2.11l
   5  *
   6  * Copyright (c) 1989
   7  *      The Regents of the University of California.  All rights reserved.
   8  *
   9  * Licensed under GPLv2 or later, see file LICENSE in this tarball for details.
  10  *
  11  * Original copyright notice is retained at the end of this file.
  12  */
  13
  14 #include "libbb.h"
  15 #include "dump.h"
  16
  17 enum _vflag bb_dump_vflag = FIRST;
  18 FS *bb_dump_fshead;                             /* head of format strings */
  19 static FU *endfu;
  20 static char **_argv;
  21 static off_t savaddress;        /* saved address/offset in stream */
  22 static off_t eaddress;  /* end address */
  23 static off_t address;   /* address/offset in stream */
  24 off_t bb_dump_skip;                             /* bytes to skip */
  25 static int exitval;                     /* final exit value */
  26 int bb_dump_blocksize;                  /* data block size */
  27 int bb_dump_length = -1;                /* max bytes to read */
  28
  29 static const char index_str[] ALIGN1 = ".#-+ 0123456789";
  30
  31 static const char size_conv_str[] ALIGN1 =
  32 "\x1\x4\x4\x4\x4\x4\x4\x8\x8\x8\x8\010cdiouxXeEfgG";
  33
  34 static const char lcc[] ALIGN1 = "diouxX";
  35
  36 int bb_dump_size(FS * fs)
  37 {
  38         FU *fu;
  39         int bcnt, cur_size;
  40         char *fmt;
  41         const char *p;
  42         int prec;
  43
  44         /* figure out the data block bb_dump_size needed for each format unit */
  45         for (cur_size = 0, fu = fs->nextfu; fu; fu = fu->nextfu) {
  46                 if (fu->bcnt) {
  47                         cur_size += fu->bcnt * fu->reps;
  48                         continue;
  49                 }
  50                 for (bcnt = prec = 0, fmt = fu->fmt; *fmt; ++fmt) {
  51                         if (*fmt != '%')
  52                                 continue;
  53                         /*
  54                          * bb_dump_skip any special chars -- save precision in
  55                          * case it's a %s format.
  56                          */
  57                         while (strchr(index_str + 1, *++fmt));
  58                         if (*fmt == '.' && isdigit(*++fmt)) {
  59                                 prec = atoi(fmt);
  60                                 while (isdigit(*++fmt));
  61                         }
  62                         if (!(p = strchr(size_conv_str + 12, *fmt))) {
  63                                 if (*fmt == 's') {
  64                                         bcnt += prec;
  65                                 } else if (*fmt == '_') {
  66                                         ++fmt;
  67                                         if ((*fmt == 'c') || (*fmt == 'p') || (*fmt == 'u')) {
  68                                                 bcnt += 1;
  69                                         }
  70                                 }
  71                         } else {
  72                                 bcnt += size_conv_str[p - (size_conv_str + 12)];
  73                         }
  74                 }
  75                 cur_size += bcnt * fu->reps;
  76         }
  77         return cur_size;
  78 }
  79
  80 static void rewrite(FS * fs)
  81 {
  82         enum { NOTOKAY, USEBCNT, USEPREC } sokay;
  83         PR *pr, **nextpr = NULL;
  84         FU *fu;
  85         char *p1, *p2, *p3;
  86         char savech, *fmtp;
  87         const char *byte_count_str;
  88         int nconv, prec = 0;
  89
  90         for (fu = fs->nextfu; fu; fu = fu->nextfu) {
  91                 /*
  92                  * break each format unit into print units; each
  93                  * conversion character gets its own.
  94                  */
  95                 for (nconv = 0, fmtp = fu->fmt; *fmtp; nextpr = &pr->nextpr) {
  96                         /* NOSTRICT */
  97                         /* DBU:[dvae@cray.com] calloc so that forward ptrs start out NULL*/
  98                         pr = xzalloc(sizeof(PR));
  99                         if (!fu->nextpr)
 100                                 fu->nextpr = pr;
 101                         /* ignore nextpr -- its unused inside the loop and is
 102                          * uninitialized 1st time thru.
 103                          */
 104
 105                         /* bb_dump_skip preceding text and up to the next % sign */
 106                         for (p1 = fmtp; *p1 && *p1 != '%'; ++p1);
 107
 108                         /* only text in the string */
 109                         if (!*p1) {
 110                                 pr->fmt = fmtp;
 111                                 pr->flags = F_TEXT;
 112                                 break;
 113                         }
 114
 115                         /*
 116                          * get precision for %s -- if have a byte count, don't
 117                          * need it.
 118                          */
 119                         if (fu->bcnt) {
 120                                 sokay = USEBCNT;
 121                                 /* bb_dump_skip to conversion character */
 122                                 for (++p1; strchr(index_str, *p1); ++p1);
 123                         } else {
 124                                 /* bb_dump_skip any special chars, field width */
 125                                 while (strchr(index_str + 1, *++p1));
 126                                 if (*p1 == '.' && isdigit(*++p1)) {
 127                                         sokay = USEPREC;
 128                                         prec = atoi(p1);
 129                                         while (isdigit(*++p1));
 130                                 } else
 131                                         sokay = NOTOKAY;
 132                         }
 133
 134                         p2 = p1 + 1;    /* set end pointer */
 135
 136                         /*
 137                          * figure out the byte count for each conversion;
 138                          * rewrite the format as necessary, set up blank-
 139                          * pbb_dump_adding for end of data.
 140                          */
 141
 142                         if (*p1 == 'c') {
 143                                 pr->flags = F_CHAR;
 144                         DO_BYTE_COUNT_1:
 145                                 byte_count_str = "\001";
 146                         DO_BYTE_COUNT:
 147                                 if (fu->bcnt) {
 148                                         do {
 149                                                 if (fu->bcnt == *byte_count_str) {
 150                                                         break;
 151                                                 }
 152                                         } while (*++byte_count_str);
 153                                 }
 154                                 /* Unlike the original, output the remainder of the format string. */
 155                                 if (!*byte_count_str) {
 156                                         bb_error_msg_and_die("bad byte count for conversion character %s", p1);
 157                                 }
 158                                 pr->bcnt = *byte_count_str;
 159                         } else if (*p1 == 'l') {
 160                                 ++p2;
 161                                 ++p1;
 162                         DO_INT_CONV:
 163                                 {
 164                                         const char *e;
 165                                         if (!(e = strchr(lcc, *p1))) {
 166                                                 goto DO_BAD_CONV_CHAR;
 167                                         }
 168                                         pr->flags = F_INT;
 169                                         if (e > lcc + 1) {
 170                                                 pr->flags = F_UINT;
 171                                         }
 172                                         byte_count_str = "\004\002\001";
 173                                         goto DO_BYTE_COUNT;
 174                                 }
 175                                 /* NOTREACHED */
 176                         } else if (strchr(lcc, *p1)) {
 177                                 goto DO_INT_CONV;
 178                         } else if (strchr("eEfgG", *p1)) {
 179                                 pr->flags = F_DBL;
 180                                 byte_count_str = "\010\004";
 181                                 goto DO_BYTE_COUNT;
 182                         } else if (*p1 == 's') {
 183                                 pr->flags = F_STR;
 184                                 if (sokay == USEBCNT) {
 185                                         pr->bcnt = fu->bcnt;
 186                                 } else if (sokay == USEPREC) {
 187                                         pr->bcnt = prec;
 188                                 } else {        /* NOTOKAY */
 189                                         bb_error_msg_and_die("%%s requires a precision or a byte count");
 190                                 }
 191                         } else if (*p1 == '_') {
 192                                 ++p2;
 193                                 switch (p1[1]) {
 194                                 case 'A':
 195                                         endfu = fu;
 196                                         fu->flags |= F_IGNORE;
 197                                         /* FALLTHROUGH */
 198                                 case 'a':
 199                                         pr->flags = F_ADDRESS;
 200                                         ++p2;
 201                                         if ((p1[2] != 'd') && (p1[2] != 'o') && (p1[2] != 'x')) {
 202                                                 goto DO_BAD_CONV_CHAR;
 203                                         }
 204                                         *p1 = p1[2];
 205                                         break;
 206                                 case 'c':
 207                                         pr->flags = F_C;
 208                                         /* *p1 = 'c';   set in conv_c */
 209                                         goto DO_BYTE_COUNT_1;
 210                                 case 'p':
 211                                         pr->flags = F_P;
 212                                         *p1 = 'c';
 213                                         goto DO_BYTE_COUNT_1;
 214                                 case 'u':
 215                                         pr->flags = F_U;
 216                                         /* *p1 = 'c';   set in conv_u */
 217                                         goto DO_BYTE_COUNT_1;
 218                                 default:
 219                                         goto DO_BAD_CONV_CHAR;
 220                                 }
 221                         } else {
 222                         DO_BAD_CONV_CHAR:
 223                                 bb_error_msg_and_die("bad conversion character %%%s", p1);
 224                         }
 225
 226                         /*
 227                          * copy to PR format string, set conversion character
 228                          * pointer, update original.
 229                          */
 230                         savech = *p2;
 231                         p1[1] = '\0';
 232                         pr->fmt = xstrdup(fmtp);
 233                         *p2 = savech;
 234                         pr->cchar = pr->fmt + (p1 - fmtp);
 235
 236                         /* DBU:[dave@cray.com] w/o this, trailing fmt text, space is lost.
 237                          * Skip subsequent text and up to the next % sign and tack the
 238                          * additional text onto fmt: eg. if fmt is "%x is a HEX number",
 239                          * we lose the " is a HEX number" part of fmt.
 240                          */
 241                         for (p3 = p2; *p3 && *p3 != '%'; p3++);
 242                         if (p3 > p2)
 243                         {
 244                                 savech = *p3;
 245                                 *p3 = '\0';
 246                                 pr->fmt = xrealloc(pr->fmt, strlen(pr->fmt)+(p3-p2)+1);
 247                                 strcat(pr->fmt, p2);
 248                                 *p3 = savech;
 249                                 p2 = p3;
 250                         }
 251
 252                         fmtp = p2;
 253
 254                         /* only one conversion character if byte count */
 255                         if (!(pr->flags & F_ADDRESS) && fu->bcnt && nconv++) {
 256                                 bb_error_msg_and_die("byte count with multiple conversion characters");
 257                         }
 258                 }
 259                 /*
 260                  * if format unit byte count not specified, figure it out
 261                  * so can adjust rep count later.
 262                  */
 263                 if (!fu->bcnt)
 264                         for (pr = fu->nextpr; pr; pr = pr->nextpr)
 265                                 fu->bcnt += pr->bcnt;
 266         }
 267         /*
 268          * if the format string interprets any data at all, and it's
 269          * not the same as the bb_dump_blocksize, and its last format unit
 270          * interprets any data at all, and has no iteration count,
 271          * repeat it as necessary.
 272          *
 273          * if, rep count is greater than 1, no trailing whitespace
 274          * gets output from the last iteration of the format unit.
 275          */
 276         for (fu = fs->nextfu;; fu = fu->nextfu) {
 277                 if (!fu->nextfu && fs->bcnt < bb_dump_blocksize &&
 278                         !(fu->flags & F_SETREP) && fu->bcnt)
 279                         fu->reps += (bb_dump_blocksize - fs->bcnt) / fu->bcnt;
 280                 if (fu->reps > 1) {
 281                         for (pr = fu->nextpr;; pr = pr->nextpr)
 282                                 if (!pr->nextpr)
 283                                         break;
 284                         for (p1 = pr->fmt, p2 = NULL; *p1; ++p1)
 285                                 p2 = isspace(*p1) ? p1 : NULL;
 286                         if (p2)
 287                                 pr->nospace = p2;
 288                 }
 289                 if (!fu->nextfu)
 290                         break;
 291         }
 292 }
 293
 294 static void do_skip(const char *fname, int statok)
 295 {
 296         struct stat sbuf;
 297
 298         if (statok) {
 299                 if (fstat(STDIN_FILENO, &sbuf)) {
 300                         bb_perror_msg_and_die("%s", fname);
 301                 }
 302                 if ((!(S_ISCHR(sbuf.st_mode) ||
 303                            S_ISBLK(sbuf.st_mode) ||
 304                            S_ISFIFO(sbuf.st_mode))) && bb_dump_skip >= sbuf.st_size) {
 305                         /* If bb_dump_size valid and bb_dump_skip >= size */
 306                         bb_dump_skip -= sbuf.st_size;
 307                         address += sbuf.st_size;
 308                         return;
 309                 }
 310         }
 311         if (fseek(stdin, bb_dump_skip, SEEK_SET)) {
 312                 bb_perror_msg_and_die("%s", fname);
 313         }
 314         savaddress = address += bb_dump_skip;
 315         bb_dump_skip = 0;
 316 }
 317
 318 static int next(char **argv)
 319 {
 320         static smallint done;
 321
 322         int statok;
 323
 324         if (argv) {
 325                 _argv = argv;
 326                 return 1;
 327         }
 328         for (;;) {
 329                 if (*_argv) {
 330                         if (!(freopen(*_argv, "r", stdin))) {
 331                                 bb_perror_msg("%s", *_argv);
 332                                 exitval = 1;
 333                                 ++_argv;
 334                                 continue;
 335                         }
 336                         done = statok = 1;
 337                 } else {
 338                         if (done)
 339                                 return 0;
 340                         done = 1;
 341                         statok = 0;
 342                 }
 343                 if (bb_dump_skip)
 344                         do_skip(statok ? *_argv : "stdin", statok);
 345                 if (*_argv)
 346                         ++_argv;
 347                 if (!bb_dump_skip)
 348                         return 1;
 349         }
 350         /* NOTREACHED */
 351 }
 352
 353 static unsigned char *get(void)
 354 {
 355         static smallint ateof = 1;
 356         static unsigned char *curp = NULL, *savp; /*DBU:[dave@cray.com]initialize curp */
 357
 358         int n;
 359         int need, nread;
 360         unsigned char *tmpp;
 361
 362         if (!curp) {
 363                 address = (off_t)0; /*DBU:[dave@cray.com] initialize,initialize..*/
 364                 curp = xmalloc(bb_dump_blocksize);
 365                 savp = xmalloc(bb_dump_blocksize);
 366         } else {
 367                 tmpp = curp;
 368                 curp = savp;
 369                 savp = tmpp;
 370                 address = savaddress += bb_dump_blocksize;
 371         }
 372         for (need = bb_dump_blocksize, nread = 0;;) {
 373                 /*
 374                  * if read the right number of bytes, or at EOF for one file,
 375                  * and no other files are available, zero-pad the rest of the
 376                  * block and set the end flag.
 377                  */
 378                 if (!bb_dump_length || (ateof && !next((char **) NULL))) {
 379                         if (need == bb_dump_blocksize) {
 380                                 return NULL;
 381                         }
 382                         if (bb_dump_vflag != ALL && !memcmp(curp, savp, nread)) {
 383                                 if (bb_dump_vflag != DUP) {
 384                                         puts("*");
 385                                 }
 386                                 return NULL;
 387                         }
 388                         memset((char *) curp + nread, 0, need);
 389                         eaddress = address + nread;
 390                         return curp;
 391                 }
 392                 n = fread((char *) curp + nread, sizeof(unsigned char),
 393                                   bb_dump_length == -1 ? need : MIN(bb_dump_length, need), stdin);
 394                 if (!n) {
 395                         if (ferror(stdin)) {
 396                                 bb_perror_msg("%s", _argv[-1]);
 397                         }
 398                         ateof = 1;
 399                         continue;
 400                 }
 401                 ateof = 0;
 402                 if (bb_dump_length != -1) {
 403                         bb_dump_length -= n;
 404                 }
 405                 need -= n;
 406                 if (!need) {
 407                         if (bb_dump_vflag == ALL || bb_dump_vflag == FIRST
 408                                 || memcmp(curp, savp, bb_dump_blocksize)) {
 409                                 if (bb_dump_vflag == DUP || bb_dump_vflag == FIRST) {
 410                                         bb_dump_vflag = WAIT;
 411                                 }
 412                                 return curp;
 413                         }
 414                         if (bb_dump_vflag == WAIT) {
 415                                 puts("*");
 416                         }
 417                         bb_dump_vflag = DUP;
 418                         address = savaddress += bb_dump_blocksize;
 419                         need = bb_dump_blocksize;
 420                         nread = 0;
 421                 } else {
 422                         nread += n;
 423                 }
 424         }
 425 }
 426
 427 static void bpad(PR * pr)
 428 {
 429         char *p1, *p2;
 430
 431         /*
 432          * remove all conversion flags; '-' is the only one valid
 433          * with %s, and it's not useful here.
 434          */
 435         pr->flags = F_BPAD;
 436         *pr->cchar = 's';
 437         for (p1 = pr->fmt; *p1 != '%'; ++p1);
 438         for (p2 = ++p1; *p1 && strchr(" -0+#", *p1); ++p1)
 439                 if (pr->nospace) pr->nospace--;
 440         while ((*p2++ = *p1++) != 0);
 441 }
 442
 443 static const char conv_str[] ALIGN1 =
 444         "\0\\0\0"
 445         "\007\\a\0"                             /* \a */
 446         "\b\\b\0"
 447         "\f\\b\0"
 448         "\n\\n\0"
 449         "\r\\r\0"
 450         "\t\\t\0"
 451         "\v\\v\0"
 452         ;
 453
 454
 455 static void conv_c(PR * pr, unsigned char * p)
 456 {
 457         const char *str = conv_str;
 458         char buf[10];
 459
 460         do {
 461                 if (*p == *str) {
 462                         ++str;
 463                         goto strpr;
 464                 }
 465                 str += 4;
 466         } while (*str);
 467
 468         if (isprint(*p)) {
 469                 *pr->cchar = 'c';
 470                 (void) printf(pr->fmt, *p);
 471         } else {
 472                 sprintf(buf, "%03o", (int) *p);
 473                 str = buf;
 474           strpr:
 475                 *pr->cchar = 's';
 476                 printf(pr->fmt, str);
 477         }
 478 }
 479
 480 static void conv_u(PR * pr, unsigned char * p)
 481 {
 482         static const char list[] ALIGN1 =
 483                 "nul\0soh\0stx\0etx\0eot\0enq\0ack\0bel\0"
 484                 "bs\0_ht\0_lf\0_vt\0_ff\0_cr\0_so\0_si\0_"
 485                 "dle\0dcl\0dc2\0dc3\0dc4\0nak\0syn\0etb\0"
 486                 "can\0em\0_sub\0esc\0fs\0_gs\0_rs\0_us";
 487
 488         /* od used nl, not lf */
 489         if (*p <= 0x1f) {
 490                 *pr->cchar = 's';
 491                 printf(pr->fmt, list + (4 * (int)*p));
 492         } else if (*p == 0x7f) {
 493                 *pr->cchar = 's';
 494                 printf(pr->fmt, "del");
 495         } else if (isprint(*p)) {
 496                 *pr->cchar = 'c';
 497                 printf(pr->fmt, *p);
 498         } else {
 499                 *pr->cchar = 'x';
 500                 printf(pr->fmt, (int) *p);
 501         }
 502 }
 503
 504 static void display(void)
 505 {
 506 /*  extern FU *endfu; */
 507         FS *fs;
 508         FU *fu;
 509         PR *pr;
 510         int cnt;
 511         unsigned char *bp;
 512
 513         off_t saveaddress;
 514         unsigned char savech = 0, *savebp;
 515
 516         while ((bp = get()) != NULL) {
 517                 for (fs = bb_dump_fshead, savebp = bp, saveaddress = address; fs;
 518                          fs = fs->nextfs, bp = savebp, address = saveaddress) {
 519                         for (fu = fs->nextfu; fu; fu = fu->nextfu) {
 520                                 if (fu->flags & F_IGNORE) {
 521                                         break;
 522                                 }
 523                                 for (cnt = fu->reps; cnt; --cnt) {
 524                                         for (pr = fu->nextpr; pr; address += pr->bcnt,
 525                                                  bp += pr->bcnt, pr = pr->nextpr) {
 526                                                 if (eaddress && address >= eaddress &&
 527                                                         !(pr->flags & (F_TEXT | F_BPAD))) {
 528                                                         bpad(pr);
 529                                                 }
 530                                                 if (cnt == 1 && pr->nospace) {
 531                                                         savech = *pr->nospace;
 532                                                         *pr->nospace = '\0';
 533                                                 }
 534 /*                      PRINT; */
 535                                                 switch (pr->flags) {
 536                                                 case F_ADDRESS:
 537                                                         printf(pr->fmt, (unsigned int) address);
 538                                                         break;
 539                                                 case F_BPAD:
 540                                                         printf(pr->fmt, "");
 541                                                         break;
 542                                                 case F_C:
 543                                                         conv_c(pr, bp);
 544                                                         break;
 545                                                 case F_CHAR:
 546                                                         printf(pr->fmt, *bp);
 547                                                         break;
 548                                                 case F_DBL:{
 549                                                         double dval;
 550                                                         float fval;
 551
 552                                                         switch (pr->bcnt) {
 553                                                         case 4:
 554                                                                 memmove((char *) &fval, (char *) bp,
 555                                                                           sizeof(fval));
 556                                                                 printf(pr->fmt, fval);
 557                                                                 break;
 558                                                         case 8:
 559                                                                 memmove((char *) &dval, (char *) bp,
 560                                                                           sizeof(dval));
 561                                                                 printf(pr->fmt, dval);
 562                                                                 break;
 563                                                         }
 564                                                         break;
 565                                                 }
 566                                                 case F_INT:{
 567                                                         int ival;
 568                                                         short sval;
 569
 570                                                         switch (pr->bcnt) {
 571                                                         case 1:
 572                                                                 printf(pr->fmt, (int) *bp);
 573                                                                 break;
 574                                                         case 2:
 575                                                                 memmove((char *) &sval, (char *) bp,
 576                                                                           sizeof(sval));
 577                                                                 printf(pr->fmt, (int) sval);
 578                                                                 break;
 579                                                         case 4:
 580                                                                 memmove((char *) &ival, (char *) bp,
 581                                                                           sizeof(ival));
 582                                                                 printf(pr->fmt, ival);
 583                                                                 break;
 584                                                         }
 585                                                         break;
 586                                                 }
 587                                                 case F_P:
 588                                                         printf(pr->fmt, isprint(*bp) ? *bp : '.');
 589                                                         break;
 590                                                 case F_STR:
 591                                                         printf(pr->fmt, (char *) bp);
 592                                                         break;
 593                                                 case F_TEXT:
 594                                                         printf(pr->fmt);
 595                                                         break;
 596                                                 case F_U:
 597                                                         conv_u(pr, bp);
 598                                                         break;
 599                                                 case F_UINT:{
 600                                                         unsigned int ival;
 601                                                         unsigned short sval;
 602
 603                                                         switch (pr->bcnt) {
 604                                                         case 1:
 605                                                                 printf(pr->fmt, (unsigned int) * bp);
 606                                                                 break;
 607                                                         case 2:
 608                                                                 memmove((char *) &sval, (char *) bp,
 609                                                                           sizeof(sval));
 610                                                                 printf(pr->fmt, (unsigned int) sval);
 611                                                                 break;
 612                                                         case 4:
 613                                                                 memmove((char *) &ival, (char *) bp,
 614                                                                           sizeof(ival));
 615                                                                 printf(pr->fmt, ival);
 616                                                                 break;
 617                                                         }
 618                                                         break;
 619                                                 }
 620                                                 }
 621                                                 if (cnt == 1 && pr->nospace) {
 622                                                         *pr->nospace = savech;
 623                                                 }
 624                                         }
 625                                 }
 626                         }
 627                 }
 628         }
 629         if (endfu) {
 630                 /*
 631                  * if eaddress not set, error or file bb_dump_size was multiple of
 632                  * bb_dump_blocksize, and no partial block ever found.
 633                  */
 634                 if (!eaddress) {
 635                         if (!address) {
 636                                 return;
 637                         }
 638                         eaddress = address;
 639                 }
 640                 for (pr = endfu->nextpr; pr; pr = pr->nextpr) {
 641                         switch (pr->flags) {
 642                         case F_ADDRESS:
 643                                 (void) printf(pr->fmt, (unsigned int) eaddress);
 644                                 break;
 645                         case F_TEXT:
 646                                 (void) printf(pr->fmt);
 647                                 break;
 648                         }
 649                 }
 650         }
 651 }
 652
 653 int bb_dump_dump(char **argv)
 654 {
 655         FS *tfs;
 656
 657         /* figure out the data block bb_dump_size */
 658         for (bb_dump_blocksize = 0, tfs = bb_dump_fshead; tfs; tfs = tfs->nextfs) {
 659                 tfs->bcnt = bb_dump_size(tfs);
 660                 if (bb_dump_blocksize < tfs->bcnt) {
 661                         bb_dump_blocksize = tfs->bcnt;
 662                 }
 663         }
 664         /* rewrite the rules, do syntax checking */
 665         for (tfs = bb_dump_fshead; tfs; tfs = tfs->nextfs) {
 666                 rewrite(tfs);
 667         }
 668
 669         next(argv);
 670         display();
 671
 672         return exitval;
 673 }
 674
 675 void bb_dump_add(const char *fmt)
 676 {
 677         const char *p;
 678         char *p1;
 679         char *p2;
 680         static FS **nextfs;
 681         FS *tfs;
 682         FU *tfu, **nextfu;
 683         const char *savep;
 684
 685         /* start new linked list of format units */
 686         tfs = xzalloc(sizeof(FS)); /*DBU:[dave@cray.com] start out NULL */
 687         if (!bb_dump_fshead) {
 688                 bb_dump_fshead = tfs;
 689         } else {
 690                 *nextfs = tfs;
 691         }
 692         nextfs = &tfs->nextfs;
 693         nextfu = &tfs->nextfu;
 694
 695         /* take the format string and break it up into format units */
 696         for (p = fmt;;) {
 697                 /* bb_dump_skip leading white space */
 698                 p = skip_whitespace(p);
 699                 if (!*p) {
 700                         break;
 701                 }
 702
 703                 /* allocate a new format unit and link it in */
 704                 /* NOSTRICT */
 705                 /* DBU:[dave@cray.com] calloc so that forward pointers start out NULL */
 706                 tfu = xzalloc(sizeof(FU));
 707                 *nextfu = tfu;
 708                 nextfu = &tfu->nextfu;
 709                 tfu->reps = 1;
 710
 711                 /* if leading digit, repetition count */
 712                 if (isdigit(*p)) {
 713                         for (savep = p; isdigit(*p); ++p);
 714                         if (!isspace(*p) && *p != '/') {
 715                                 bb_error_msg_and_die("bad format {%s}", fmt);
 716                         }
 717                         /* may overwrite either white space or slash */
 718                         tfu->reps = atoi(savep);
 719                         tfu->flags = F_SETREP;
 720                         /* bb_dump_skip trailing white space */
 721                         p = skip_whitespace(++p);
 722                 }
 723
 724                 /* bb_dump_skip slash and trailing white space */
 725                 if (*p == '/') {
 726                         p = skip_whitespace(++p);
 727                 }
 728
 729                 /* byte count */
 730                 if (isdigit(*p)) {
 731 // TODO: use bb_strtou
 732                         savep = p;
 733                         do p++; while (isdigit(*p));
 734                         if (!isspace(*p)) {
 735                                 bb_error_msg_and_die("bad format {%s}", fmt);
 736                         }
 737                         tfu->bcnt = atoi(savep);
 738                         /* bb_dump_skip trailing white space */
 739                         p = skip_whitespace(++p);
 740                 }
 741
 742                 /* format */
 743                 if (*p != '"') {
 744                         bb_error_msg_and_die("bad format {%s}", fmt);
 745                 }
 746                 for (savep = ++p; *p != '"';) {
 747                         if (*p++ == 0) {
 748                                 bb_error_msg_and_die("bad format {%s}", fmt);
 749                         }
 750                 }
 751                 tfu->fmt = xmalloc(p - savep + 1);
 752                 strncpy(tfu->fmt, savep, p - savep);
 753                 tfu->fmt[p - savep] = '\0';
 754 /*      escape(tfu->fmt); */
 755
 756                 p1 = tfu->fmt;
 757
 758                 /* alphabetic escape sequences have to be done in place */
 759                 for (p2 = p1;; ++p1, ++p2) {
 760                         if (!*p1) {
 761                                 *p2 = *p1;
 762                                 break;
 763                         }
 764                         if (*p1 == '\\') {
 765                                 const char *cs = conv_str + 4;
 766                                 ++p1;
 767                                 *p2 = *p1;
 768                                 do {
 769                                         if (*p1 == cs[2]) {
 770                                                 *p2 = cs[0];
 771                                                 break;
 772                                         }
 773                                         cs += 4;
 774                                 } while (*cs);
 775                         }
 776                 }
 777
 778                 p++;
 779         }
 780 }
 781
 782 /*
 783  * Copyright (c) 1989 The Regents of the University of California.
 784  * All rights reserved.
 785  *
 786  * Redistribution and use in source and binary forms, with or without
 787  * modification, are permitted provided that the following conditions
 788  * are met:
 789  * 1. Redistributions of source code must retain the above copyright
 790  *    notice, this list of conditions and the following disclaimer.
 791  * 2. Redistributions in binary form must reproduce the above copyright
 792  *    notice, this list of conditions and the following disclaimer in the
 793  *    documentation and/or other materials provided with the distribution.
 794  * 3. Neither the name of the University nor the names of its contributors
 795  *    may be used to endorse or promote products derived from this software
 796  *    without specific prior written permission.
 797  *
 798  * THIS SOFTWARE IS PROVIDED BY THE REGENTS AND CONTRIBUTORS ``AS IS'' AND
 799  * ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
 800  * IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE
 801  * ARE DISCLAIMED.  IN NO EVENT SHALL THE REGENTS OR CONTRIBUTORS BE LIABLE
 802  * FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL
 803  * DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS
 804  * OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION)
 805  * HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT
 806  * LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY
 807  * OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF
 808  * SUCH DAMAGE.
 809  */