src/od.c

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