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