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