src/od.c

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