src/od.c

   1 /* od -- dump files in octal and other formats
   2    Copyright (C) 92, 95, 96, 1997 Free Software Foundation, Inc.
   3
   4    This program is free software; you can redistribute it and/or modify
   5    it under the terms of the GNU General Public License as published by
   6    the Free Software Foundation; either version 2, or (at your option)
   7    any later version.
   8
   9    This program is distributed in the hope that it will be useful,
  10    but WITHOUT ANY WARRANTY; without even the implied warranty of
  11    MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
  12    GNU General Public License for more details.
  13
  14    You should have received a copy of the GNU General Public License
  15    along with this program; if not, write to the Free Software Foundation,
  16    Inc., 59 Temple Place - Suite 330, Boston, MA 02111-1307, USA.  */
  17
  18 /* Written by Jim Meyering.  */
  19
  20 #include <config.h>
  21
  22 #include <stdio.h>
  23 #include <assert.h>
  24 #include <getopt.h>
  25 #include <sys/types.h>
  26 #include "system.h"
  27 #include "xstrtoul.h"
  28 #include "error.h"
  29
  30 #if defined(__GNUC__) || defined(STDC_HEADERS)
  31 # include <float.h>
  32 #endif
  33
  34 #ifdef HAVE_LONG_DOUBLE
  35 typedef long double LONG_DOUBLE;
  36 #else
  37 typedef double LONG_DOUBLE;
  38 #endif
  39
  40 #if HAVE_LIMITS_H
  41 # include <limits.h>
  42 #endif
  43 #ifndef SCHAR_MAX
  44 # define SCHAR_MAX 127
  45 #endif
  46 #ifndef SCHAR_MIN
  47 # define SCHAR_MIN (-128)
  48 #endif
  49 #ifndef SHRT_MAX
  50 # define SHRT_MAX 32767
  51 #endif
  52 #ifndef SHRT_MIN
  53 # define SHRT_MIN (-32768)
  54 #endif
  55 #ifndef ULONG_MAX
  56 # define ULONG_MAX ((unsigned long) ~(unsigned long) 0)
  57 #endif
  58
  59 #if HAVE_VALUES_H
  60 # include <values.h>
  61 #endif
  62
  63 #ifndef BITSPERBYTE
  64 # define BITSPERBYTE 8
  65 #endif
  66
  67 #ifndef MAX
  68 # define MAX(a, b) ((a) > (b) ? (a) : (b))
  69 #endif
  70
  71 #ifndef MIN
  72 # define MIN(a,b) (((a) < (b)) ? (a) : (b))
  73 #endif
  74
  75 #if defined (_WIN32) && defined (_O_BINARY)
  76 # define WINDOWS_SETFILEMODE_BINARY(IN_STREAM, FILENAME)                \
  77     do                                                                  \
  78       { /* Turn off DOS text file modes, "rb" doesn't work on stdin.  */\
  79         if (_setmode (_fileno ((IN_STREAM)), _O_BINARY) == -1)          \
  80           {                                                             \
  81             error (0, errno, "%s", (FILENAME));                         \
  82             err = 1;                                                    \
  83             continue;                                                   \
  84           }                                                             \
  85       }                                                                 \
  86     while (0)
  87 #else
  88 # define WINDOWS_SETFILEMODE_BINARY(IN_STREAM, FILENAME) /* empty */
  89 #endif
  90
  91 /* The default number of input bytes per output line.  */
  92 #define DEFAULT_BYTES_PER_BLOCK 16
  93
  94 /* The number of decimal digits of precision in a float.  */
  95 #ifndef FLT_DIG
  96 # define FLT_DIG 7
  97 #endif
  98
  99 /* The number of decimal digits of precision in a double.  */
 100 #ifndef DBL_DIG
 101 # define DBL_DIG 15
 102 #endif
 103
 104 /* The number of decimal digits of precision in a long double.  */
 105 #ifndef LDBL_DIG
 106 # define LDBL_DIG DBL_DIG
 107 #endif
 108
 109 char *xmalloc ();
 110 char *xrealloc ();
 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 (spec, (n_specs_allocated
 953                                                    * sizeof (struct tspec)));
 954         }
 955
 956       memcpy ((char *) &spec[n_specs], (char *) &tspec,
 957               sizeof (struct tspec));
 958       ++n_specs;
 959     }
 960
 961   return 0;
 962 }
 963
 964 /* Given a list of one or more input filenames FILE_LIST, set the global
 965    file pointer IN_STREAM to position N_SKIP in the concatenation of
 966    those files.  If any file operation fails or if there are fewer than
 967    N_SKIP bytes in the combined input, give an error message and return
 968    nonzero.  When possible, use seek- rather than read operations to
 969    advance IN_STREAM.  A file name of "-" is interpreted as standard
 970    input.  */
 971
 972 static int
 973 skip (off_t n_skip)
 974 {
 975   int err;
 976
 977   err = 0;
 978   for ( /* empty */ ; *file_list != NULL; ++file_list)
 979     {
 980       struct stat file_stats;
 981       int j;
 982
 983       if (STREQ (*file_list, "-"))
 984         {
 985           input_filename = _("standard input");
 986           in_stream = stdin;
 987           have_read_stdin = 1;
 988         }
 989       else
 990         {
 991           input_filename = *file_list;
 992           in_stream = fopen (input_filename, "r");
 993           if (in_stream == NULL)
 994             {
 995               error (0, errno, "%s", input_filename);
 996               err = 1;
 997               continue;
 998             }
 999         }
1000       WINDOWS_SETFILEMODE_BINARY (in_stream, input_filename);
1001
1002       if (n_skip == 0)
1003         break;
1004
1005       /* First try using fseek.  For large offsets, this extra work is
1006          worthwhile.  If the offset is below some threshold it may be
1007          more efficient to move the pointer by reading.  There are two
1008          issues when trying to use fseek:
1009            - the file must be seekable.
1010            - before seeking to the specified position, make sure
1011              that the new position is in the current file.
1012              Try to do that by getting file's size using fstat().
1013              But that will work only for regular files and dirs.  */
1014
1015       if (fstat (fileno (in_stream), &file_stats))
1016         {
1017           error (0, errno, "%s", input_filename);
1018           err = 1;
1019           continue;
1020         }
1021
1022       /* The st_size field is valid only for regular files and
1023          directories.  FIXME: is the preceding true?
1024          If the number of bytes left to skip is at least as large as
1025          the size of the current file, we can decrement
1026          n_skip and go on to the next file.  */
1027       if (S_ISREG (file_stats.st_mode) || S_ISDIR (file_stats.st_mode))
1028         {
1029           if (n_skip >= file_stats.st_size)
1030             {
1031               n_skip -= file_stats.st_size;
1032               if (in_stream != stdin && fclose (in_stream) == EOF)
1033                 {
1034                   error (0, errno, "%s", input_filename);
1035                   err = 1;
1036                 }
1037               continue;
1038             }
1039           else
1040             {
1041               /* fseek may work on some streams for which lseek doesn't.
1042                  But fseek's offset argument is restricted to the range
1043                  of type `long'.  So if N_SKIP is too large or if fseek
1044                  fails, try lseek.  */
1045               if ((n_skip <= LONG_MAX
1046                    && fseek (in_stream, (long) n_skip, SEEK_SET) == 0)
1047                   || lseek (fileno (in_stream), n_skip, SEEK_SET) >= 0)
1048                 {
1049                   n_skip = 0;
1050                   break;
1051                 }
1052             }
1053         }
1054
1055       /* Seek didn't work or wasn't attempted;  position the file pointer
1056          by reading.  */
1057
1058       for (j = n_skip / BUFSIZ; j >= 0; j--)
1059         {
1060           char buf[BUFSIZ];
1061           size_t n_bytes_to_read = (j > 0
1062                                     ? BUFSIZ
1063                                     : n_skip % BUFSIZ);
1064           size_t n_bytes_read;
1065           n_bytes_read = fread (buf, 1, n_bytes_to_read, in_stream);
1066           n_skip -= n_bytes_read;
1067           if (n_bytes_read != n_bytes_to_read)
1068             break;
1069         }
1070
1071       if (n_skip == 0)
1072         break;
1073     }
1074
1075   if (n_skip != 0)
1076     error (EXIT_FAILURE, 0, _("cannot skip past end of combined input"));
1077
1078   return err;
1079 }
1080
1081 static const char *
1082 format_address_none (long unsigned int address)
1083 {
1084   return "";
1085 }
1086
1087 static const char *
1088 format_address_std (long unsigned int address)
1089 {
1090   const char *address_string;
1091
1092   sprintf (address_fmt_buffer, output_address_fmt_string, address);
1093   address_string = address_fmt_buffer;
1094   return address_string;
1095 }
1096
1097 static const char *
1098 format_address_label (long unsigned int address)
1099 {
1100   const char *address_string;
1101   assert (output_address_fmt_string != NULL);
1102
1103   sprintf (address_fmt_buffer, output_address_fmt_string,
1104            address, address + pseudo_offset);
1105   address_string = address_fmt_buffer;
1106   return address_string;
1107 }
1108
1109 /* Write N_BYTES bytes from CURR_BLOCK to standard output once for each
1110    of the N_SPEC format specs.  CURRENT_OFFSET is the byte address of
1111    CURR_BLOCK in the concatenation of input files, and it is printed
1112    (optionally) only before the output line associated with the first
1113    format spec.  When duplicate blocks are being abbreviated, the output
1114    for a sequence of identical input blocks is the output for the first
1115    block followed by an asterisk alone on a line.  It is valid to compare
1116    the blocks PREV_BLOCK and CURR_BLOCK only when N_BYTES == BYTES_PER_BLOCK.
1117    That condition may be false only for the last input block -- and then
1118    only when it has not been padded to length BYTES_PER_BLOCK.  */
1119
1120 static void
1121 write_block (long unsigned int current_offset, long unsigned int n_bytes,
1122              const char *prev_block, const char *curr_block)
1123 {
1124   static int first = 1;
1125   static int prev_pair_equal = 0;
1126
1127 #define EQUAL_BLOCKS(b1, b2) (memcmp ((b1), (b2), bytes_per_block) == 0)
1128
1129   if (abbreviate_duplicate_blocks
1130       && !first && n_bytes == bytes_per_block
1131       && EQUAL_BLOCKS (prev_block, curr_block))
1132     {
1133       if (prev_pair_equal)
1134         {
1135           /* The two preceding blocks were equal, and the current
1136              block is the same as the last one, so print nothing.  */
1137         }
1138       else
1139         {
1140           printf ("*\n");
1141           prev_pair_equal = 1;
1142         }
1143     }
1144   else
1145     {
1146       unsigned int i;
1147
1148       prev_pair_equal = 0;
1149       for (i = 0; i < n_specs; i++)
1150         {
1151           const char *addr_or_pad = (i == 0
1152                                      ? format_address (current_offset)
1153                                      : address_pad);
1154
1155           fputs (addr_or_pad, stdout);
1156           (*spec[i].print_function) (n_bytes, curr_block, spec[i].fmt_string);
1157           if (spec[i].hexl_mode_trailer)
1158             {
1159               /* space-pad out to full line width, then dump the trailer */
1160               int datum_width = width_bytes[spec[i].size];
1161               int blank_fields = (bytes_per_block - n_bytes) / datum_width;
1162               int field_width = spec[i].field_width + 1;
1163               printf ("%*s", blank_fields * field_width, "");
1164               dump_hexl_mode_trailer (n_bytes, curr_block);
1165             }
1166           putchar ('\n');
1167         }
1168     }
1169   first = 0;
1170 }
1171
1172 /* Test whether there have been errors on in_stream, and close it if
1173    it is not standard input.  Return nonzero if there has been an error
1174    on in_stream or stdout; return zero otherwise.  This function will
1175    report more than one error only if both a read and a write error
1176    have occurred.  */
1177
1178 static int
1179 check_and_close (void)
1180 {
1181   int err;
1182
1183   err = 0;
1184   if (ferror (in_stream))
1185     {
1186       error (0, errno, "%s", input_filename);
1187       if (in_stream != stdin)
1188         fclose (in_stream);
1189       err = 1;
1190     }
1191   else if (in_stream != stdin && fclose (in_stream) == EOF)
1192     {
1193       error (0, errno, "%s", input_filename);
1194       err = 1;
1195     }
1196
1197   if (ferror (stdout))
1198     {
1199       error (0, errno, _("standard output"));
1200       err = 1;
1201     }
1202
1203   return err;
1204 }
1205
1206 /* Read a single byte into *C from the concatenation of the input files
1207    named in the global array FILE_LIST.  On the first call to this
1208    function, the global variable IN_STREAM is expected to be an open
1209    stream associated with the input file *FILE_LIST.  If IN_STREAM is
1210    at end-of-file, close it and update the global variables IN_STREAM,
1211    FILE_LIST, and INPUT_FILENAME so they correspond to the next file in
1212    the list.  Then try to read a byte from the newly opened file.
1213    Repeat if necessary until *FILE_LIST is NULL.  When EOF is reached
1214    for the last file in FILE_LIST, set *C to EOF and return.  Subsequent
1215    calls do likewise.  The return value is nonzero if any errors
1216    occured, zero otherwise.  */
1217
1218 static int
1219 read_char (int *c)
1220 {
1221   int err;
1222
1223   if (*file_list == NULL)
1224     {
1225       *c = EOF;
1226       return 0;
1227     }
1228
1229   err = 0;
1230   while (1)
1231     {
1232       *c = fgetc (in_stream);
1233
1234       if (*c != EOF)
1235         return err;
1236
1237       err |= check_and_close ();
1238
1239       do
1240         {
1241           ++file_list;
1242           if (*file_list == NULL)
1243             return err;
1244
1245           if (STREQ (*file_list, "-"))
1246             {
1247               input_filename = _("standard input");
1248               in_stream = stdin;
1249               have_read_stdin = 1;
1250             }
1251           else
1252             {
1253               input_filename = *file_list;
1254               in_stream = fopen (input_filename, "r");
1255               if (in_stream == NULL)
1256                 {
1257                   error (0, errno, "%s", input_filename);
1258                   err = 1;
1259                 }
1260             }
1261           WINDOWS_SETFILEMODE_BINARY (in_stream, input_filename);
1262         }
1263       while (in_stream == NULL);
1264     }
1265 }
1266
1267 /* Read N bytes into BLOCK from the concatenation of the input files
1268    named in the global array FILE_LIST.  On the first call to this
1269    function, the global variable IN_STREAM is expected to be an open
1270    stream associated with the input file *FILE_LIST.  On subsequent
1271    calls, if *FILE_LIST is NULL, don't modify BLOCK and return zero.
1272    If all N bytes cannot be read from IN_STREAM, close IN_STREAM and
1273    update the global variables IN_STREAM, FILE_LIST, and INPUT_FILENAME.
1274    Then try to read the remaining bytes from the newly opened file.
1275    Repeat if necessary until *FILE_LIST is NULL.  Set *N_BYTES_IN_BUFFER
1276    to the number of bytes read.  If an error occurs, it will be detected
1277    through ferror when the stream is about to be closed.  If there is an
1278    error, give a message but continue reading as usual and return nonzero.
1279    Otherwise return zero.  */
1280
1281 static int
1282 read_block (size_t n, char *block, size_t *n_bytes_in_buffer)
1283 {
1284   int err;
1285
1286   assert (n > 0 && n <= bytes_per_block);
1287
1288   *n_bytes_in_buffer = 0;
1289
1290   if (n == 0)
1291     return 0;
1292
1293   if (*file_list == NULL)
1294     return 0;                   /* EOF.  */
1295
1296   err = 0;
1297   while (1)
1298     {
1299       size_t n_needed;
1300       size_t n_read;
1301
1302       n_needed = n - *n_bytes_in_buffer;
1303       n_read = fread (block + *n_bytes_in_buffer, 1, n_needed, in_stream);
1304
1305       *n_bytes_in_buffer += n_read;
1306
1307       if (n_read == n_needed)
1308         return err;
1309
1310       err |= check_and_close ();
1311
1312       do
1313         {
1314           ++file_list;
1315           if (*file_list == NULL)
1316             return err;
1317
1318           if (STREQ (*file_list, "-"))
1319             {
1320               input_filename = _("standard input");
1321               in_stream = stdin;
1322               have_read_stdin = 1;
1323             }
1324           else
1325             {
1326               input_filename = *file_list;
1327               in_stream = fopen (input_filename, "r");
1328               if (in_stream == NULL)
1329                 {
1330                   error (0, errno, "%s", input_filename);
1331                   err = 1;
1332                 }
1333             }
1334           WINDOWS_SETFILEMODE_BINARY (in_stream, input_filename);
1335         }
1336       while (in_stream == NULL);
1337     }
1338 }
1339
1340 /* Return the least common multiple of the sizes associated
1341    with the format specs.  */
1342
1343 static int
1344 get_lcm (void)
1345 {
1346   unsigned int i;
1347   int l_c_m = 1;
1348
1349   for (i = 0; i < n_specs; i++)
1350     l_c_m = lcm (l_c_m, width_bytes[(int) spec[i].size]);
1351   return l_c_m;
1352 }
1353
1354 /* If S is a valid pre-POSIX offset specification with an optional leading '+'
1355    return the offset it denotes.  Otherwise, return -1.  */
1356
1357 off_t
1358 parse_old_offset (const char *s)
1359 {
1360   int radix;
1361   off_t offset;
1362   enum strtol_error s_err;
1363   long unsigned int tmp;
1364
1365   if (*s == '\0')
1366     return -1;
1367
1368   /* Skip over any leading '+'. */
1369   if (s[0] == '+')
1370     ++s;
1371
1372   /* Determine the radix we'll use to interpret S.  If there is a `.',
1373      it's decimal, otherwise, if the string begins with `0X'or `0x',
1374      it's hexadecimal, else octal.  */
1375   if (strchr (s, '.') != NULL)
1376     radix = 10;
1377   else
1378     {
1379       if (s[0] == '0' && (s[1] == 'x' || s[1] == 'X'))
1380         radix = 16;
1381       else
1382         radix = 8;
1383     }
1384
1385   s_err = xstrtoul (s, NULL, radix, &tmp, "Bb");
1386   if (s_err != LONGINT_OK)
1387     {
1388       STRTOL_FAIL_WARN (s, _("old-style offset"), s_err);
1389       return -1;
1390     }
1391   offset = tmp;
1392   return offset;
1393 }
1394
1395 /* Read a chunk of size BYTES_PER_BLOCK from the input files, write the
1396    formatted block to standard output, and repeat until the specified
1397    maximum number of bytes has been read or until all input has been
1398    processed.  If the last block read is smaller than BYTES_PER_BLOCK
1399    and its size is not a multiple of the size associated with a format
1400    spec, extend the input block with zero bytes until its length is a
1401    multiple of all format spec sizes.  Write the final block.  Finally,
1402    write on a line by itself the offset of the byte after the last byte
1403    read.  Accumulate return values from calls to read_block and
1404    check_and_close, and if any was nonzero, return nonzero.
1405    Otherwise, return zero.  */
1406
1407 static int
1408 dump (void)
1409 {
1410   char *block[2];
1411   off_t current_offset;
1412   off_t end_offset;
1413   int idx;
1414   int err;
1415   size_t n_bytes_read;
1416
1417 #ifdef lint  /* Suppress `used before initialized' warning.  */
1418   end_offset = 0;
1419 #endif
1420
1421   block[0] = (char *) alloca (bytes_per_block);
1422   block[1] = (char *) alloca (bytes_per_block);
1423
1424   current_offset = n_bytes_to_skip;
1425
1426   idx = 0;
1427   err = 0;
1428   if (limit_bytes_to_format)
1429     {
1430       end_offset = n_bytes_to_skip + max_bytes_to_format;
1431
1432       while (1)
1433         {
1434           size_t n_needed;
1435           if (current_offset >= end_offset)
1436             {
1437               n_bytes_read = 0;
1438               break;
1439             }
1440           n_needed = MIN (end_offset - current_offset,
1441                           (off_t) bytes_per_block);
1442           err |= read_block (n_needed, block[idx], &n_bytes_read);
1443           if (n_bytes_read < bytes_per_block)
1444             break;
1445           assert (n_bytes_read == bytes_per_block);
1446           write_block (current_offset, n_bytes_read,
1447                        block[!idx], block[idx]);
1448           current_offset += n_bytes_read;
1449           idx = !idx;
1450         }
1451     }
1452   else
1453     {
1454       while (1)
1455         {
1456           err |= read_block (bytes_per_block, block[idx], &n_bytes_read);
1457           if (n_bytes_read < bytes_per_block)
1458             break;
1459           assert (n_bytes_read == bytes_per_block);
1460           write_block (current_offset, n_bytes_read,
1461                        block[!idx], block[idx]);
1462           current_offset += n_bytes_read;
1463           idx = !idx;
1464         }
1465     }
1466
1467   if (n_bytes_read > 0)
1468     {
1469       int l_c_m;
1470       size_t bytes_to_write;
1471
1472       l_c_m = get_lcm ();
1473
1474       /* Make bytes_to_write the smallest multiple of l_c_m that
1475          is at least as large as n_bytes_read.  */
1476       bytes_to_write = l_c_m * (int) ((n_bytes_read + l_c_m - 1) / l_c_m);
1477
1478       memset (block[idx] + n_bytes_read, 0, bytes_to_write - n_bytes_read);
1479       write_block (current_offset, bytes_to_write,
1480                    block[!idx], block[idx]);
1481       current_offset += n_bytes_read;
1482     }
1483
1484   if (output_address_fmt_string != NULL)
1485     printf ("%s\n", format_address (current_offset));
1486
1487   if (limit_bytes_to_format && current_offset > end_offset)
1488     err |= check_and_close ();
1489
1490   return err;
1491 }
1492
1493 /* STRINGS mode.  Find each "string constant" in the input.
1494    A string constant is a run of at least `string_min' ASCII
1495    graphic (or formatting) characters terminated by a null.
1496    Based on a function written by Richard Stallman for a
1497    pre-POSIX version of od.  Return nonzero if an error
1498    occurs.  Otherwise, return zero.  */
1499
1500 static int
1501 dump_strings (void)
1502 {
1503   size_t bufsize = MAX (100, string_min);
1504   char *buf = xmalloc (bufsize);
1505   off_t address = n_bytes_to_skip;
1506   int err;
1507
1508   err = 0;
1509   while (1)
1510     {
1511       unsigned int i;
1512       int c;
1513
1514       /* See if the next `string_min' chars are all printing chars.  */
1515     tryline:
1516
1517       if (limit_bytes_to_format
1518           && address >= (n_bytes_to_skip + max_bytes_to_format -
1519                          (off_t) string_min))
1520         break;
1521
1522       for (i = 0; i < string_min; i++)
1523         {
1524           err |= read_char (&c);
1525           address++;
1526           if (c < 0)
1527             {
1528               free (buf);
1529               return err;
1530             }
1531           if (!ISPRINT (c))
1532             /* Found a non-printing.  Try again starting with next char.  */
1533             goto tryline;
1534           buf[i] = c;
1535         }
1536
1537       /* We found a run of `string_min' printable characters.
1538          Now see if it is terminated with a null byte.  */
1539       while (!limit_bytes_to_format
1540              || address < n_bytes_to_skip + max_bytes_to_format)
1541         {
1542           if (i == bufsize)
1543             {
1544               bufsize = 1 + 3 * bufsize / 2;
1545               buf = xrealloc (buf, bufsize);
1546             }
1547           err |= read_char (&c);
1548           address++;
1549           if (c < 0)
1550             {
1551               free (buf);
1552               return err;
1553             }
1554           if (c == '\0')
1555             break;              /* It is; print this string.  */
1556           if (!ISPRINT (c))
1557             goto tryline;       /* It isn't; give up on this string.  */
1558           buf[i++] = c;         /* String continues; store it all.  */
1559         }
1560
1561       /* If we get here, the string is all printable and null-terminated,
1562          so print it.  It is all in `buf' and `i' is its length.  */
1563       buf[i] = 0;
1564       if (output_address_fmt_string != NULL)
1565         {
1566           printf ("%s ", format_address (address - i - 1));
1567         }
1568       for (i = 0; (c = buf[i]); i++)
1569         {
1570           switch (c)
1571             {
1572             case '\007':
1573               fputs ("\\a", stdout);
1574               break;
1575
1576             case '\b':
1577               fputs ("\\b", stdout);
1578               break;
1579
1580             case '\f':
1581               fputs ("\\f", stdout);
1582               break;
1583
1584             case '\n':
1585               fputs ("\\n", stdout);
1586               break;
1587
1588             case '\r':
1589               fputs ("\\r", stdout);
1590               break;
1591
1592             case '\t':
1593               fputs ("\\t", stdout);
1594               break;
1595
1596             case '\v':
1597               fputs ("\\v", stdout);
1598               break;
1599
1600             default:
1601               putc (c, stdout);
1602             }
1603         }
1604       putchar ('\n');
1605     }
1606
1607   /* We reach this point only if we search through
1608      (max_bytes_to_format - string_min) bytes before reachine EOF.  */
1609
1610   free (buf);
1611
1612   err |= check_and_close ();
1613   return err;
1614 }
1615
1616 int
1617 main (int argc, char **argv)
1618 {
1619   int c;
1620   int n_files;
1621   unsigned int i;
1622   unsigned int l_c_m;
1623   unsigned int address_pad_len;
1624   unsigned long int desired_width;
1625   int width_specified = 0;
1626   int n_failed_decodes = 0;
1627   int err;
1628
1629   /* The old-style `pseudo starting address' to be printed in parentheses
1630      after any true address.  */
1631   long int pseudo_start;
1632
1633 #ifdef lint  /* Suppress `used before initialized' warning.  */
1634   pseudo_start = 0;
1635 #endif
1636
1637   program_name = argv[0];
1638   setlocale (LC_ALL, "");
1639   bindtextdomain (PACKAGE, LOCALEDIR);
1640   textdomain (PACKAGE);
1641
1642   err = 0;
1643
1644   for (i = 0; i <= MAX_INTEGRAL_TYPE_SIZE; i++)
1645     integral_type_size[i] = NO_SIZE;
1646
1647   integral_type_size[sizeof (char)] = CHAR;
1648   integral_type_size[sizeof (short int)] = SHORT;
1649   integral_type_size[sizeof (int)] = INT;
1650   integral_type_size[sizeof (long int)] = LONG;
1651
1652   for (i = 0; i <= MAX_FP_TYPE_SIZE; i++)
1653     fp_type_size[i] = NO_SIZE;
1654
1655   fp_type_size[sizeof (float)] = FLOAT_SINGLE;
1656   /* The array entry for `double' is filled in after that for LONG_DOUBLE
1657      so that if `long double' is the same type or if long double isn't
1658      supported FLOAT_LONG_DOUBLE will never be used.  */
1659   fp_type_size[sizeof (LONG_DOUBLE)] = FLOAT_LONG_DOUBLE;
1660   fp_type_size[sizeof (double)] = FLOAT_DOUBLE;
1661
1662   n_specs = 0;
1663   n_specs_allocated = 5;
1664   spec = (struct tspec *) xmalloc (n_specs_allocated * sizeof (struct tspec));
1665
1666   output_address_fmt_string = "%07o";
1667   format_address = format_address_std;
1668   address_pad_len = 7;
1669   flag_dump_strings = 0;
1670
1671   while ((c = getopt_long (argc, argv, "abcdfhilos::xw::A:j:N:t:v",
1672                            long_options, NULL)) != -1)
1673     {
1674       unsigned long int tmp;
1675       enum strtol_error s_err;
1676
1677       switch (c)
1678         {
1679         case 0:
1680           break;
1681
1682         case 'A':
1683           switch (optarg[0])
1684             {
1685             case 'd':
1686               output_address_fmt_string = "%07d";
1687               format_address = format_address_std;
1688               address_pad_len = 7;
1689               break;
1690             case 'o':
1691               output_address_fmt_string = "%07o";
1692               format_address = format_address_std;
1693               address_pad_len = 7;
1694               break;
1695             case 'x':
1696               output_address_fmt_string = "%06x";
1697               format_address = format_address_std;
1698               address_pad_len = 6;
1699               break;
1700             case 'n':
1701               output_address_fmt_string = NULL;
1702               format_address = format_address_none;
1703               address_pad_len = 0;
1704               break;
1705             default:
1706               error (EXIT_FAILURE, 0,
1707                      _("invalid output address radix `%c'; \
1708 it must be one character from [doxn]"),
1709                      optarg[0]);
1710               break;
1711             }
1712           break;
1713
1714         case 'j':
1715           s_err = xstrtoul (optarg, NULL, 0, &tmp, "bkm");
1716           n_bytes_to_skip = tmp;
1717           if (s_err != LONGINT_OK)
1718             STRTOL_FATAL_ERROR (optarg, _("skip argument"), s_err);
1719           break;
1720
1721         case 'N':
1722           limit_bytes_to_format = 1;
1723
1724           /* FIXME: if off_t is long long and that's an 8-byte type,
1725              use xstrtouq here.  */
1726           s_err = xstrtoul (optarg, NULL, 0, &tmp, "bkm");
1727           max_bytes_to_format = tmp;
1728           if (s_err != LONGINT_OK)
1729             STRTOL_FATAL_ERROR (optarg, _("limit argument"), s_err);
1730
1731           if (tmp > LONG_MAX)
1732             error (EXIT_FAILURE, 0,
1733                    _("specified number of bytes `%s' is larger than \
1734 the maximum\nrepresentable value of type `long'"), optarg);
1735           break;
1736
1737         case 's':
1738           if (optarg == NULL)
1739             string_min = 3;
1740           else
1741             {
1742               s_err = xstrtoul (optarg, NULL, 0, &string_min, "bkm");
1743               if (s_err != LONGINT_OK)
1744                 STRTOL_FATAL_ERROR (optarg, _("minimum string length"), s_err);
1745             }
1746           ++flag_dump_strings;
1747           break;
1748
1749         case 't':
1750           if (decode_format_string (optarg))
1751             ++n_failed_decodes;
1752           break;
1753
1754         case 'v':
1755           abbreviate_duplicate_blocks = 0;
1756           break;
1757
1758         case 'B':
1759           traditional = 1;
1760           break;
1761
1762           /* The next several cases map the old, pre-POSIX format
1763              specification options to the corresponding POSIX format
1764              specs.  GNU od accepts any combination of old- and
1765              new-style options.  Format specification options accumulate.  */
1766
1767 #define CASE_OLD_ARG(old_char,new_string)               \
1768         case old_char:                                  \
1769           {                                             \
1770             if (decode_format_string (new_string))      \
1771               ++n_failed_decodes;                       \
1772           }                                             \
1773           break
1774
1775           CASE_OLD_ARG ('a', "a");
1776           CASE_OLD_ARG ('b', "oC");
1777           CASE_OLD_ARG ('c', "c");
1778           CASE_OLD_ARG ('d', "u2");
1779           CASE_OLD_ARG ('f', "fF");
1780           CASE_OLD_ARG ('h', "x2");
1781           CASE_OLD_ARG ('i', "d2");
1782           CASE_OLD_ARG ('l', "d4");
1783           CASE_OLD_ARG ('o', "o2");
1784           CASE_OLD_ARG ('x', "x2");
1785
1786 #undef CASE_OLD_ARG
1787
1788         case 'w':
1789           width_specified = 1;
1790           if (optarg == NULL)
1791             {
1792               desired_width = 32;
1793             }
1794           else
1795             {
1796               s_err = xstrtoul (optarg, NULL, 10, &desired_width, "");
1797               if (s_err != LONGINT_OK)
1798                 STRTOL_FATAL_ERROR (optarg, _("width specification"), s_err);
1799             }
1800           break;
1801
1802         default:
1803           usage (1);
1804           break;
1805         }
1806     }
1807
1808   if (n_failed_decodes > 0)
1809     exit (EXIT_FAILURE);
1810
1811   if (show_version)
1812     {
1813       printf ("od (%s) %s\n", GNU_PACKAGE, VERSION);
1814       exit (EXIT_SUCCESS);
1815     }
1816
1817   if (show_help)
1818     usage (0);
1819
1820   if (flag_dump_strings && n_specs > 0)
1821     error (EXIT_FAILURE, 0,
1822            _("no type may be specified when dumping strings"));
1823
1824   n_files = argc - optind;
1825
1826   /* If the --backward-compatible option is used, there may be from
1827      0 to 3 remaining command line arguments;  handle each case
1828      separately.
1829         od [file] [[+]offset[.][b] [[+]label[.][b]]]
1830      The offset and pseudo_start have the same syntax.  */
1831
1832   if (traditional)
1833     {
1834       off_t offset;
1835
1836       if (n_files == 1)
1837         {
1838           if ((offset = parse_old_offset (argv[optind])) >= 0)
1839             {
1840               n_bytes_to_skip = offset;
1841               --n_files;
1842               ++argv;
1843             }
1844         }
1845       else if (n_files == 2)
1846         {
1847           off_t o1, o2;
1848           if ((o1 = parse_old_offset (argv[optind])) >= 0
1849               && (o2 = parse_old_offset (argv[optind + 1])) >= 0)
1850             {
1851               n_bytes_to_skip = o1;
1852               flag_pseudo_start = 1;
1853               pseudo_start = o2;
1854               argv += 2;
1855               n_files -= 2;
1856             }
1857           else if ((o2 = parse_old_offset (argv[optind + 1])) >= 0)
1858             {
1859               n_bytes_to_skip = o2;
1860               --n_files;
1861               argv[optind + 1] = argv[optind];
1862               ++argv;
1863             }
1864           else
1865             {
1866               error (0, 0,
1867                      _("invalid second operand in compatibility mode `%s'"),
1868                      argv[optind + 1]);
1869               usage (1);
1870             }
1871         }
1872       else if (n_files == 3)
1873         {
1874           off_t o1, o2;
1875           if ((o1 = parse_old_offset (argv[optind + 1])) >= 0
1876               && (o2 = parse_old_offset (argv[optind + 2])) >= 0)
1877             {
1878               n_bytes_to_skip = o1;
1879               flag_pseudo_start = 1;
1880               pseudo_start = o2;
1881               argv[optind + 2] = argv[optind];
1882               argv += 2;
1883               n_files -= 2;
1884             }
1885           else
1886             {
1887               error (0, 0,
1888             _("in compatibility mode, the last two arguments must be offsets"));
1889               usage (1);
1890             }
1891         }
1892       else if (n_files > 3)
1893         {
1894           error (0, 0,
1895                  _("compatibility mode supports at most three arguments"));
1896           usage (1);
1897         }
1898
1899       if (flag_pseudo_start)
1900         {
1901           static char buf[10];
1902
1903           if (output_address_fmt_string == NULL)
1904             {
1905               output_address_fmt_string = "(%07o)";
1906               format_address = format_address_std;
1907             }
1908           else
1909             {
1910               sprintf (buf, "%s (%s)",
1911                        output_address_fmt_string,
1912                        output_address_fmt_string);
1913               output_address_fmt_string = buf;
1914               format_address = format_address_label;
1915             }
1916         }
1917     }
1918
1919   assert (address_pad_len <= MAX_ADDRESS_LENGTH);
1920   for (i = 0; i < address_pad_len; i++)
1921     address_pad[i] = ' ';
1922   address_pad[address_pad_len] = '\0';
1923
1924   if (n_specs == 0)
1925     {
1926       if (decode_one_format ("o2", "o2", NULL, &(spec[0])))
1927         {
1928           /* This happens on Cray systems that don't have a 2-byte
1929              integral type.  */
1930           exit (EXIT_FAILURE);
1931         }
1932
1933       n_specs = 1;
1934     }
1935
1936   if (n_files > 0)
1937     file_list = (char const *const *) &argv[optind];
1938   else
1939     {
1940       /* If no files were listed on the command line, set up the
1941          global array FILE_LIST so that it contains the null-terminated
1942          list of one name: "-".  */
1943       static char const *const default_file_list[] = {"-", NULL};
1944
1945       file_list = default_file_list;
1946     }
1947
1948   err |= skip (n_bytes_to_skip);
1949   if (in_stream == NULL)
1950     goto cleanup;
1951
1952   pseudo_offset = (flag_pseudo_start ? pseudo_start - n_bytes_to_skip : 0);
1953
1954   /* Compute output block length.  */
1955   l_c_m = get_lcm ();
1956
1957   if (width_specified)
1958     {
1959       if (desired_width != 0 && desired_width % l_c_m == 0)
1960         bytes_per_block = desired_width;
1961       else
1962         {
1963           error (0, 0, _("warning: invalid width %lu; using %d instead"),
1964                  desired_width, l_c_m);
1965           bytes_per_block = l_c_m;
1966         }
1967     }
1968   else
1969     {
1970       if (l_c_m < DEFAULT_BYTES_PER_BLOCK)
1971         bytes_per_block = l_c_m * (int) (DEFAULT_BYTES_PER_BLOCK / l_c_m);
1972       else
1973         bytes_per_block = l_c_m;
1974     }
1975
1976 #ifdef DEBUG
1977   for (i = 0; i < n_specs; i++)
1978     {
1979       printf (_("%d: fmt=\"%s\" width=%d\n"),
1980               i, spec[i].fmt_string, width_bytes[spec[i].size]);
1981     }
1982 #endif
1983
1984   err |= (flag_dump_strings ? dump_strings () : dump ());
1985
1986 cleanup:;
1987
1988   if (have_read_stdin && fclose (stdin) == EOF)
1989     error (EXIT_FAILURE, errno, _("standard input"));
1990
1991   if (fclose (stdout) == EOF)
1992     error (EXIT_FAILURE, errno, _("write error"));
1993
1994   exit (err == 0 ? EXIT_SUCCESS : EXIT_FAILURE);
1995 }