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