src/od.c

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