src/od.c

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