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 char *xmalloc ();
 113 char *xrealloc ();
 114
 115 enum size_spec
 116   {
 117     NO_SIZE,
 118     CHAR,
 119     SHORT,
 120     INT,
 121     LONG,
 122     FLOAT_SINGLE,
 123     FLOAT_DOUBLE,
 124     FLOAT_LONG_DOUBLE
 125   };
 126
 127 enum output_format
 128   {
 129     SIGNED_DECIMAL,
 130     UNSIGNED_DECIMAL,
 131     OCTAL,
 132     HEXADECIMAL,
 133     FLOATING_POINT,
 134     NAMED_CHARACTER,
 135     CHARACTER
 136   };
 137
 138 /* Each output format specification (from POSIX `-t spec' or from
 139    old-style options) is represented by one of these structures.  */
 140 struct tspec
 141   {
 142     enum output_format fmt;
 143     enum size_spec size;
 144     void (*print_function) ();
 145     char *fmt_string;
 146     int hexl_mode_trailer;
 147     int field_width;
 148   };
 149
 150 /* The name this program was run with.  */
 151 char *program_name;
 152
 153 /* Convert the number of 8-bit bytes of a binary representation to
 154    the number of characters (digits + sign if the type is signed)
 155    required to represent the same quantity in the specified base/type.
 156    For example, a 32-bit (4-byte) quantity may require a field width
 157    as wide as the following for these types:
 158    11   unsigned octal
 159    11   signed decimal
 160    10   unsigned decimal
 161    8    unsigned hexadecimal  */
 162
 163 static const unsigned int bytes_to_oct_digits[] =
 164 {0, 3, 6, 8, 11, 14, 16, 19, 22, 25, 27, 30, 32, 35, 38, 41, 43};
 165
 166 static const unsigned int bytes_to_signed_dec_digits[] =
 167 {1, 4, 6, 8, 11, 13, 16, 18, 20, 23, 25, 28, 30, 33, 35, 37, 40};
 168
 169 static const unsigned int bytes_to_unsigned_dec_digits[] =
 170 {0, 3, 5, 8, 10, 13, 15, 17, 20, 22, 25, 27, 29, 32, 34, 37, 39};
 171
 172 static const unsigned int bytes_to_hex_digits[] =
 173 {0, 2, 4, 6, 8, 10, 12, 14, 16, 18, 20, 22, 24, 26, 28, 30, 32};
 174
 175 /* Convert enum size_spec to the size of the named type.  */
 176 static const int width_bytes[] =
 177 {
 178   -1,
 179   sizeof (char),
 180   sizeof (short int),
 181   sizeof (int),
 182   sizeof (long int),
 183   sizeof (float),
 184   sizeof (double),
 185   sizeof (LONG_DOUBLE)
 186 };
 187
 188 /* Names for some non-printing characters.  */
 189 static const char *const charname[33] =
 190 {
 191   "nul", "soh", "stx", "etx", "eot", "enq", "ack", "bel",
 192   "bs", "ht", "nl", "vt", "ff", "cr", "so", "si",
 193   "dle", "dc1", "dc2", "dc3", "dc4", "nak", "syn", "etb",
 194   "can", "em", "sub", "esc", "fs", "gs", "rs", "us",
 195   "sp"
 196 };
 197
 198 /* A printf control string for printing a file offset.  */
 199 static const char *output_address_fmt_string;
 200
 201 /* FIXME: make this the number of octal digits in an unsigned long.  */
 202 #define MAX_ADDRESS_LENGTH 13
 203
 204 /* Space for a normal address, a space, a pseudo address, parentheses
 205    around the pseudo address, and a trailing zero byte. */
 206 static char address_fmt_buffer[2 * MAX_ADDRESS_LENGTH + 4];
 207 static char address_pad[MAX_ADDRESS_LENGTH + 1];
 208
 209 static unsigned long int string_min;
 210 static unsigned long int flag_dump_strings;
 211
 212 /* Non-zero if we should recognize the pre-POSIX non-option arguments
 213    that specified at most one file and optional arguments specifying
 214    offset and pseudo-start address.  */
 215 static int traditional;
 216
 217 /* Non-zero if an old-style `pseudo-address' was specified.  */
 218 static long int flag_pseudo_start;
 219
 220 /* The difference between the old-style pseudo starting address and
 221    the number of bytes to skip.  */
 222 static long int pseudo_offset;
 223
 224 /* Function to format an address and optionally an additional parenthesized
 225    pseudo-address; it returns the formatted string.  */
 226 static const char *(*format_address) __P ((long unsigned int));
 227
 228 /* The number of input bytes to skip before formatting and writing.  */
 229 static off_t n_bytes_to_skip = 0;
 230
 231 /* When nonzero, MAX_BYTES_TO_FORMAT is the maximum number of bytes
 232    to be read and formatted.  Otherwise all input is formatted.  */
 233 static int limit_bytes_to_format = 0;
 234
 235 /* The maximum number of bytes that will be formatted.  This
 236    value is used only when LIMIT_BYTES_TO_FORMAT is nonzero.  */
 237 static off_t max_bytes_to_format;
 238
 239 /* When nonzero and two or more consecutive blocks are equal, format
 240    only the first block and output an asterisk alone on the following
 241    line to indicate that identical blocks have been elided.  */
 242 static int abbreviate_duplicate_blocks = 1;
 243
 244 /* An array of specs describing how to format each input block.  */
 245 static struct tspec *spec;
 246
 247 /* The number of format specs.  */
 248 static unsigned int n_specs;
 249
 250 /* The allocated length of SPEC.  */
 251 static unsigned int n_specs_allocated;
 252
 253 /* The number of input bytes formatted per output line.  It must be
 254    a multiple of the least common multiple of the sizes associated with
 255    the specified output types.  It should be as large as possible, but
 256    no larger than 16 -- unless specified with the -w option.  */
 257 static unsigned int bytes_per_block;
 258
 259 /* Human-readable representation of *file_list (for error messages).
 260    It differs from *file_list only when *file_list is "-".  */
 261 static char const *input_filename;
 262
 263 /* A NULL-terminated list of the file-arguments from the command line.
 264    If no file-arguments were specified, this variable is initialized
 265    to { "-", NULL }.  */
 266 static char const *const *file_list;
 267
 268 /* The input stream associated with the current file.  */
 269 static FILE *in_stream;
 270
 271 /* If nonzero, at least one of the files we read was standard input.  */
 272 static int have_read_stdin;
 273
 274 #define LONGEST_INTEGRAL_TYPE long int
 275
 276 #define MAX_INTEGRAL_TYPE_SIZE sizeof(LONGEST_INTEGRAL_TYPE)
 277 static enum size_spec integral_type_size[MAX_INTEGRAL_TYPE_SIZE + 1];
 278
 279 #define MAX_FP_TYPE_SIZE sizeof(LONG_DOUBLE)
 280 static enum size_spec fp_type_size[MAX_FP_TYPE_SIZE + 1];
 281
 282 /* If nonzero, display usage information and exit.  */
 283 static int show_help;
 284
 285 /* If nonzero, print the version on standard output then exit.  */
 286 static int show_version;
 287
 288 static struct option const long_options[] =
 289 {
 290   /* POSIX options.  */
 291   {"skip-bytes", required_argument, NULL, 'j'},
 292   {"address-radix", required_argument, NULL, 'A'},
 293   {"read-bytes", required_argument, NULL, 'N'},
 294   {"format", required_argument, NULL, 't'},
 295   {"output-duplicates", no_argument, NULL, 'v'},
 296
 297   /* non-POSIX options.  */
 298   {"strings", optional_argument, NULL, 's'},
 299   {"traditional", no_argument, NULL, 'B'},
 300   {"width", optional_argument, NULL, 'w'},
 301   {"help", no_argument, &show_help, 1},
 302   {"version", no_argument, &show_version, 1},
 303   {NULL, 0, NULL, 0}
 304 };
 305
 306 static void
 307 usage (int status)
 308 {
 309   if (status != 0)
 310     fprintf (stderr, _("Try `%s --help' for more information.\n"),
 311              program_name);
 312   else
 313     {
 314       printf (_("\
 315 Usage: %s [OPTION]... [FILE]...\n\
 316   or:  %s --traditional [FILE] [[+]OFFSET [[+]LABEL]]\n\
 317 "),
 318               program_name, program_name);
 319       printf (_("\
 320 Write an unambiguous representation, octal bytes by default, of FILE\n\
 321 to standard output.  With no FILE, or when FILE is -, read standard input.\n\
 322 \n\
 323   -A, --address-radix=RADIX   decide how file offsets are printed\n\
 324   -j, --skip-bytes=BYTES      skip BYTES input bytes first on each file\n\
 325   -N, --read-bytes=BYTES      limit dump to BYTES input bytes per file\n\
 326   -s, --strings[=BYTES]       output strings of at least BYTES graphic chars\n\
 327   -t, --format=TYPE           select output format or formats\n\
 328   -v, --output-duplicates     do not use * to mark line suppression\n\
 329   -w, --width[=BYTES]         output BYTES bytes per output line\n\
 330       --traditional           accept arguments in pre-POSIX form\n\
 331       --help                  display this help and exit\n\
 332       --version               output version information and exit\n\
 333 \n\
 334 Pre-POSIX format specifications may be intermixed, they accumulate:\n\
 335   -a   same as -t a,  select named characters\n\
 336   -b   same as -t oC, select octal bytes\n\
 337   -c   same as -t c,  select ASCII characters or backslash escapes\n\
 338   -d   same as -t u2, select unsigned decimal shorts\n\
 339   -f   same as -t fF, select floats\n\
 340   -h   same as -t x2, select hexadecimal shorts\n\
 341   -i   same as -t d2, select decimal shorts\n\
 342   -l   same as -t d4, select decimal longs\n\
 343   -o   same as -t o2, select octal shorts\n\
 344   -x   same as -t x2, select hexadecimal shorts\n\
 345 "));
 346       printf (_("\
 347 \n\
 348 For older syntax (second call format), OFFSET means -j OFFSET.  LABEL\n\
 349 is the pseudo-address at first byte printed, incremented when dump is\n\
 350 progressing.  For OFFSET and LABEL, a 0x or 0X prefix indicates\n\
 351 hexadecimal, suffixes maybe . for octal and b multiply by 512.\n\
 352 \n\
 353 TYPE is made up of one or more of these specifications:\n\
 354 \n\
 355   a          named character\n\
 356   c          ASCII character or backslash escape\n\
 357   d[SIZE]    signed decimal, SIZE bytes per integer\n\
 358   f[SIZE]    floating point, SIZE bytes per integer\n\
 359   o[SIZE]    octal, SIZE bytes per integer\n\
 360   u[SIZE]    unsigned decimal, SIZE bytes per integer\n\
 361   x[SIZE]    hexadecimal, SIZE bytes per integer\n\
 362 \n\
 363 SIZE is a number.  For TYPE in doux, SIZE may also be C for\n\
 364 sizeof(char), S for sizeof(short), I for sizeof(int) or L for\n\
 365 sizeof(long).  If TYPE is f, SIZE may also be F for sizeof(float), D\n\
 366 for sizeof(double) or L for sizeof(long double).\n\
 367 \n\
 368 RADIX is d for decimal, o for octal, x for hexadecimal or n for none.\n\
 369 BYTES is hexadecimal with 0x or 0X prefix, it is multiplied by 512\n\
 370 with b suffix, by 1024 with k and by 1048576 with m.  Adding a z suffix to\n\
 371 any type adds a display of printable characters to the end of each line\n\
 372 of output.  -s without a number implies 3.  -w without a number implies 32.\n\
 373 By default, od uses -A o -t d2 -w 16.\n\
 374 "));
 375       puts (_("\nReport bugs to <textutils-bugs@gnu.org>."));
 376     }
 377   exit (status == 0 ? EXIT_SUCCESS : EXIT_FAILURE);
 378 }
 379
 380 /* Compute the greatest common denominator of U and V
 381    using Euclid's algorithm.  */
 382
 383 static unsigned int
 384 gcd (unsigned int u, unsigned int v)
 385 {
 386   unsigned int t;
 387   while (v != 0)
 388     {
 389       t = u % v;
 390       u = v;
 391       v = t;
 392     }
 393   return u;
 394 }
 395
 396 /* Compute the least common multiple of U and V.  */
 397
 398 static unsigned int
 399 lcm (unsigned int u, unsigned int v)
 400 {
 401   unsigned int t = gcd (u, v);
 402   if (t == 0)
 403     return 0;
 404   return u * v / t;
 405 }
 406
 407 static void
 408 print_s_char (long unsigned int n_bytes, const char *block,
 409               const char *fmt_string)
 410 {
 411   int i;
 412   for (i = n_bytes; i > 0; i--)
 413     {
 414       int tmp = (unsigned) *(const unsigned char *) block;
 415       if (tmp > SCHAR_MAX)
 416         tmp -= SCHAR_MAX - SCHAR_MIN + 1;
 417       assert (tmp <= SCHAR_MAX);
 418       printf (fmt_string, tmp);
 419       block += sizeof (unsigned char);
 420     }
 421 }
 422
 423 static void
 424 print_char (long unsigned int n_bytes, const char *block,
 425             const char *fmt_string)
 426 {
 427   int i;
 428   for (i = n_bytes; i > 0; i--)
 429     {
 430       unsigned int tmp = *(const unsigned char *) block;
 431       printf (fmt_string, tmp);
 432       block += sizeof (unsigned char);
 433     }
 434 }
 435
 436 static void
 437 print_s_short (long unsigned int n_bytes, const char *block,
 438                const char *fmt_string)
 439 {
 440   int i;
 441   for (i = n_bytes / sizeof (unsigned short); i > 0; i--)
 442     {
 443       int tmp = (unsigned) *(const unsigned short *) block;
 444       if (tmp > SHRT_MAX)
 445         tmp -= SHRT_MAX - SHRT_MIN + 1;
 446       assert (tmp <= SHRT_MAX);
 447       printf (fmt_string, tmp);
 448       block += sizeof (unsigned short);
 449     }
 450 }
 451
 452 static void
 453 print_short (long unsigned int n_bytes, const char *block,
 454              const char *fmt_string)
 455 {
 456   int i;
 457   for (i = n_bytes / sizeof (unsigned short); i > 0; i--)
 458     {
 459       unsigned int tmp = *(const unsigned short *) block;
 460       printf (fmt_string, tmp);
 461       block += sizeof (unsigned short);
 462     }
 463 }
 464
 465 static void
 466 print_int (long unsigned int n_bytes, const char *block,
 467            const char *fmt_string)
 468 {
 469   int i;
 470   for (i = n_bytes / sizeof (unsigned int); i > 0; i--)
 471     {
 472       unsigned int tmp = *(const unsigned int *) block;
 473       printf (fmt_string, tmp);
 474       block += sizeof (unsigned int);
 475     }
 476 }
 477
 478 static void
 479 print_long (long unsigned int n_bytes, const char *block,
 480             const char *fmt_string)
 481 {
 482   int i;
 483   for (i = n_bytes / sizeof (unsigned long); i > 0; i--)
 484     {
 485       unsigned long tmp = *(const unsigned long *) block;
 486       printf (fmt_string, tmp);
 487       block += sizeof (unsigned long);
 488     }
 489 }
 490
 491 static void
 492 print_float (long unsigned int n_bytes, const char *block,
 493              const char *fmt_string)
 494 {
 495   int i;
 496   for (i = n_bytes / sizeof (float); i > 0; i--)
 497     {
 498       float tmp = *(const float *) block;
 499       printf (fmt_string, tmp);
 500       block += sizeof (float);
 501     }
 502 }
 503
 504 static void
 505 print_double (long unsigned int n_bytes, const char *block,
 506               const char *fmt_string)
 507 {
 508   int i;
 509   for (i = n_bytes / sizeof (double); i > 0; i--)
 510     {
 511       double tmp = *(const double *) block;
 512       printf (fmt_string, tmp);
 513       block += sizeof (double);
 514     }
 515 }
 516
 517 #ifdef HAVE_LONG_DOUBLE
 518 static void
 519 print_long_double (long unsigned int n_bytes, const char *block,
 520                    const char *fmt_string)
 521 {
 522   int i;
 523   for (i = n_bytes / sizeof (LONG_DOUBLE); i > 0; i--)
 524     {
 525       LONG_DOUBLE tmp = *(const LONG_DOUBLE *) block;
 526       printf (fmt_string, tmp);
 527       block += sizeof (LONG_DOUBLE);
 528     }
 529 }
 530
 531 #endif
 532
 533 static void
 534 dump_hexl_mode_trailer (long unsigned int n_bytes, const char *block)
 535 {
 536   int i;
 537   fputs ("  >", stdout);
 538   for (i = n_bytes; i > 0; i--)
 539     {
 540       unsigned int c = *(const unsigned char *) block;
 541       unsigned int c2 = (ISPRINT(c) ? c : '.');
 542       putchar (c2);
 543       block += sizeof (unsigned char);
 544     }
 545   putchar ('<');
 546 }
 547
 548 static void
 549 print_named_ascii (long unsigned int n_bytes, const char *block,
 550                    const char *unused_fmt_string)
 551 {
 552   int i;
 553   for (i = n_bytes; i > 0; i--)
 554     {
 555       unsigned int c = *(const unsigned char *) block;
 556       unsigned int masked_c = (0x7f & c);
 557       const char *s;
 558       char buf[5];
 559
 560       if (masked_c == 127)
 561         s = "del";
 562       else if (masked_c <= 040)
 563         s = charname[masked_c];
 564       else
 565         {
 566           sprintf (buf, "  %c", masked_c);
 567           s = buf;
 568         }
 569
 570       printf (" %3s", s);
 571       block += sizeof (unsigned char);
 572     }
 573 }
 574
 575 static void
 576 print_ascii (long unsigned int n_bytes, const char *block,
 577              const char *unused_fmt_string)
 578 {
 579   int i;
 580   for (i = n_bytes; i > 0; i--)
 581     {
 582       unsigned int c = *(const unsigned char *) block;
 583       const char *s;
 584       char buf[5];
 585
 586       switch (c)
 587         {
 588         case '\0':
 589           s = " \\0";
 590           break;
 591
 592         case '\007':
 593           s = " \\a";
 594           break;
 595
 596         case '\b':
 597           s = " \\b";
 598           break;
 599
 600         case '\f':
 601           s = " \\f";
 602           break;
 603
 604         case '\n':
 605           s = " \\n";
 606           break;
 607
 608         case '\r':
 609           s = " \\r";
 610           break;
 611
 612         case '\t':
 613           s = " \\t";
 614           break;
 615
 616         case '\v':
 617           s = " \\v";
 618           break;
 619
 620         default:
 621           sprintf (buf, (ISPRINT (c) ? "  %c" : "%03o"), c);
 622           s = (const char *) buf;
 623         }
 624
 625       printf (" %3s", s);
 626       block += sizeof (unsigned char);
 627     }
 628 }
 629
 630 /* Convert a null-terminated (possibly zero-length) string S to an
 631    unsigned long integer value.  If S points to a non-digit set *P to S,
 632    *VAL to 0, and return 0.  Otherwise, accumulate the integer value of
 633    the string of digits.  If the string of digits represents a value
 634    larger than ULONG_MAX, don't modify *VAL or *P and return nonzero.
 635    Otherwise, advance *P to the first non-digit after S, set *VAL to
 636    the result of the conversion and return zero.  */
 637
 638 static int
 639 simple_strtoul (const char *s, const char **p, long unsigned int *val)
 640 {
 641   unsigned long int sum;
 642
 643   sum = 0;
 644   while (ISDIGIT (*s))
 645     {
 646       unsigned int c = *s++ - '0';
 647       if (sum > (ULONG_MAX - c) / 10)
 648         return 1;
 649       sum = sum * 10 + c;
 650     }
 651   *p = s;
 652   *val = sum;
 653   return 0;
 654 }
 655
 656 /* If S points to a single valid POSIX-style od format string, put
 657    a description of that format in *TSPEC, make *NEXT point at the
 658    character following the just-decoded format (if *NEXT is non-NULL),
 659    and return zero.  If S is not valid, don't modify *NEXT or *TSPEC,
 660    give a diagnostic, and return nonzero.  For example, if S were
 661    "d4afL" *NEXT would be set to "afL" and *TSPEC would be
 662      {
 663        fmt = SIGNED_DECIMAL;
 664        size = INT or LONG; (whichever integral_type_size[4] resolves to)
 665        print_function = print_int; (assuming size == INT)
 666        fmt_string = "%011d%c";
 667       }
 668    S_ORIG is solely for reporting errors.  It should be the full format
 669    string argument.
 670    */
 671
 672 static int
 673 decode_one_format (const char *s_orig, const char *s, const char **next,
 674                    struct tspec *tspec)
 675 {
 676   enum size_spec size_spec;
 677   unsigned long int size;
 678   enum output_format fmt;
 679   const char *pre_fmt_string;
 680   char *fmt_string;
 681   void (*print_function) ();
 682   const char *p;
 683   unsigned int c;
 684   unsigned int field_width = 0;
 685
 686   assert (tspec != NULL);
 687
 688   switch (*s)
 689     {
 690     case 'd':
 691     case 'o':
 692     case 'u':
 693     case 'x':
 694       c = *s;
 695       ++s;
 696       switch (*s)
 697         {
 698         case 'C':
 699           ++s;
 700           size = sizeof (char);
 701           break;
 702
 703         case 'S':
 704           ++s;
 705           size = sizeof (short);
 706           break;
 707
 708         case 'I':
 709           ++s;
 710           size = sizeof (int);
 711           break;
 712
 713         case 'L':
 714           ++s;
 715           size = sizeof (long int);
 716           break;
 717
 718         default:
 719           if (simple_strtoul (s, &p, &size) != 0)
 720             {
 721               /* The integer at P in S would overflow an unsigned long.
 722                  A digit string that long is sufficiently odd looking
 723                  that the following diagnostic is sufficient.  */
 724               error (0, 0, _("invalid type string `%s'"), s_orig);
 725               return 1;
 726             }
 727           if (p == s)
 728             size = sizeof (int);
 729           else
 730             {
 731               if (size > MAX_INTEGRAL_TYPE_SIZE
 732                   || integral_type_size[size] == NO_SIZE)
 733                 {
 734                   error (0, 0, _("invalid type string `%s';\n\
 735 this system doesn't provide a %lu-byte integral type"), s_orig, size);
 736                   return 1;
 737                 }
 738               s = p;
 739             }
 740           break;
 741         }
 742
 743 #define FMT_BYTES_ALLOCATED 9
 744       fmt_string = xmalloc (FMT_BYTES_ALLOCATED);
 745
 746       size_spec = integral_type_size[size];
 747
 748       switch (c)
 749         {
 750         case 'd':
 751           fmt = SIGNED_DECIMAL;
 752           sprintf (fmt_string, " %%%u%sd",
 753                    (field_width = bytes_to_signed_dec_digits[size]),
 754                    (size_spec == LONG ? "l" : ""));
 755           break;
 756
 757         case 'o':
 758           fmt = OCTAL;
 759           sprintf (fmt_string, " %%0%u%so",
 760                    (field_width = bytes_to_oct_digits[size]),
 761                    (size_spec == LONG ? "l" : ""));
 762           break;
 763
 764         case 'u':
 765           fmt = UNSIGNED_DECIMAL;
 766           sprintf (fmt_string, " %%%u%su",
 767                    (field_width = bytes_to_unsigned_dec_digits[size]),
 768                    (size_spec == LONG ? "l" : ""));
 769           break;
 770
 771         case 'x':
 772           fmt = HEXADECIMAL;
 773           sprintf (fmt_string, " %%0%u%sx",
 774                    (field_width = bytes_to_hex_digits[size]),
 775                    (size_spec == LONG ? "l" : ""));
 776           break;
 777
 778         default:
 779           abort ();
 780         }
 781
 782       assert (strlen (fmt_string) < FMT_BYTES_ALLOCATED);
 783
 784       switch (size_spec)
 785         {
 786         case CHAR:
 787           print_function = (fmt == SIGNED_DECIMAL
 788                             ? print_s_char
 789                             : print_char);
 790           break;
 791
 792         case SHORT:
 793           print_function = (fmt == SIGNED_DECIMAL
 794                             ? print_s_short
 795                             : print_short);
 796           break;
 797
 798         case INT:
 799           print_function = print_int;
 800           break;
 801
 802         case LONG:
 803           print_function = print_long;
 804           break;
 805
 806         default:
 807           abort ();
 808         }
 809       break;
 810
 811     case 'f':
 812       fmt = FLOATING_POINT;
 813       ++s;
 814       switch (*s)
 815         {
 816         case 'F':
 817           ++s;
 818           size = sizeof (float);
 819           break;
 820
 821         case 'D':
 822           ++s;
 823           size = sizeof (double);
 824           break;
 825
 826         case 'L':
 827           ++s;
 828           size = sizeof (LONG_DOUBLE);
 829           break;
 830
 831         default:
 832           if (simple_strtoul (s, &p, &size) != 0)
 833             {
 834               /* The integer at P in S would overflow an unsigned long.
 835                  A digit string that long is sufficiently odd looking
 836                  that the following diagnostic is sufficient.  */
 837               error (0, 0, _("invalid type string `%s'"), s_orig);
 838               return 1;
 839             }
 840           if (p == s)
 841             size = sizeof (double);
 842           else
 843             {
 844               if (size > MAX_FP_TYPE_SIZE
 845                   || fp_type_size[size] == NO_SIZE)
 846                 {
 847                   error (0, 0, _("invalid type string `%s';\n\
 848 this system doesn't provide a %lu-byte floating point type"), s_orig, size);
 849                   return 1;
 850                 }
 851               s = p;
 852             }
 853           break;
 854         }
 855       size_spec = fp_type_size[size];
 856
 857       switch (size_spec)
 858         {
 859         case FLOAT_SINGLE:
 860           print_function = print_float;
 861           /* Don't use %#e; not all systems support it.  */
 862           pre_fmt_string = " %%%d.%de";
 863           fmt_string = xmalloc (strlen (pre_fmt_string));
 864           sprintf (fmt_string, pre_fmt_string,
 865                    (field_width = FLT_DIG + 8), FLT_DIG);
 866           break;
 867
 868         case FLOAT_DOUBLE:
 869           print_function = print_double;
 870           pre_fmt_string = " %%%d.%de";
 871           fmt_string = xmalloc (strlen (pre_fmt_string));
 872           sprintf (fmt_string, pre_fmt_string,
 873                    (field_width = DBL_DIG + 8), DBL_DIG);
 874           break;
 875
 876 #ifdef HAVE_LONG_DOUBLE
 877         case FLOAT_LONG_DOUBLE:
 878           print_function = print_long_double;
 879           pre_fmt_string = " %%%d.%dLe";
 880           fmt_string = xmalloc (strlen (pre_fmt_string));
 881           sprintf (fmt_string, pre_fmt_string,
 882                    (field_width = LDBL_DIG + 8), LDBL_DIG);
 883           break;
 884 #endif
 885
 886         default:
 887           abort ();
 888         }
 889       break;
 890
 891     case 'a':
 892       ++s;
 893       fmt = NAMED_CHARACTER;
 894       size_spec = CHAR;
 895       fmt_string = NULL;
 896       print_function = print_named_ascii;
 897       field_width = 3;
 898       break;
 899
 900     case 'c':
 901       ++s;
 902       fmt = CHARACTER;
 903       size_spec = CHAR;
 904       fmt_string = NULL;
 905       print_function = print_ascii;
 906       field_width = 3;
 907       break;
 908
 909     default:
 910       error (0, 0, _("invalid character `%c' in type string `%s'"),
 911              *s, s_orig);
 912       return 1;
 913     }
 914
 915   tspec->size = size_spec;
 916   tspec->fmt = fmt;
 917   tspec->print_function = print_function;
 918   tspec->fmt_string = fmt_string;
 919
 920   tspec->field_width = field_width;
 921   tspec->hexl_mode_trailer = (*s == 'z');
 922   if (tspec->hexl_mode_trailer)
 923     s++;
 924
 925   if (next != NULL)
 926     *next = s;
 927
 928   return 0;
 929 }
 930
 931 /* Decode the POSIX-style od format string S.  Append the decoded
 932    representation to the global array SPEC, reallocating SPEC if
 933    necessary.  Return zero if S is valid, nonzero otherwise.  */
 934
 935 static int
 936 decode_format_string (const char *s)
 937 {
 938   const char *s_orig = s;
 939   assert (s != NULL);
 940
 941   while (*s != '\0')
 942     {
 943       struct tspec tspec;
 944       const char *next;
 945
 946       if (decode_one_format (s_orig, s, &next, &tspec))
 947         return 1;
 948
 949       assert (s != next);
 950       s = next;
 951
 952       if (n_specs >= n_specs_allocated)
 953         {
 954           n_specs_allocated = 1 + (3 * n_specs_allocated) / 2;
 955           spec = (struct tspec *) xrealloc (spec, (n_specs_allocated
 956                                                    * sizeof (struct tspec)));
 957         }
 958
 959       memcpy ((char *) &spec[n_specs], (char *) &tspec,
 960               sizeof (struct tspec));
 961       ++n_specs;
 962     }
 963
 964   return 0;
 965 }
 966
 967 /* Given a list of one or more input filenames FILE_LIST, set the global
 968    file pointer IN_STREAM to position N_SKIP in the concatenation of
 969    those files.  If any file operation fails or if there are fewer than
 970    N_SKIP bytes in the combined input, give an error message and return
 971    nonzero.  When possible, use seek- rather than read operations to
 972    advance IN_STREAM.  A file name of "-" is interpreted as standard
 973    input.  */
 974
 975 static int
 976 skip (off_t n_skip)
 977 {
 978   int err;
 979
 980   err = 0;
 981   for ( /* empty */ ; *file_list != NULL; ++file_list)
 982     {
 983       struct stat file_stats;
 984       int j;
 985
 986       if (STREQ (*file_list, "-"))
 987         {
 988           input_filename = _("standard input");
 989           in_stream = stdin;
 990           have_read_stdin = 1;
 991         }
 992       else
 993         {
 994           input_filename = *file_list;
 995           in_stream = fopen (input_filename, "r");
 996           if (in_stream == NULL)
 997             {
 998               error (0, errno, "%s", input_filename);
 999               err = 1;
1000               continue;
1001             }
1002         }
1003       WINDOWS_SETFILEMODE_BINARY (in_stream, input_filename);
1004
1005       if (n_skip == 0)
1006         break;
1007
1008       /* First try using fseek.  For large offsets, this extra work is
1009          worthwhile.  If the offset is below some threshold it may be
1010          more efficient to move the pointer by reading.  There are two
1011          issues when trying to use fseek:
1012            - the file must be seekable.
1013            - before seeking to the specified position, make sure
1014              that the new position is in the current file.
1015              Try to do that by getting file's size using fstat().
1016              But that will work only for regular files and dirs.  */
1017
1018       if (fstat (fileno (in_stream), &file_stats))
1019         {
1020           error (0, errno, "%s", input_filename);
1021           err = 1;
1022           continue;
1023         }
1024
1025       /* The st_size field is valid only for regular files and
1026          directories.  FIXME: is the preceding true?
1027          If the number of bytes left to skip is at least as large as
1028          the size of the current file, we can decrement
1029          n_skip and go on to the next file.  */
1030       if (S_ISREG (file_stats.st_mode) || S_ISDIR (file_stats.st_mode))
1031         {
1032           if (n_skip >= file_stats.st_size)
1033             {
1034               n_skip -= file_stats.st_size;
1035               if (in_stream != stdin && fclose (in_stream) == EOF)
1036                 {
1037                   error (0, errno, "%s", input_filename);
1038                   err = 1;
1039                 }
1040               continue;
1041             }
1042           else
1043             {
1044               /* fseek may work on some streams for which lseek doesn't.
1045                  But fseek's offset argument is restricted to the range
1046                  of type `long'.  So if N_SKIP is too large or if fseek
1047                  fails, try lseek.  */
1048               if ((n_skip <= LONG_MAX
1049                    && fseek (in_stream, (long) n_skip, SEEK_SET) == 0)
1050                   || lseek (fileno (in_stream), 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 }