src/od.c

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