src/od.c

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