src/od.c

   1 /* od -- dump in octal (and other formats) the contents of files
   2    Copyright (C) 1992 Free Software Foundation, Inc.
   3
   4    This program is free software; you can redistribute it and/or modify
   5    it under the terms of the GNU General Public License as published by
   6    the Free Software Foundation; either version 2, or (at your option)
   7    any later version.
   8
   9    This program is distributed in the hope that it will be useful,
  10    but WITHOUT ANY WARRANTY; without even the implied warranty of
  11    MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
  12    GNU General Public License for more details.
  13
  14    You should have received a copy of the GNU General Public License
  15    along with this program; if not, write to the Free Software
  16    Foundation, Inc., 675 Mass Ave, Cambridge, MA 02139, USA.  */
  17
  18 /* Written by Jim Meyering.  */
  19
  20 /* AIX requires this to be the first thing in the file.  */
  21 #ifdef __GNUC__
  22 #define alloca __builtin_alloca
  23 #else /* not __GNUC__ */
  24 #if HAVE_ALLOCA_H
  25 #include <alloca.h>
  26 #else /* not HAVE_ALLOCA_H */
  27 #ifdef _AIX
  28  #pragma alloca
  29 #else /* not _AIX */
  30 char *alloca ();
  31 #endif /* not _AIX */
  32 #endif /* not HAVE_ALLOCA_H */
  33 #endif /* not __GNUC__ */
  34
  35 #include <stdio.h>
  36 #include <ctype.h>
  37 #include <assert.h>
  38 #include <getopt.h>
  39 #include <sys/types.h>
  40 #include "system.h"
  41
  42 #if defined(__GNUC__) || defined(STDC_HEADERS)
  43 #include <float.h>
  44 #endif
  45
  46 #ifdef __GNUC__
  47 typedef long double LONG_DOUBLE;
  48 #else
  49 typedef double LONG_DOUBLE;
  50 #endif
  51
  52 #if HAVE_LIMITS_H
  53 #include <limits.h>
  54 #endif
  55 #ifndef SCHAR_MAX
  56 #define SCHAR_MAX 127
  57 #endif
  58 #ifndef SHRT_MAX
  59 #define SHRT_MAX 32767
  60 #endif
  61 #ifndef ULONG_MAX
  62 #define ULONG_MAX ((unsigned long) ~(unsigned long) 0)
  63 #endif
  64
  65 #define STREQ(a,b) (strcmp((a), (b)) == 0)
  66
  67 #ifndef MAX
  68 #define MAX(a, b) ((a) > (b) ? (a) : (b))
  69 #endif
  70
  71 #ifndef MIN
  72 #define MIN(a,b) (((a) < (b)) ? (a) : (b))
  73 #endif
  74
  75 /* The default number of input bytes per output line.  */
  76 #define DEFAULT_BYTES_PER_BLOCK 16
  77
  78 /* The number of decimal digits of precision in a float.  */
  79 #ifndef FLT_DIG
  80 #define FLT_DIG 7
  81 #endif
  82
  83 /* The number of decimal digits of precision in a double.  */
  84 #ifndef DBL_DIG
  85 #define DBL_DIG 15
  86 #endif
  87
  88 /* The number of decimal digits of precision in a long double.  */
  89 #ifndef LDBL_DIG
  90 #define LDBL_DIG DBL_DIG
  91 #endif
  92
  93 char *xmalloc ();
  94 char *xrealloc ();
  95 void error ();
  96
  97 enum size_spec
  98 {
  99   NO_SIZE,
 100   CHAR,
 101   SHORT,
 102   INT,
 103   LONG,
 104   FP_SINGLE,
 105   FP_DOUBLE,
 106   FP_LONG_DOUBLE
 107 };
 108
 109 enum output_format
 110 {
 111   SIGNED_DECIMAL,
 112   UNSIGNED_DECIMAL,
 113   OCTAL,
 114   HEXADECIMAL,
 115   FLOATING_POINT,
 116   NAMED_CHARACTER,
 117   CHARACTER
 118 };
 119
 120 enum strtoul_error
 121 {
 122   UINT_OK, UINT_INVALID, UINT_INVALID_SUFFIX_CHAR, UINT_OVERFLOW
 123 };
 124 typedef enum strtoul_error strtoul_error;
 125
 126 /* Each output format specification (from POSIX `-t spec' or from
 127    old-style options) is represented by one of these structures.  */
 128 struct tspec
 129 {
 130   enum output_format fmt;
 131   enum size_spec size;
 132   void (*print_function) ();
 133   char *fmt_string;
 134 };
 135
 136 /* Convert the number of 8-bit bytes of a binary representation to
 137    the number of characters (digits + sign if the type is signed)
 138    required to represent the same quantity in the specified base/type.
 139    For example, a 32-bit (4-byte) quantity may require a field width
 140    as wide as the following for these types:
 141    11   unsigned octal
 142    11   signed decimal
 143    10   unsigned decimal
 144    8    unsigned hexadecimal  */
 145
 146 static const unsigned int bytes_to_oct_digits[] =
 147 {0, 3, 6, 8, 11, 14, 16, 19, 22, 25, 27, 30, 32, 35, 38, 41, 43};
 148
 149 static const unsigned int bytes_to_signed_dec_digits[] =
 150 {1, 4, 6, 8, 11, 13, 16, 18, 20, 23, 25, 28, 30, 33, 35, 37, 40};
 151
 152 static const unsigned int bytes_to_unsigned_dec_digits[] =
 153 {0, 3, 5, 8, 10, 13, 15, 17, 20, 22, 25, 27, 29, 32, 34, 37, 39};
 154
 155 static const unsigned int bytes_to_hex_digits[] =
 156 {0, 2, 4, 6, 8, 10, 12, 14, 16, 18, 20, 22, 24, 26, 28, 30, 32};
 157
 158 /* Convert enum size_spec to the size of the named type.  */
 159 static const int width_bytes[] =
 160 {
 161   -1,
 162   sizeof (char),
 163   sizeof (short int),
 164   sizeof (int),
 165   sizeof (long int),
 166   sizeof (float),
 167   sizeof (double),
 168   sizeof (LONG_DOUBLE)
 169 };
 170
 171 /* Names for some non-printing characters.  */
 172 static const char *const charname[33] =
 173 {
 174   "nul", "soh", "stx", "etx", "eot", "enq", "ack", "bel",
 175   "bs", "ht", "nl", "vt", "ff", "cr", "so", "si",
 176   "dle", "dc1", "dc2", "dc3", "dc4", "nak", "syn", "etb",
 177   "can", "em", "sub", "esc", "fs", "gs", "rs", "us",
 178   "sp"
 179 };
 180
 181 /* A printf control string for printing a file offset.  */
 182 static const char *output_address_fmt_string;
 183
 184 /* FIXME: make this the number of octal digits in an unsigned long.  */
 185 #define MAX_ADDRESS_LENGTH 13
 186 static char address_fmt_buffer[MAX_ADDRESS_LENGTH + 1];
 187 static char address_pad[MAX_ADDRESS_LENGTH + 1];
 188
 189 static unsigned long int string_min;
 190 static unsigned long int flag_dump_strings;
 191
 192 /* The number of input bytes to skip before formatting and writing.  */
 193 static unsigned long int n_bytes_to_skip = 0;
 194
 195 /* When non-zero, MAX_BYTES_TO_FORMAT is the maximum number of bytes
 196    to be read and formatted.  Otherwise all input is formatted.  */
 197 static int limit_bytes_to_format = 0;
 198
 199 /* The maximum number of bytes that will be formatted.  This
 200    value is used only when LIMIT_BYTES_TO_FORMAT is non-zero.  */
 201 static unsigned long int max_bytes_to_format;
 202
 203 /* When non-zero and two or more consecutive blocks are equal, format
 204    only the first block and output an asterisk alone on the following
 205    line to indicate that identical blocks have been elided.  */
 206 static int abbreviate_duplicate_blocks = 1;
 207
 208 /* An array of specs describing how to format each input block.  */
 209 static struct tspec *spec;
 210
 211 /* The number of format specs.  */
 212 static unsigned int n_specs;
 213
 214 /* The allocated length of SPEC.  */
 215 static unsigned int n_specs_allocated;
 216
 217 /* The number of input bytes formatted per output line.  It must be
 218    a multiple of the least common multiple of the sizes associated with
 219    the specified output types.  It should be as large as possible, but
 220    no larger than 16 -- unless specified with the -w option.  */
 221 static unsigned int bytes_per_block;
 222
 223 /* Human-readable representation of *file_list (for error messages).
 224    It differs from *file_list only when *file_list is "-".  */
 225 static char const *input_filename;
 226
 227 /* A NULL-terminated list of the file-arguments from the command line.
 228    If no file-arguments were specified, this variable is initialized
 229    to { "-", NULL }.  */
 230 static char const *const *file_list;
 231
 232 /* The input stream associated with the current file.  */
 233 static FILE *in_stream;
 234
 235 #define LONGEST_INTEGRAL_TYPE long int
 236
 237 #define MAX_INTEGRAL_TYPE_SIZE sizeof(LONGEST_INTEGRAL_TYPE)
 238 static enum size_spec integral_type_size[MAX_INTEGRAL_TYPE_SIZE + 1];
 239
 240 #define MAX_FP_TYPE_SIZE sizeof(LONG_DOUBLE)
 241 static enum size_spec fp_type_size[MAX_FP_TYPE_SIZE + 1];
 242
 243 static struct option long_options[] =
 244 {
 245   /* POSIX options.  */
 246   {"skip-bytes", 1, NULL, 'j'},
 247   {"address-radix", 1, NULL, 'A'},
 248   {"read-bytes", 1, NULL, 'N'},
 249   {"format", 1, NULL, 't'},
 250   {"output-duplicates", 0, NULL, 'v'},
 251
 252   /* non-POSIX options.  */
 253   {"strings", 2, NULL, 's'},
 254   {"width", 2, NULL, 'w'},
 255   {NULL, 0, NULL, 0}
 256 };
 257
 258 /* The name this program was run with.  */
 259 char *program_name;
 260
 261 static void
 262 usage ()
 263 {
 264   fprintf (stderr, "\
 265 Usage: %s [-abcdfhiloxv] [-s[bytes]] [-w[bytes]] [-A radix] [-j bytes]\n\
 266        [-N bytes] [-t type] [--skip-bytes=bytes] [--address-radix=radix]\n\
 267        [--read-bytes=bytes] [--format=type] [--output-duplicates]\n\
 268        [--strings[=bytes]] [--width[=bytes]] [file...]\n",
 269            program_name);
 270   exit (1);
 271 }
 272
 273 /* Compute the greatest common denominator of U and V
 274    using Euclid's algorithm.  */
 275
 276 static unsigned int
 277 gcd (u, v)
 278      unsigned int u;
 279      unsigned int v;
 280 {
 281   unsigned int t;
 282   while (v != 0)
 283     {
 284       t = u % v;
 285       u = v;
 286       v = t;
 287     }
 288   return u;
 289 }
 290
 291 /* Compute the least common multiple of U and V.  */
 292
 293 static unsigned int
 294 lcm (u, v)
 295      unsigned int u;
 296      unsigned int v;
 297 {
 298   unsigned int t = gcd (u, v);
 299   if (t == 0)
 300     return 0;
 301   return u * v / t;
 302 }
 303
 304 static strtoul_error
 305 my_strtoul (s, base, val, allow_bkm_suffix)
 306      const char *s;
 307      int base;
 308      long unsigned int *val;
 309      int allow_bkm_suffix;
 310 {
 311   char *p;
 312   unsigned long int tmp;
 313
 314   assert (0 <= base && base <= 36);
 315
 316   tmp = strtoul (s, &p, base);
 317   if (errno != 0)
 318     return UINT_OVERFLOW;
 319   if (p == s)
 320     return UINT_INVALID;
 321   if (!allow_bkm_suffix)
 322     {
 323       if (*p == '\0')
 324         {
 325           *val = tmp;
 326           return UINT_OK;
 327         }
 328       else
 329         return UINT_INVALID_SUFFIX_CHAR;
 330     }
 331
 332   switch (*p)
 333     {
 334     case '\0':
 335       break;
 336
 337 #define BKM_SCALE(x,scale_factor)                       \
 338       do                                                \
 339         {                                               \
 340           if (x > (double) ULONG_MAX / scale_factor)    \
 341             return UINT_OVERFLOW;                       \
 342           x *= scale_factor;                            \
 343         }                                               \
 344       while (0)
 345
 346     case 'b':
 347       BKM_SCALE (tmp, 512);
 348       break;
 349
 350     case 'k':
 351       BKM_SCALE (tmp, 1024);
 352       break;
 353
 354     case 'm':
 355       BKM_SCALE (tmp, 1024 * 1024);
 356       break;
 357
 358     default:
 359       return UINT_INVALID_SUFFIX_CHAR;
 360       break;
 361     }
 362
 363   *val = tmp;
 364   return UINT_OK;
 365 }
 366
 367 static void
 368 uint_fatal_error (str, argument_type_string, err)
 369      const char *str;
 370      const char *argument_type_string;
 371      strtoul_error err;
 372 {
 373   switch (err)
 374     {
 375     case UINT_OK:
 376       abort ();
 377
 378     case UINT_INVALID:
 379       error (2, 0, "invalid %s `%s'", argument_type_string, str);
 380       break;
 381
 382     case UINT_INVALID_SUFFIX_CHAR:
 383       error (2, 0, "invalid character following %s `%s'",
 384              argument_type_string, str);
 385       break;
 386
 387     case UINT_OVERFLOW:
 388       error (2, 0, "%s `%s' larger than maximum unsigned long",
 389              argument_type_string, str);
 390       break;
 391     }
 392 }
 393
 394 static void
 395 print_s_char (n_bytes, block, fmt_string)
 396      long unsigned int n_bytes;
 397      const char *block;
 398      const char *fmt_string;
 399 {
 400   int i, err;
 401   err = 0;
 402   for (i = n_bytes; i > 0; i--)
 403     {
 404       int tmp = (unsigned) *(unsigned char *) block;
 405       if (tmp > SCHAR_MAX)
 406         tmp = (SCHAR_MAX - tmp);
 407       assert (tmp <= SCHAR_MAX);
 408       err |= (printf (fmt_string, tmp, (i == 1 ? '\n' : ' ')) == EOF);
 409       block += sizeof (unsigned char);
 410     }
 411   if (err)
 412     error (2, errno, "standard output");
 413 }
 414
 415 static void
 416 print_char (n_bytes, block, fmt_string)
 417      long unsigned int n_bytes;
 418      const char *block;
 419      const char *fmt_string;
 420 {
 421   int i, err;
 422   err = 0;
 423   for (i = n_bytes; i > 0; i--)
 424     {
 425       unsigned int tmp = *(unsigned char *) block;
 426       err |= (printf (fmt_string, tmp, (i == 1 ? '\n' : ' ')) == EOF);
 427       block += sizeof (unsigned char);
 428     }
 429   if (err)
 430     error (2, errno, "standard output");
 431 }
 432
 433 static void
 434 print_s_short (n_bytes, block, fmt_string)
 435      long unsigned int n_bytes;
 436      const char *block;
 437      const char *fmt_string;
 438 {
 439   int i, err;
 440   err = 0;
 441   for (i = n_bytes / sizeof (unsigned short); i > 0; i--)
 442     {
 443       int tmp = (unsigned) *(unsigned short *) block;
 444       if (tmp > SHRT_MAX)
 445         tmp = (SHRT_MAX - tmp);
 446       assert (tmp <= SHRT_MAX);
 447       err |= (printf (fmt_string, tmp, (i == 1 ? '\n' : ' ')) == EOF);
 448       block += sizeof (unsigned short);
 449     }
 450   if (err)
 451     error (2, errno, "standard output");
 452 }
 453
 454 static void
 455 print_short (n_bytes, block, fmt_string)
 456      long unsigned int n_bytes;
 457      const char *block;
 458      const char *fmt_string;
 459 {
 460   int i, err;
 461   err = 0;
 462   for (i = n_bytes / sizeof (unsigned short); i > 0; i--)
 463     {
 464       unsigned int tmp = *(unsigned short *) block;
 465       err |= (printf (fmt_string, tmp, (i == 1 ? '\n' : ' ')) == EOF);
 466       block += sizeof (unsigned short);
 467     }
 468   if (err)
 469     error (2, errno, "standard output");
 470 }
 471
 472 static void
 473 print_int (n_bytes, block, fmt_string)
 474      long unsigned int n_bytes;
 475      const char *block;
 476      const char *fmt_string;
 477 {
 478   int i, err;
 479   err = 0;
 480   for (i = n_bytes / sizeof (unsigned int); i > 0; i--)
 481     {
 482       unsigned int tmp = *(unsigned int *) block;
 483       err |= (printf (fmt_string, tmp, (i == 1 ? '\n' : ' ')) == EOF);
 484       block += sizeof (unsigned int);
 485     }
 486   if (err)
 487     error (2, errno, "standard output");
 488 }
 489
 490 static void
 491 print_long (n_bytes, block, fmt_string)
 492      long unsigned int n_bytes;
 493      const char *block;
 494      const char *fmt_string;
 495 {
 496   int i, err;
 497   err = 0;
 498   for (i = n_bytes / sizeof (unsigned long); i > 0; i--)
 499     {
 500       unsigned long tmp = *(unsigned long *) block;
 501       err |= (printf (fmt_string, tmp, (i == 1 ? '\n' : ' ')) == EOF);
 502       block += sizeof (unsigned long);
 503     }
 504   if (err)
 505     error (2, errno, "standard output");
 506 }
 507
 508 static void
 509 print_float (n_bytes, block, fmt_string)
 510      long unsigned int n_bytes;
 511      const char *block;
 512      const char *fmt_string;
 513 {
 514   int i, err;
 515   err = 0;
 516   for (i = n_bytes / sizeof (float); i > 0; i--)
 517     {
 518       float tmp = *(float *) block;
 519       err |= (printf (fmt_string, tmp, (i == 1 ? '\n' : ' ')) == EOF);
 520       block += sizeof (float);
 521     }
 522   if (err)
 523     error (2, errno, "standard output");
 524 }
 525
 526 static void
 527 print_double (n_bytes, block, fmt_string)
 528      long unsigned int n_bytes;
 529      const char *block;
 530      const char *fmt_string;
 531 {
 532   int i, err;
 533   err = 0;
 534   for (i = n_bytes / sizeof (double); i > 0; i--)
 535     {
 536       double tmp = *(double *) block;
 537       err |= (printf (fmt_string, tmp, (i == 1 ? '\n' : ' ')) == EOF);
 538       block += sizeof (double);
 539     }
 540   if (err)
 541     error (2, errno, "standard output");
 542 }
 543
 544 #ifdef __GNUC__
 545 static void
 546 print_long_double (n_bytes, block, fmt_string)
 547      long unsigned int n_bytes;
 548      const char *block;
 549      const char *fmt_string;
 550 {
 551   int i, err;
 552   err = 0;
 553   for (i = n_bytes / sizeof (LONG_DOUBLE); i > 0; i--)
 554     {
 555       LONG_DOUBLE tmp = *(LONG_DOUBLE *) block;
 556       err |= (printf (fmt_string, tmp, (i == 1 ? '\n' : ' ')) == EOF);
 557       block += sizeof (LONG_DOUBLE);
 558     }
 559   if (err)
 560     error (2, errno, "standard output");
 561 }
 562
 563 #endif
 564
 565 static void
 566 print_named_ascii (n_bytes, block, unused_fmt_string)
 567      long unsigned int n_bytes;
 568      const char *block;
 569      const char *unused_fmt_string;
 570 {
 571   int i;
 572   for (i = n_bytes; i > 0; i--)
 573     {
 574       unsigned int c = *(unsigned char *) block;
 575       unsigned int masked_c = (0x7f & c);
 576       const char *s;
 577       char buf[5];
 578
 579       if (masked_c == 127)
 580         s = "del";
 581       else if (masked_c <= 040)
 582         s = charname[masked_c];
 583       else
 584         {
 585           sprintf (buf, "  %c", masked_c);
 586           s = buf;
 587         }
 588
 589       if (printf ("%3s%c", s, (i == 1 ? '\n' : ' ')) == EOF)
 590         error (2, errno, "standard output");
 591       block += sizeof (unsigned char);
 592     }
 593 }
 594
 595 static void
 596 print_ascii (n_bytes, block, unused_fmt_string)
 597      long unsigned int n_bytes;
 598      const char *block;
 599      const char *unused_fmt_string;
 600 {
 601   int i;
 602   for (i = n_bytes; i > 0; i--)
 603     {
 604       unsigned int c = *(unsigned char *) block;
 605       const char *s;
 606       char buf[5];
 607
 608       switch (c)
 609         {
 610         case '\0':
 611           s = " \\0";
 612           break;
 613
 614         case '\007':
 615           s = " \\a";
 616           break;
 617
 618         case '\b':
 619           s = " \\b";
 620           break;
 621
 622         case '\f':
 623           s = " \\f";
 624           break;
 625
 626         case '\n':
 627           s = " \\n";
 628           break;
 629
 630         case '\r':
 631           s = " \\r";
 632           break;
 633
 634         case '\t':
 635           s = " \\t";
 636           break;
 637
 638         case '\v':
 639           s = " \\v";
 640           break;
 641
 642         default:
 643           sprintf (buf, (isprint (c) ? "  %c" : "%03o"), c);
 644           s = (const char *) buf;
 645         }
 646
 647       if (printf ("%3s%c", s, (i == 1 ? '\n' : ' ')) == EOF)
 648         error (2, errno, "standard output");
 649       block += sizeof (unsigned char);
 650     }
 651 }
 652
 653 /* Convert a null-terminated (possibly zero-length) string S to an
 654    unsigned long integer value.  If S points to a non-digit set *P to S,
 655    *VAL to 0, and return 0.  Otherwise, accumulate the integer value of
 656    the string of digits.  If the string of digits represents a value
 657    larger than ULONG_MAX, don't modify *VAL or *P and return non-zero.
 658    Otherwise, advance *P to the first non-digit after S, set *VAL to
 659    the result of the conversion and return zero.  */
 660
 661 static int
 662 simple_strtoul (s, p, val)
 663      const char *s;
 664      const char **p;
 665      long unsigned int *val;
 666 {
 667   unsigned long int sum;
 668
 669   sum = 0;
 670   while (isdigit (*s))
 671     {
 672       unsigned int c = *s++ - '0';
 673       if (sum > (ULONG_MAX - c) / 10)
 674         return 1;
 675       sum = sum * 10 + c;
 676     }
 677   *p = s;
 678   *val = sum;
 679   return 0;
 680 }
 681
 682 /* If S points to a single valid POSIX-style od format string, put a
 683    description of that format in *TSPEC, make *NEXT point at the character
 684    following the just-decoded format (if *NEXT is non-NULL), and return
 685    zero.  If S is not valid, don't modify *NEXT or *TSPEC and return
 686    non-zero.  For example, if S were "d4afL" *NEXT would be set to "afL"
 687    and *TSPEC would be
 688      {
 689        fmt = SIGNED_DECIMAL;
 690        size = INT or LONG; (whichever integral_type_size[4] resolves to)
 691        print_function = print_int; (assuming size == INT)
 692        fmt_string = "%011d%c";
 693       }
 694 */
 695
 696 static int
 697 decode_one_format (s, next, tspec)
 698      const char *s;
 699      const char **next;
 700      struct tspec *tspec;
 701 {
 702   enum size_spec size_spec;
 703   unsigned long int size;
 704   enum output_format fmt;
 705   const char *pre_fmt_string;
 706   char *fmt_string;
 707   void (*print_function) ();
 708   const char *p;
 709   unsigned int c;
 710
 711   assert (tspec != NULL);
 712
 713   switch (*s)
 714     {
 715     case 'd':
 716     case 'o':
 717     case 'u':
 718     case 'x':
 719       c = *s;
 720       ++s;
 721       switch (*s)
 722         {
 723         case 'C':
 724           ++s;
 725           size = sizeof (char);
 726           break;
 727
 728         case 'S':
 729           ++s;
 730           size = sizeof (short);
 731           break;
 732
 733         case 'I':
 734           ++s;
 735           size = sizeof (int);
 736           break;
 737
 738         case 'L':
 739           ++s;
 740           size = sizeof (long int);
 741           break;
 742
 743         default:
 744           if (simple_strtoul (s, &p, &size) != 0)
 745             return 1;
 746           if (p == s)
 747             size = sizeof (int);
 748           else
 749             {
 750               if (size > MAX_INTEGRAL_TYPE_SIZE
 751                   || integral_type_size[size] == NO_SIZE)
 752                 return 1;
 753               s = p;
 754             }
 755           break;
 756         }
 757
 758 #define FMT_BYTES_ALLOCATED 9
 759       fmt_string = xmalloc (FMT_BYTES_ALLOCATED);
 760
 761       size_spec = integral_type_size[size];
 762
 763       switch (c)
 764         {
 765         case 'd':
 766           fmt = SIGNED_DECIMAL;
 767           sprintf (fmt_string, "%%0%u%sd%%c",
 768                    bytes_to_signed_dec_digits[size],
 769                    (size_spec == LONG ? "l" : ""));
 770           break;
 771
 772         case 'o':
 773           fmt = OCTAL;
 774           sprintf (fmt_string, "%%0%u%so%%c",
 775                    bytes_to_oct_digits[size],
 776                    (size_spec == LONG ? "l" : ""));
 777           break;
 778
 779         case 'u':
 780           fmt = UNSIGNED_DECIMAL;
 781           sprintf (fmt_string, "%%0%u%su%%c",
 782                    bytes_to_unsigned_dec_digits[size],
 783                    (size_spec == LONG ? "l" : ""));
 784           break;
 785
 786         case 'x':
 787           fmt = HEXADECIMAL;
 788           sprintf (fmt_string, "%%0%u%sx%%c",
 789                    bytes_to_hex_digits[size],
 790                    (size_spec == LONG ? "l" : ""));
 791           break;
 792
 793         default:
 794           abort ();
 795         }
 796
 797       assert (strlen (fmt_string) < FMT_BYTES_ALLOCATED);
 798
 799       switch (size_spec)
 800         {
 801         case CHAR:
 802           print_function = (fmt == SIGNED_DECIMAL
 803                             ? print_s_char
 804                             : print_char);
 805           break;
 806
 807         case SHORT:
 808           print_function = (fmt == SIGNED_DECIMAL
 809                             ? print_s_short
 810                             : print_short);;
 811           break;
 812
 813         case INT:
 814           print_function = print_int;
 815           break;
 816
 817         case LONG:
 818           print_function = print_long;
 819           break;
 820
 821         default:
 822           abort ();
 823         }
 824       break;
 825
 826     case 'f':
 827       fmt = FLOATING_POINT;
 828       ++s;
 829       switch (*s)
 830         {
 831         case 'F':
 832           ++s;
 833           size = sizeof (float);
 834           break;
 835
 836         case 'D':
 837           ++s;
 838           size = sizeof (double);
 839           break;
 840
 841         case 'L':
 842           ++s;
 843           size = sizeof (LONG_DOUBLE);
 844           break;
 845
 846         default:
 847           if (simple_strtoul (s, &p, &size) != 0)
 848             return 1;
 849           if (p == s)
 850             size = sizeof (double);
 851           else
 852             {
 853               if (size > MAX_FP_TYPE_SIZE
 854                   || fp_type_size[size] == NO_SIZE)
 855                 return 1;
 856               s = p;
 857             }
 858           break;
 859         }
 860       size_spec = fp_type_size[size];
 861
 862       switch (size_spec)
 863         {
 864         case FP_SINGLE:
 865           print_function = print_float;
 866           pre_fmt_string = "%%%d.%d#e%%c";
 867           fmt_string = xmalloc (strlen (pre_fmt_string));
 868           sprintf (fmt_string, pre_fmt_string,
 869                    FLT_DIG + 8, FLT_DIG);
 870           break;
 871
 872         case FP_DOUBLE:
 873           print_function = print_double;
 874           pre_fmt_string = "%%%d.%d#e%%c";
 875           fmt_string = xmalloc (strlen (pre_fmt_string));
 876           sprintf (fmt_string, pre_fmt_string,
 877                    DBL_DIG + 8, DBL_DIG);
 878           break;
 879
 880 #ifdef __GNUC__
 881         case FP_LONG_DOUBLE:
 882           print_function = print_long_double;
 883           pre_fmt_string = "%%%d.%d#le%%c";
 884           fmt_string = xmalloc (strlen (pre_fmt_string));
 885           sprintf (fmt_string, pre_fmt_string,
 886                    LDBL_DIG + 8, LDBL_DIG);
 887           break;
 888 #endif
 889
 890         default:
 891           abort ();
 892         }
 893       break;
 894
 895     case 'a':
 896       ++s;
 897       fmt = NAMED_CHARACTER;
 898       size_spec = CHAR;
 899       fmt_string = NULL;
 900       print_function = print_named_ascii;
 901       break;
 902
 903     case 'c':
 904       ++s;
 905       fmt = CHARACTER;
 906       size_spec = CHAR;
 907       fmt_string = NULL;
 908       print_function = print_ascii;
 909       break;
 910
 911     default:
 912       return 1;
 913     }
 914
 915   tspec->size = size_spec;
 916   tspec->fmt = fmt;
 917   tspec->print_function = print_function;
 918   tspec->fmt_string = fmt_string;
 919
 920   if (next != NULL)
 921     *next = s;
 922
 923   return 0;
 924 }
 925
 926 /* Decode the POSIX-style od format string S.  Append the decoded
 927    representation to the global array SPEC, reallocating SPEC if
 928    necessary.  Return zero if S is valid, non-zero otherwise.  */
 929
 930 static int
 931 decode_format_string (s)
 932      const char *s;
 933 {
 934   assert (s != NULL);
 935
 936   while (*s != '\0')
 937     {
 938       struct tspec tspec;
 939       const char *next;
 940
 941       if (decode_one_format (s, &next, &tspec))
 942         return 1;
 943
 944       assert (s != next);
 945       s = next;
 946
 947       if (n_specs >= n_specs_allocated)
 948         {
 949           n_specs_allocated = 1 + (3 * n_specs_allocated) / 2;
 950           spec = (struct tspec *) xrealloc (spec, (n_specs_allocated
 951                                                    * sizeof (struct tspec)));
 952         }
 953
 954       bcopy ((char *) &tspec, (char *) &spec[n_specs], sizeof (struct tspec));
 955       ++n_specs;
 956     }
 957
 958   return 0;
 959 }
 960
 961 /* Given a list of one or more input filenames FILE_LIST, set the global
 962    file pointer IN_STREAM to position N_SKIP in the concatenation of
 963    those files.  If any file operation fails or if there are fewer than
 964    N_SKIP bytes in the combined input, give an error message and exit.
 965    When possible, use seek- rather than read operations to advance
 966    IN_STREAM.  A file name of "-" is interpreted as standard input.  */
 967
 968 static void
 969 skip (n_skip)
 970      long unsigned int n_skip;
 971 {
 972   for ( /*empty */ ; *file_list != NULL; ++file_list)
 973     {
 974       struct stat file_stats;
 975       int j;
 976
 977       if (STREQ (*file_list, "-"))
 978         {
 979           input_filename = "standard input";
 980           in_stream = stdin;
 981         }
 982       else
 983         {
 984           input_filename = *file_list;
 985           in_stream = fopen (input_filename, "r");
 986           if (in_stream == NULL)
 987             error (2, errno, "%s", input_filename);
 988         }
 989
 990       if (n_skip == 0)
 991         break;
 992
 993       /* First try using fseek.  For large offsets, all this work is
 994          worthwhile.  If the offset is below some threshold it may be
 995          more efficient to move the pointer by reading.  There are two
 996          issues when trying to use fseek:
 997            - the file must be seekable.
 998            - before seeking to the specified position, make sure
 999              that the new position is in the current file.
1000              Try to do that by getting file's size using stat().
1001              But that will work only for regular files and dirs.  */
1002
1003       if (fstat (fileno (in_stream), &file_stats))
1004         error (2, errno, "%s", input_filename);
1005
1006       /* The st_size field is valid only for regular files and
1007          directories.  FIXME: is the preceding true?
1008          If the number of bytes left to skip is at least as large as
1009          the size of the current file, we can decrement
1010          n_skip and go on to the next file.  */
1011       if (S_ISREG (file_stats.st_mode) || S_ISDIR (file_stats.st_mode))
1012         {
1013           if (n_skip >= file_stats.st_size)
1014             {
1015               n_skip -= file_stats.st_size;
1016               if (in_stream != stdin)
1017                 {
1018                   if (fclose (in_stream))
1019                     error (2, errno, "%s", input_filename);
1020                 }
1021               continue;
1022             }
1023           else
1024             {
1025               if (fseek (in_stream, n_skip, SEEK_SET) == 0)
1026                 {
1027                   n_skip = 0;
1028                   break;
1029                 }
1030             }
1031         }
1032
1033       /* fseek didn't work or wasn't attempted; do it the slow way.  */
1034
1035       for (j = n_skip / BUFSIZ; j >= 0; j--)
1036         {
1037           char buf[BUFSIZ];
1038           size_t n_bytes_to_read = (j > 0
1039                                     ? BUFSIZ
1040                                     : n_skip % BUFSIZ);
1041           size_t n_bytes_read;
1042           n_bytes_read = fread (buf, 1, n_bytes_to_read, in_stream);
1043           n_skip -= n_bytes_read;
1044           if (n_bytes_read != n_bytes_to_read)
1045             {
1046               if (ferror (in_stream))
1047                 error (2, errno, "%s", input_filename);
1048               else
1049                 break;
1050             }
1051         }
1052
1053       if (n_skip == 0)
1054         break;
1055     }
1056
1057   if (n_skip != 0)
1058     error (2, 0, "cannot skip past end of combined input");
1059 }
1060
1061 static const char *
1062 format_address (address)
1063      long unsigned int address;
1064 {
1065   const char *address_string;
1066
1067   if (output_address_fmt_string == NULL)
1068     address_string = "";
1069   else
1070     {
1071       sprintf (address_fmt_buffer, output_address_fmt_string, address);
1072       address_string = address_fmt_buffer;
1073     }
1074   return address_string;
1075 }
1076
1077 /* Write N_BYTES bytes from CURR_BLOCK to standard output once for each
1078    of the N_SPEC format specs.  CURRENT_OFFSET is the byte address of
1079    CURR_BLOCK in the concatenation of input files, and it is printed
1080    (optionally) only before the output line associated with the first
1081    format spec.  When duplicate blocks are being abbreviated, the output
1082    for a sequence of identical input blocks is the output for the first
1083    block followed by an asterisk alone on a line.  It is valid to compare
1084    the blocks PREV_BLOCK and CURR_BLOCK only when N_BYTES == BYTES_PER_BLOCK.
1085    That condition may be false only for the last input block -- and then
1086    only when it has not been padded to length BYTES_PER_BLOCK.  */
1087
1088 static void
1089 write_block (current_offset, n_bytes, prev_block, curr_block)
1090      long unsigned int current_offset;
1091      long unsigned int n_bytes;
1092      const char *prev_block;
1093      const char *curr_block;
1094 {
1095   static int first = 1;
1096   static int prev_pair_equal = 0;
1097
1098 #define EQUAL_BLOCKS(b1, b2) (bcmp ((b1), (b2), bytes_per_block) == 0)
1099
1100   if (abbreviate_duplicate_blocks
1101       && !first && n_bytes == bytes_per_block
1102       && EQUAL_BLOCKS (prev_block, curr_block))
1103     {
1104       if (prev_pair_equal)
1105         {
1106           /* The two preceding blocks were equal, and the current
1107              block is the same as the last one, so print nothing.  */
1108         }
1109       else
1110         {
1111           printf ("*\n");
1112           prev_pair_equal = 1;
1113         }
1114     }
1115   else
1116     {
1117       int i;
1118
1119       prev_pair_equal = 0;
1120       for (i = 0; i < n_specs; i++)
1121         {
1122           if (printf ("%s ", (i == 0
1123                               ? format_address (current_offset)
1124                               : address_pad))
1125               == EOF)
1126             error (2, errno, "standard output");
1127           (*spec[i].print_function) (n_bytes, curr_block, spec[i].fmt_string);
1128         }
1129     }
1130   first = 0;
1131 }
1132
1133 /* Read and return a single byte from the concatenation of the input
1134    files named in the global array FILE_LIST.  On the first call to this
1135    function, the global variable IN_STREAM is expected to be an open
1136    stream associated with the input file *FILE_LIST.  If IN_STREAM is
1137    at end-of-file, close it and update the global variables IN_STREAM,
1138    FILE_LIST, and INPUT_FILENAME so they correspond to the next file in
1139    the list.  Then try to read a byte from the newly opened file.
1140    Repeat if necessary until *FILE_LIST is NULL.  Upon any read-, open-,
1141    or close error give a message and exit. When EOF is reached for the
1142    last file in FILE_LIST, return EOF.  Any subsequent calls return EOF.  */
1143
1144 static int
1145 read_char ()
1146 {
1147   if (*file_list == NULL)
1148     return EOF;
1149
1150   while (1)
1151     {
1152       int c;
1153
1154       c = fgetc (in_stream);
1155
1156       if (c != EOF)
1157         return c;
1158
1159       if (errno != 0)
1160         error (2, errno, "%s", input_filename);
1161
1162       if (in_stream != stdin)
1163         if (fclose (in_stream) == EOF)
1164           error (2, errno, "%s", input_filename);
1165
1166       ++file_list;
1167       if (*file_list == NULL)
1168         return EOF;
1169
1170       if (STREQ (*file_list, "-"))
1171         {
1172           input_filename = "standard input";
1173           in_stream = stdin;
1174         }
1175       else
1176         {
1177           input_filename = *file_list;
1178           in_stream = fopen (input_filename, "r");
1179           if (in_stream == NULL)
1180             error (2, errno, "%s", input_filename);
1181         }
1182     }
1183 }
1184
1185 /* Read N bytes into BLOCK from the concatenation of the input files
1186    named in the global array FILE_LIST.  On the first call to this
1187    function, the global variable IN_STREAM is expected to be an open
1188    stream associated with the input file *FILE_LIST.  On subsequent
1189    calls, if *FILE_LIST is NULL, don't modify BLOCK and return zero.
1190    If all N bytes cannot be read from IN_STREAM, close IN_STREAM and
1191    update the global variables IN_STREAM, FILE_LIST, and INPUT_FILENAME.
1192    Then try to read the remaining bytes from the newly opened file.
1193    Repeat if necessary until *FILE_LIST is NULL.  Upon any read-, open-,
1194    or close error give a message and exit.  Otherwise, return the number
1195    of bytes read.  */
1196
1197 static unsigned long int
1198 read_block (n, block)
1199      size_t n;
1200      char *block;
1201 {
1202   unsigned long int n_bytes_in_buffer;
1203
1204   assert (n > 0 && n <= bytes_per_block);
1205   if (n == 0)
1206     return 0;
1207
1208   n_bytes_in_buffer = 0;
1209
1210   if (*file_list == NULL)
1211     return 0;                   /* EOF.  */
1212
1213   while (1)
1214     {
1215       size_t n_needed;
1216       size_t n_read;
1217
1218       n_needed = n - n_bytes_in_buffer;
1219       n_read = fread (block + n_bytes_in_buffer, 1, n_needed, in_stream);
1220
1221       if (ferror (in_stream))
1222         error (2, errno, "%s", input_filename);
1223
1224       if (n_read == n_needed)
1225         return n;
1226
1227       n_bytes_in_buffer += n_read;
1228
1229       if (in_stream != stdin)
1230         if (fclose (in_stream) == EOF)
1231           error (2, errno, "%s", input_filename);
1232
1233       ++file_list;
1234       if (*file_list == NULL)
1235         return n_bytes_in_buffer;
1236
1237       if (STREQ (*file_list, "-"))
1238         {
1239           input_filename = "standard input";
1240           in_stream = stdin;
1241         }
1242       else
1243         {
1244           input_filename = *file_list;
1245           in_stream = fopen (input_filename, "r");
1246           if (in_stream == NULL)
1247             error (2, errno, "%s", input_filename);
1248         }
1249     }
1250 }
1251
1252 /* Return the least common multiple of the sizes associated
1253    with the format specs.  */
1254
1255 static int
1256 get_lcm ()
1257 {
1258   int i;
1259   int l_c_m = 1;
1260
1261   for (i = 0; i < n_specs; i++)
1262     l_c_m = lcm (l_c_m, width_bytes[(int) spec[i].size]);
1263   return l_c_m;
1264 }
1265
1266 /* Read chunks of size BYTES_PER_BLOCK from the input files, write the
1267    formatted block to standard output, and repeat until the specified
1268    maximum number of bytes has been read or until all input has been
1269    processed.  If the last block read is smaller than BYTES_PER_BLOCK
1270    and its size is not a multiple of the size associated with a format
1271    spec, extend the input block with zero bytes until its length is a
1272    multiple of all format spec sizes.  Write the final block.  Finally,
1273    write on a line by itself the offset of the byte after the last byte
1274    read.  */
1275
1276 static void
1277 dump ()
1278 {
1279   char *block[2];
1280   unsigned long int current_offset;
1281   int idx = 0;
1282   size_t n_bytes_read;
1283
1284   block[0] = (char *) alloca (bytes_per_block);
1285   block[1] = (char *) alloca (bytes_per_block);
1286
1287   current_offset = n_bytes_to_skip;
1288
1289   if (limit_bytes_to_format)
1290     {
1291       size_t end_offset = n_bytes_to_skip + max_bytes_to_format;
1292
1293       n_bytes_read = 0;
1294       while (current_offset < end_offset)
1295         {
1296           size_t n_needed;
1297           n_needed = MIN (end_offset - current_offset, bytes_per_block);
1298           n_bytes_read = read_block (n_needed, block[idx]);
1299           if (n_bytes_read < bytes_per_block)
1300             break;
1301           assert (n_bytes_read == bytes_per_block);
1302           write_block (current_offset, n_bytes_read,
1303                        block[!idx], block[idx]);
1304           current_offset += n_bytes_read;
1305           idx = !idx;
1306         }
1307     }
1308   else
1309     {
1310       while (1)
1311         {
1312           n_bytes_read = read_block (bytes_per_block, block[idx]);
1313           if (n_bytes_read < bytes_per_block)
1314             break;
1315           assert (n_bytes_read == bytes_per_block);
1316           write_block (current_offset, n_bytes_read,
1317                        block[!idx], block[idx]);
1318           current_offset += n_bytes_read;
1319           idx = !idx;
1320         }
1321     }
1322
1323   if (n_bytes_read > 0)
1324     {
1325       int l_c_m;
1326       size_t bytes_to_write;
1327
1328       l_c_m = get_lcm ();
1329
1330       /* Make bytes_to_write the smallest multiple of l_c_m that
1331          is at least as large as n_bytes_read.  */
1332       bytes_to_write = l_c_m * (int) ((n_bytes_read + l_c_m - 1) / l_c_m);
1333
1334       bzero (block[idx] + n_bytes_read, bytes_to_write - n_bytes_read);
1335       write_block (current_offset, bytes_to_write,
1336                    block[!idx], block[idx]);
1337       current_offset += n_bytes_read;
1338     }
1339
1340   if (output_address_fmt_string != NULL)
1341     {
1342       if (printf ("%s\n", format_address (current_offset)) == EOF)
1343         error (2, errno, "standard output");
1344     }
1345 }
1346
1347 /* STRINGS mode.  Find each "string constant" in the file.
1348    A string constant is a run of at least `string_min' ASCII graphic
1349    (or formatting) characters terminated by a null.  Based on a
1350    function written by Richard Stallman for a pre-POSIX
1351    version of od.  */
1352
1353 static void
1354 dump_strings ()
1355 {
1356   int bufsize = MAX (100, string_min);
1357   char *buf = xmalloc (bufsize);
1358   unsigned long address = n_bytes_to_skip;
1359
1360   while (1)
1361     {
1362       int i;
1363       int c;
1364
1365       /* See if the next `string_min' chars are all printing chars.  */
1366     tryline:
1367
1368       if (limit_bytes_to_format
1369           && address >= (n_bytes_to_skip + max_bytes_to_format - string_min))
1370         break;
1371
1372       for (i = 0; i < string_min; i++)
1373         {
1374           c = read_char ();
1375           address++;
1376           if (c < 0)
1377             return;
1378           if (!isprint (c))
1379             /* Found a non-printing.  Try again starting with next char.  */
1380             goto tryline;
1381           buf[i] = c;
1382         }
1383
1384       /* We found a run of `string_min' printable characters.
1385          Now see if it is terminated with a null byte.  */
1386       while (!limit_bytes_to_format
1387              || address < n_bytes_to_skip + max_bytes_to_format)
1388         {
1389           if (i == bufsize)
1390             {
1391               bufsize = 1 + 3 * bufsize / 2;
1392               buf = xrealloc (buf, bufsize);
1393             }
1394           c = read_char ();
1395           address++;
1396           if (c < 0)
1397             return;
1398           if (c == '\0')
1399             break;              /* It is; print this string.  */
1400           if (!isprint (c))
1401             goto tryline;       /* It isn't; give up on this string.  */
1402           buf[i++] = c;         /* String continues; store it all.  */
1403         }
1404
1405       /* If we get here, the string is all printable and null-terminated,
1406          so print it.  It is all in `buf' and `i' is its length.  */
1407       buf[i] = 0;
1408       if (output_address_fmt_string != NULL)
1409         {
1410           if (printf ("%s ", format_address (address - i - 1)) == EOF)
1411             error (2, errno, "standard output");
1412         }
1413       for (i = 0; (c = buf[i]); i++)
1414         {
1415           int err;
1416           switch (c)
1417             {
1418             case '\007':
1419               err = fputs ("\\a", stdout);
1420               break;
1421
1422             case '\b':
1423               err = fputs ("\\b", stdout);
1424               break;
1425
1426             case '\f':
1427               err = fputs ("\\f", stdout);
1428               break;
1429
1430             case '\n':
1431               err = fputs ("\\n", stdout);
1432               break;
1433
1434             case '\r':
1435               err = fputs ("\\r", stdout);
1436               break;
1437
1438             case '\t':
1439               err = fputs ("\\t", stdout);
1440               break;
1441
1442             case '\v':
1443               err = fputs ("\\v", stdout);
1444               break;
1445
1446             default:
1447               err = putchar (c);
1448             }
1449           if (err == EOF)
1450             error (2, errno, "standard output");
1451         }
1452       if (putchar ('\n') == EOF)
1453         error (2, errno, "standard output");
1454     }
1455   free (buf);
1456 }
1457
1458 void
1459 main (argc, argv)
1460      int argc;
1461      char **argv;
1462 {
1463   int c;
1464   int n_files;
1465   int i;
1466   unsigned int l_c_m;
1467   unsigned int address_pad_len;
1468   unsigned long int desired_width;
1469   int width_specified = 0;
1470
1471   program_name = argv[0];
1472
1473   for (i = 0; i <= MAX_INTEGRAL_TYPE_SIZE; i++)
1474     integral_type_size[i] = NO_SIZE;
1475
1476   integral_type_size[sizeof (char)] = CHAR;
1477   integral_type_size[sizeof (short int)] = SHORT;
1478   integral_type_size[sizeof (int)] = INT;
1479   integral_type_size[sizeof (long int)] = LONG;
1480
1481   for (i = 0; i <= MAX_FP_TYPE_SIZE; i++)
1482     fp_type_size[i] = NO_SIZE;
1483
1484   fp_type_size[sizeof (float)] = FP_SINGLE;
1485   /* The array entry for `double' is filled in after that for LONG_DOUBLE
1486      so that if `long double' is the same type or if long double isn't
1487      supported FP_LONG_DOUBLE will never be used.  */
1488   fp_type_size[sizeof (LONG_DOUBLE)] = FP_LONG_DOUBLE;
1489   fp_type_size[sizeof (double)] = FP_DOUBLE;
1490
1491   n_specs = 0;
1492   n_specs_allocated = 5;
1493   spec = (struct tspec *) xmalloc (n_specs_allocated * sizeof (struct tspec));
1494
1495   output_address_fmt_string = "%07o";
1496   address_pad_len = 7;
1497   flag_dump_strings = 0;
1498
1499   while ((c = getopt_long (argc, argv, "abcdfhilos::xw::A:j:N:t:v",
1500                            long_options, (int *) 0))
1501          != EOF)
1502     {
1503       strtoul_error err;
1504
1505       switch (c)
1506         {
1507         case 'A':
1508           switch (optarg[0])
1509             {
1510             case 'd':
1511               output_address_fmt_string = "%07d";
1512               address_pad_len = 7;
1513               break;
1514             case 'o':
1515               output_address_fmt_string = "%07o";
1516               address_pad_len = 7;
1517               break;
1518             case 'x':
1519               output_address_fmt_string = "%06x";
1520               address_pad_len = 6;
1521               break;
1522             case 'n':
1523               output_address_fmt_string = NULL;
1524               address_pad_len = 0;
1525               break;
1526             default:
1527               error (2, 0,
1528                      "invalid output address radix `%c'; it must be one character from [doxn]",
1529                      optarg[0]);
1530               break;
1531             }
1532           break;
1533
1534         case 'j':
1535           err = my_strtoul (optarg, 0, &n_bytes_to_skip, 1);
1536           if (err != UINT_OK)
1537             uint_fatal_error (optarg, "skip argument", err);
1538           break;
1539
1540         case 'N':
1541           limit_bytes_to_format = 1;
1542
1543           err = my_strtoul (optarg, 0, &max_bytes_to_format, 1);
1544           if (err != UINT_OK)
1545             uint_fatal_error (optarg, "limit argument", err);
1546           break;
1547
1548         case 's':
1549           if (optarg == NULL)
1550             string_min = 3;
1551           else
1552             {
1553               err = my_strtoul (optarg, 0, &string_min, 1);
1554               if (err != UINT_OK)
1555                 uint_fatal_error (optarg, "minimum string length", err);
1556             }
1557           ++flag_dump_strings;
1558           break;
1559
1560         case 't':
1561           if (decode_format_string (optarg))
1562             error (2, 0, "invalid type string `%s'", optarg);
1563           break;
1564
1565         case 'v':
1566           abbreviate_duplicate_blocks = 0;
1567           break;
1568
1569           /* The next several cases map the old, pre-POSIX format
1570              specification options to the corresponding POSIX format
1571              specs.  GNU od accepts any combination of old- and
1572              new-style options.  If only POSIX format specs are used
1573              and more than one is used, they are accumulated.  If only
1574              old-style options are used, all but the last are ignored.
1575              If both types of specs are used in the same command, the
1576              last old-style option and any POSIX specs following it
1577              are accumulated.  To illustrate, `od -c -t a' is the same
1578              as `od -t ca', but `od -t a -c' is the same as `od -c'.  */
1579
1580 #define CASE_OLD_ARG(old_char,new_string)                               \
1581         case old_char:                                                  \
1582           {                                                             \
1583             const char *next;                                           \
1584             int tmp;                                                    \
1585             assert (n_specs_allocated >= 1);                            \
1586             tmp = decode_one_format (new_string, &next, &(spec[0]));    \
1587             n_specs = 1;                                                \
1588             assert (tmp == 0);                                          \
1589             assert (*next == '\0');                                     \
1590           }                                                             \
1591           break
1592
1593           CASE_OLD_ARG ('a', "a");
1594           CASE_OLD_ARG ('b', "oC");
1595           CASE_OLD_ARG ('c', "c");
1596           CASE_OLD_ARG ('d', "u2");
1597           CASE_OLD_ARG ('f', "fF");
1598           CASE_OLD_ARG ('h', "x2");
1599           CASE_OLD_ARG ('i', "d2");
1600           CASE_OLD_ARG ('l', "d4");
1601           CASE_OLD_ARG ('o', "o2");
1602           CASE_OLD_ARG ('x', "x2");
1603
1604 #undef CASE_OLD_ARG
1605
1606         case 'w':
1607           width_specified = 1;
1608           if (optarg == NULL)
1609             {
1610               desired_width = 32;
1611             }
1612           else
1613             {
1614               err = my_strtoul (optarg, 10, &desired_width, 0);
1615               if (err != UINT_OK)
1616                 error (2, 0, "invalid width specification `%s'", optarg);
1617             }
1618           break;
1619
1620         default:
1621           usage ();
1622           break;
1623         }
1624     }
1625
1626   if (flag_dump_strings && n_specs > 0)
1627     error (2, 0, "no type may be specified when dumping strings");
1628
1629   assert (address_pad_len <= MAX_ADDRESS_LENGTH);
1630   for (i = 0; i < address_pad_len; i++)
1631     address_pad[i] = ' ';
1632   address_pad[address_pad_len] = '\0';
1633
1634   if (n_specs == 0)
1635     {
1636       int err = decode_one_format ("o2", NULL, &(spec[0]));
1637
1638       assert (err == 0);
1639       n_specs = 1;
1640     }
1641
1642   n_files = argc - optind;
1643   if (n_files > 0)
1644     file_list = (char const *const *) &argv[optind];
1645   else
1646     {
1647       /* If no files were listed on the command line, set up the
1648          global array FILE_LIST so that it contains the null-terminated
1649          list of one name: "-".  */
1650       static char const * const default_file_list[] = {"-", NULL};
1651
1652       file_list = default_file_list;
1653     }
1654
1655   skip (n_bytes_to_skip);
1656
1657   /* Compute output block length.  */
1658   l_c_m = get_lcm ();
1659
1660   if (width_specified)
1661     {
1662       if (desired_width != 0 && desired_width % l_c_m == 0)
1663         bytes_per_block = desired_width;
1664       else
1665         {
1666           error (0, 0, "warning: invalid width %d; using %d instead",
1667                  desired_width, l_c_m);
1668           bytes_per_block = l_c_m;
1669         }
1670     }
1671   else
1672     {
1673       if (l_c_m < DEFAULT_BYTES_PER_BLOCK)
1674         bytes_per_block = l_c_m * (int) (DEFAULT_BYTES_PER_BLOCK / l_c_m);
1675       else
1676         bytes_per_block = l_c_m;
1677     }
1678
1679 #ifdef DEBUG
1680   for (i = 0; i < n_specs; i++)
1681     {
1682       printf ("%d: fmt=\"%s\" width=%d\n",
1683               i, spec[i].fmt_string, width_bytes[spec[i].size]);
1684     }
1685 #endif
1686
1687   if (flag_dump_strings)
1688     {
1689       dump_strings ();
1690     }
1691   else
1692     {
1693       dump ();
1694     }
1695
1696   exit (0);
1697 }