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