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