src/od.c

   1 /* od -- dump files in octal and other formats
   2    Copyright (C) 1992 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
  75 #define STREQ(a,b) (strcmp((a), (b)) == 0)
  76
  77 #ifndef MAX
  78 #define MAX(a, b) ((a) > (b) ? (a) : (b))
  79 #endif
  80
  81 #ifndef MIN
  82 #define MIN(a,b) (((a) < (b)) ? (a) : (b))
  83 #endif
  84
  85 /* The default number of input bytes per output line.  */
  86 #define DEFAULT_BYTES_PER_BLOCK 16
  87
  88 /* The number of decimal digits of precision in a float.  */
  89 #ifndef FLT_DIG
  90 #define FLT_DIG 7
  91 #endif
  92
  93 /* The number of decimal digits of precision in a double.  */
  94 #ifndef DBL_DIG
  95 #define DBL_DIG 15
  96 #endif
  97
  98 /* The number of decimal digits of precision in a long double.  */
  99 #ifndef LDBL_DIG
 100 #define LDBL_DIG DBL_DIG
 101 #endif
 102
 103 char *xmalloc ();
 104 char *xrealloc ();
 105
 106 enum size_spec
 107   {
 108     NO_SIZE,
 109     CHAR,
 110     SHORT,
 111     INT,
 112     LONG,
 113     FLOAT_SINGLE,
 114     FLOAT_DOUBLE,
 115     FLOAT_LONG_DOUBLE
 116   };
 117
 118 enum output_format
 119   {
 120     SIGNED_DECIMAL,
 121     UNSIGNED_DECIMAL,
 122     OCTAL,
 123     HEXADECIMAL,
 124     FLOATING_POINT,
 125     NAMED_CHARACTER,
 126     CHARACTER
 127   };
 128
 129 enum strtoul_error
 130   {
 131     UINT_OK, UINT_INVALID, UINT_INVALID_SUFFIX_CHAR, UINT_OVERFLOW
 132   };
 133 typedef enum strtoul_error strtoul_error;
 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   };
 144
 145 /* The name this program was run with.  */
 146 char *program_name;
 147
 148 /* Convert the number of 8-bit bytes of a binary representation to
 149    the number of characters (digits + sign if the type is signed)
 150    required to represent the same quantity in the specified base/type.
 151    For example, a 32-bit (4-byte) quantity may require a field width
 152    as wide as the following for these types:
 153    11   unsigned octal
 154    11   signed decimal
 155    10   unsigned decimal
 156    8    unsigned hexadecimal  */
 157
 158 static const unsigned int bytes_to_oct_digits[] =
 159 {0, 3, 6, 8, 11, 14, 16, 19, 22, 25, 27, 30, 32, 35, 38, 41, 43};
 160
 161 static const unsigned int bytes_to_signed_dec_digits[] =
 162 {1, 4, 6, 8, 11, 13, 16, 18, 20, 23, 25, 28, 30, 33, 35, 37, 40};
 163
 164 static const unsigned int bytes_to_unsigned_dec_digits[] =
 165 {0, 3, 5, 8, 10, 13, 15, 17, 20, 22, 25, 27, 29, 32, 34, 37, 39};
 166
 167 static const unsigned int bytes_to_hex_digits[] =
 168 {0, 2, 4, 6, 8, 10, 12, 14, 16, 18, 20, 22, 24, 26, 28, 30, 32};
 169
 170 /* Convert enum size_spec to the size of the named type.  */
 171 static const int width_bytes[] =
 172 {
 173   -1,
 174   sizeof (char),
 175   sizeof (short int),
 176   sizeof (int),
 177   sizeof (long int),
 178   sizeof (float),
 179   sizeof (double),
 180   sizeof (LONG_DOUBLE)
 181 };
 182
 183 /* Names for some non-printing characters.  */
 184 static const char *const charname[33] =
 185 {
 186   "nul", "soh", "stx", "etx", "eot", "enq", "ack", "bel",
 187   "bs", "ht", "nl", "vt", "ff", "cr", "so", "si",
 188   "dle", "dc1", "dc2", "dc3", "dc4", "nak", "syn", "etb",
 189   "can", "em", "sub", "esc", "fs", "gs", "rs", "us",
 190   "sp"
 191 };
 192
 193 /* A printf control string for printing a file offset.  */
 194 static const char *output_address_fmt_string;
 195
 196 /* FIXME: make this the number of octal digits in an unsigned long.  */
 197 #define MAX_ADDRESS_LENGTH 13
 198
 199 /* Space for a normal address, a space, a pseudo address, parentheses
 200    around the pseudo address, and a trailing zero byte. */
 201 static char address_fmt_buffer[2 * MAX_ADDRESS_LENGTH + 4];
 202 static char address_pad[MAX_ADDRESS_LENGTH + 1];
 203
 204 static unsigned long int string_min;
 205 static unsigned long int flag_dump_strings;
 206
 207 /* Non-zero if we should recognize the pre-POSIX non-option arguments
 208    that specified at most one file and optional arguments specifying
 209    offset and pseudo-start address.  */
 210 static int traditional;
 211
 212 /* Non-zero if an old-style `pseudo-address' was specified.  */
 213 static long int flag_pseudo_start;
 214
 215 /* The difference between the old-style pseudo starting address and
 216    the number of bytes to skip.  */
 217 static long int pseudo_offset;
 218
 219 /* Function to format an address and optionally an additional parenthesized
 220    pseudo-address; it returns the formatted string.  */
 221 static const char *(*format_address) (/* long unsigned int */);
 222
 223 /* The number of input bytes to skip before formatting and writing.  */
 224 static off_t n_bytes_to_skip = 0;
 225
 226 /* When non-zero, MAX_BYTES_TO_FORMAT is the maximum number of bytes
 227    to be read and formatted.  Otherwise all input is formatted.  */
 228 static int limit_bytes_to_format = 0;
 229
 230 /* The maximum number of bytes that will be formatted.  This
 231    value is used only when LIMIT_BYTES_TO_FORMAT is non-zero.  */
 232 static off_t max_bytes_to_format;
 233
 234 /* When non-zero and two or more consecutive blocks are equal, format
 235    only the first block and output an asterisk alone on the following
 236    line to indicate that identical blocks have been elided.  */
 237 static int abbreviate_duplicate_blocks = 1;
 238
 239 /* An array of specs describing how to format each input block.  */
 240 static struct tspec *spec;
 241
 242 /* The number of format specs.  */
 243 static unsigned int n_specs;
 244
 245 /* The allocated length of SPEC.  */
 246 static unsigned int n_specs_allocated;
 247
 248 /* The number of input bytes formatted per output line.  It must be
 249    a multiple of the least common multiple of the sizes associated with
 250    the specified output types.  It should be as large as possible, but
 251    no larger than 16 -- unless specified with the -w option.  */
 252 static unsigned int bytes_per_block;
 253
 254 /* Human-readable representation of *file_list (for error messages).
 255    It differs from *file_list only when *file_list is "-".  */
 256 static char const *input_filename;
 257
 258 /* A NULL-terminated list of the file-arguments from the command line.
 259    If no file-arguments were specified, this variable is initialized
 260    to { "-", NULL }.  */
 261 static char const *const *file_list;
 262
 263 /* The input stream associated with the current file.  */
 264 static FILE *in_stream;
 265
 266 /* If non-zero, at least one of the files we read was standard input.  */
 267 static int have_read_stdin;
 268
 269 #define LONGEST_INTEGRAL_TYPE long int
 270
 271 #define MAX_INTEGRAL_TYPE_SIZE sizeof(LONGEST_INTEGRAL_TYPE)
 272 static enum size_spec integral_type_size[MAX_INTEGRAL_TYPE_SIZE + 1];
 273
 274 #define MAX_FP_TYPE_SIZE sizeof(LONG_DOUBLE)
 275 static enum size_spec fp_type_size[MAX_FP_TYPE_SIZE + 1];
 276
 277 /* If non-zero, display usage information and exit.  */
 278 static int show_help;
 279
 280 /* If non-zero, print the version on standard output then exit.  */
 281 static int show_version;
 282
 283 static struct option const long_options[] =
 284 {
 285   /* POSIX options.  */
 286   {"skip-bytes", required_argument, NULL, 'j'},
 287   {"address-radix", required_argument, NULL, 'A'},
 288   {"read-bytes", required_argument, NULL, 'N'},
 289   {"format", required_argument, NULL, 't'},
 290   {"output-duplicates", no_argument, NULL, 'v'},
 291
 292   /* non-POSIX options.  */
 293   {"strings", optional_argument, NULL, 's'},
 294   {"traditional", no_argument, NULL, 'B'},
 295   {"width", optional_argument, NULL, 'w'},
 296   {"help", no_argument, &show_help, 1},
 297   {"version", no_argument, &show_version, 1},
 298   {NULL, 0, NULL, 0}
 299 };
 300
 301 static void
 302 usage (status)
 303      int status;
 304 {
 305   if (status != 0)
 306     fprintf (stderr, "Try `%s --help' for more information.\n",
 307              program_name);
 308   else
 309     {
 310       printf ("\
 311 Usage: %s [OPTION]... [FILE]...\n\
 312   or:  %s --traditional [FILE] [[+]OFFSET [[+]LABEL]]\n\
 313 ",
 314               program_name, program_name);
 315       printf ("\
 316 \n\
 317   -A, --address-radix=RADIX   decide how file offsets are printed\n\
 318   -N, --read-bytes=BYTES      limit dump to BYTES input bytes per file\n\
 319   -j, --skip-bytes=BYTES      skip BYTES input bytes first on each file\n\
 320   -s, --strings[=BYTES]       output strings of at least BYTES graphic chars\n\
 321   -t, --format=TYPE           select output format or formats\n\
 322   -v, --output-duplicates     do not use * to mark line suppression\n\
 323   -w, --width[=BYTES]         output BYTES bytes per output line\n\
 324       --help                  display this help and exit\n\
 325       --traditional           accept arguments in pre-POSIX form\n\
 326       --version               output version information and exit\n\
 327 \n\
 328 Pre-POSIX format specifications may be intermixed, they accumulate:\n\
 329   -a   same as -t a,  select named characters\n\
 330   -b   same as -t oC, select octal bytes\n\
 331   -c   same as -t c,  select ASCII characters or backslash escapes\n\
 332   -d   same as -t u2, select unsigned decimal shorts\n\
 333   -f   same as -t fF, select floats\n\
 334   -h   same as -t x2, select hexadecimal shorts\n\
 335   -i   same as -t d2, select decimal shorts\n\
 336   -l   same as -t d4, select decimal longs\n\
 337   -o   same as -t o2, select octal shorts\n\
 338   -x   same as -t x2, select hexadecimal shorts\n\
 339 ");
 340       printf ("\
 341 \n\
 342 For older syntax (second call format), OFFSET means -j OFFSET.  LABEL\n\
 343 is the pseudo-address at first byte printed, incremented when dump is\n\
 344 progressing.  For OFFSET and LABEL, a 0x or 0X prefix indicates\n\
 345 hexadecimal, suffixes maybe . for octal and b multiply by 512.\n\
 346 \n\
 347 TYPE is made up of one or more of these specifications:\n\
 348 \n\
 349   a          named character\n\
 350   c          ASCII character or backslash escape\n\
 351   d[SIZE]    signed decimal, SIZE bytes per integer\n\
 352   f[SIZE]    floating point, SIZE bytes per integer\n\
 353   o[SIZE]    octal, SIZE bytes per integer\n\
 354   u[SIZE]    unsigned decimal, SIZE bytes per integer\n\
 355   x[SIZE]    hexadecimal, SIZE bytes per integer\n\
 356 \n\
 357 SIZE is a number.  For TYPE in doux, SIZE may also be C for\n\
 358 sizeof(char), S for sizeof(short), I for sizeof(int) or L for\n\
 359 sizeof(long).  If TYPE is f, SIZE may also be F for sizeof(float), D\n\
 360 for sizeof(double) or L for sizeof(long double).\n\
 361 \n\
 362 RADIX is d for decimal, o for octal, x for hexadecimal or n for none.\n\
 363 BYTES is hexadecimal with 0x or 0X prefix, it is multiplied by 512\n\
 364 with b suffix, by 1024 with k and by 1048576 with m.  -s without a\n\
 365 number implies 3.  -w without a number implies 32.  By default, od\n\
 366 uses -A o -t d2 -w 16.  With no FILE, or when FILE is -, read standard\n\
 367 input.\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       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   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   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 (index (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, bytes_per_block);
1405           err |= read_block (n_needed, block[idx], &n_bytes_read);
1406           if (n_bytes_read < bytes_per_block)
1407             break;
1408           assert (n_bytes_read == bytes_per_block);
1409           write_block (current_offset, n_bytes_read,
1410                        block[!idx], block[idx]);
1411           current_offset += n_bytes_read;
1412           idx = !idx;
1413         }
1414     }
1415   else
1416     {
1417       while (1)
1418         {
1419           err |= read_block (bytes_per_block, block[idx], &n_bytes_read);
1420           if (n_bytes_read < bytes_per_block)
1421             break;
1422           assert (n_bytes_read == bytes_per_block);
1423           write_block (current_offset, n_bytes_read,
1424                        block[!idx], block[idx]);
1425           current_offset += n_bytes_read;
1426           idx = !idx;
1427         }
1428     }
1429
1430   if (n_bytes_read > 0)
1431     {
1432       int l_c_m;
1433       size_t bytes_to_write;
1434
1435       l_c_m = get_lcm ();
1436
1437       /* Make bytes_to_write the smallest multiple of l_c_m that
1438          is at least as large as n_bytes_read.  */
1439       bytes_to_write = l_c_m * (int) ((n_bytes_read + l_c_m - 1) / l_c_m);
1440
1441       memset (block[idx] + n_bytes_read, 0, bytes_to_write - n_bytes_read);
1442       write_block (current_offset, bytes_to_write,
1443                    block[!idx], block[idx]);
1444       current_offset += n_bytes_read;
1445     }
1446
1447   if (output_address_fmt_string != NULL)
1448     printf ("%s\n", format_address (current_offset));
1449
1450   if (limit_bytes_to_format && current_offset > end_offset)
1451     err |= check_and_close ();
1452
1453   return err;
1454 }
1455
1456 /* STRINGS mode.  Find each "string constant" in the input.
1457    A string constant is a run of at least `string_min' ASCII
1458    graphic (or formatting) characters terminated by a null.
1459    Based on a function written by Richard Stallman for a
1460    pre-POSIX version of od.  Return non-zero if an error
1461    occurs.  Otherwise, return zero.  */
1462
1463 static int
1464 dump_strings ()
1465 {
1466   int bufsize = MAX (100, string_min);
1467   char *buf = xmalloc (bufsize);
1468   off_t address = n_bytes_to_skip;
1469   int err;
1470
1471   err = 0;
1472   while (1)
1473     {
1474       int i;
1475       int c;
1476
1477       /* See if the next `string_min' chars are all printing chars.  */
1478     tryline:
1479
1480       if (limit_bytes_to_format
1481           && address >= (n_bytes_to_skip + max_bytes_to_format - string_min))
1482         break;
1483
1484       for (i = 0; i < string_min; i++)
1485         {
1486           err |= read_char (&c);
1487           address++;
1488           if (c < 0)
1489             {
1490               free (buf);
1491               return err;
1492             }
1493           if (!ISPRINT (c))
1494             /* Found a non-printing.  Try again starting with next char.  */
1495             goto tryline;
1496           buf[i] = c;
1497         }
1498
1499       /* We found a run of `string_min' printable characters.
1500          Now see if it is terminated with a null byte.  */
1501       while (!limit_bytes_to_format
1502              || address < n_bytes_to_skip + max_bytes_to_format)
1503         {
1504           if (i == bufsize)
1505             {
1506               bufsize = 1 + 3 * bufsize / 2;
1507               buf = xrealloc (buf, bufsize);
1508             }
1509           err |= read_char (&c);
1510           address++;
1511           if (c < 0)
1512             {
1513               free (buf);
1514               return err;
1515             }
1516           if (c == '\0')
1517             break;              /* It is; print this string.  */
1518           if (!ISPRINT (c))
1519             goto tryline;       /* It isn't; give up on this string.  */
1520           buf[i++] = c;         /* String continues; store it all.  */
1521         }
1522
1523       /* If we get here, the string is all printable and null-terminated,
1524          so print it.  It is all in `buf' and `i' is its length.  */
1525       buf[i] = 0;
1526       if (output_address_fmt_string != NULL)
1527         {
1528           printf ("%s ", format_address (address - i - 1));
1529         }
1530       for (i = 0; (c = buf[i]); i++)
1531         {
1532           switch (c)
1533             {
1534             case '\007':
1535               fputs ("\\a", stdout);
1536               break;
1537
1538             case '\b':
1539               fputs ("\\b", stdout);
1540               break;
1541
1542             case '\f':
1543               fputs ("\\f", stdout);
1544               break;
1545
1546             case '\n':
1547               fputs ("\\n", stdout);
1548               break;
1549
1550             case '\r':
1551               fputs ("\\r", stdout);
1552               break;
1553
1554             case '\t':
1555               fputs ("\\t", stdout);
1556               break;
1557
1558             case '\v':
1559               fputs ("\\v", stdout);
1560               break;
1561
1562             default:
1563               putc (c, stdout);
1564             }
1565         }
1566       putchar ('\n');
1567     }
1568
1569   /* We reach this point only if we search through
1570      (max_bytes_to_format - string_min) bytes before reachine EOF.  */
1571
1572   free (buf);
1573
1574   err |= check_and_close ();
1575   return err;
1576 }
1577
1578 int
1579 main (argc, argv)
1580      int argc;
1581      char **argv;
1582 {
1583   int c;
1584   int n_files;
1585   int i;
1586   unsigned int l_c_m;
1587   unsigned int address_pad_len;
1588   unsigned long int desired_width;
1589   int width_specified = 0;
1590   int err;
1591
1592   /* The old-style `pseudo starting address' to be printed in parentheses
1593      after any true address.  */
1594   long int pseudo_start;
1595
1596 #ifdef lint  /* Suppress `used before initialized' warning.  */
1597   pseudo_start = 0;
1598 #endif
1599
1600   program_name = argv[0];
1601   err = 0;
1602
1603   for (i = 0; i <= MAX_INTEGRAL_TYPE_SIZE; i++)
1604     integral_type_size[i] = NO_SIZE;
1605
1606   integral_type_size[sizeof (char)] = CHAR;
1607   integral_type_size[sizeof (short int)] = SHORT;
1608   integral_type_size[sizeof (int)] = INT;
1609   integral_type_size[sizeof (long int)] = LONG;
1610
1611   for (i = 0; i <= MAX_FP_TYPE_SIZE; i++)
1612     fp_type_size[i] = NO_SIZE;
1613
1614   fp_type_size[sizeof (float)] = FLOAT_SINGLE;
1615   /* The array entry for `double' is filled in after that for LONG_DOUBLE
1616      so that if `long double' is the same type or if long double isn't
1617      supported FLOAT_LONG_DOUBLE will never be used.  */
1618   fp_type_size[sizeof (LONG_DOUBLE)] = FLOAT_LONG_DOUBLE;
1619   fp_type_size[sizeof (double)] = FLOAT_DOUBLE;
1620
1621   n_specs = 0;
1622   n_specs_allocated = 5;
1623   spec = (struct tspec *) xmalloc (n_specs_allocated * sizeof (struct tspec));
1624
1625   output_address_fmt_string = "%07o";
1626   format_address = format_address_std;
1627   address_pad_len = 7;
1628   flag_dump_strings = 0;
1629
1630   while ((c = getopt_long (argc, argv, "abcdfhilos::xw::A:j:N:t:v",
1631                            long_options, (int *) 0))
1632          != EOF)
1633     {
1634       unsigned long int tmp;
1635       strtoul_error s_err;
1636
1637       switch (c)
1638         {
1639         case 0:
1640           break;
1641
1642         case 'A':
1643           switch (optarg[0])
1644             {
1645             case 'd':
1646               output_address_fmt_string = "%07d";
1647               format_address = format_address_std;
1648               address_pad_len = 7;
1649               break;
1650             case 'o':
1651               output_address_fmt_string = "%07o";
1652               format_address = format_address_std;
1653               address_pad_len = 7;
1654               break;
1655             case 'x':
1656               output_address_fmt_string = "%06x";
1657               format_address = format_address_std;
1658               address_pad_len = 6;
1659               break;
1660             case 'n':
1661               output_address_fmt_string = NULL;
1662               format_address = format_address_none;
1663               address_pad_len = 0;
1664               break;
1665             default:
1666               error (2, 0,
1667                      "invalid output address radix `%c'; it must be one character from [doxn]",
1668                      optarg[0]);
1669               break;
1670             }
1671           break;
1672
1673         case 'j':
1674           s_err = xstrtoul (optarg, NULL, 0, &tmp, "bkm");
1675           n_bytes_to_skip = tmp;
1676           if (s_err != LONGINT_OK)
1677             STRTOL_FATAL_ERROR (optarg, "skip argument", s_err);
1678           break;
1679
1680         case 'N':
1681           limit_bytes_to_format = 1;
1682
1683           s_err = xstrtoul (optarg, NULL, 0, &max_bytes_to_format, "bkm");
1684           if (s_err != LONGINT_OK)
1685             STRTOL_FATAL_ERROR (optarg, "limit argument", s_err);
1686           break;
1687
1688         case 's':
1689           if (optarg == NULL)
1690             string_min = 3;
1691           else
1692             {
1693               s_err = xstrtoul (optarg, NULL, 0, &string_min, "bkm");
1694               if (s_err != LONGINT_OK)
1695                 STRTOL_FATAL_ERROR (optarg, "minimum string length", s_err);
1696             }
1697           ++flag_dump_strings;
1698           break;
1699
1700         case 't':
1701           if (decode_format_string (optarg))
1702             error (2, 0, "invalid type string `%s'", optarg);
1703           break;
1704
1705         case 'v':
1706           abbreviate_duplicate_blocks = 0;
1707           break;
1708
1709         case 'B':
1710           traditional = 1;
1711           break;
1712
1713           /* The next several cases map the old, pre-POSIX format
1714              specification options to the corresponding POSIX format
1715              specs.  GNU od accepts any combination of old- and
1716              new-style options.  Format specification options accumulate.  */
1717
1718 #define CASE_OLD_ARG(old_char,new_string)               \
1719         case old_char:                                  \
1720           {                                             \
1721             int tmp;                                    \
1722             tmp = decode_format_string (new_string);    \
1723             assert (tmp == 0);                          \
1724           }                                             \
1725           break
1726
1727           CASE_OLD_ARG ('a', "a");
1728           CASE_OLD_ARG ('b', "oC");
1729           CASE_OLD_ARG ('c', "c");
1730           CASE_OLD_ARG ('d', "u2");
1731           CASE_OLD_ARG ('f', "fF");
1732           CASE_OLD_ARG ('h', "x2");
1733           CASE_OLD_ARG ('i', "d2");
1734           CASE_OLD_ARG ('l', "d4");
1735           CASE_OLD_ARG ('o', "o2");
1736           CASE_OLD_ARG ('x', "x2");
1737
1738 #undef CASE_OLD_ARG
1739
1740         case 'w':
1741           width_specified = 1;
1742           if (optarg == NULL)
1743             {
1744               desired_width = 32;
1745             }
1746           else
1747             {
1748               s_err = xstrtoul (optarg, NULL, 10, &desired_width, NULL);
1749               if (s_err != LONGINT_OK)
1750                 STRTOL_FATAL_ERROR (optarg, "width specification", s_err);
1751             }
1752           break;
1753
1754         default:
1755           usage (1);
1756           break;
1757         }
1758     }
1759
1760   if (show_version)
1761     {
1762       printf ("od - %s\n", version_string);
1763       exit (0);
1764     }
1765
1766   if (show_help)
1767     usage (0);
1768
1769   if (flag_dump_strings && n_specs > 0)
1770     error (2, 0, "no type may be specified when dumping strings");
1771
1772   n_files = argc - optind;
1773
1774   /* If the --backward-compatible option is used, there may be from
1775      0 to 3 remaining command line arguments;  handle each case
1776      separately.
1777         od [file] [[+]offset[.][b] [[+]label[.][b]]]
1778      The offset and pseudo_start have the same syntax.  */
1779
1780   if (traditional)
1781     {
1782       off_t offset;
1783
1784       if (n_files == 1)
1785         {
1786           if ((offset = parse_old_offset (argv[optind])) >= 0)
1787             {
1788               n_bytes_to_skip = offset;
1789               --n_files;
1790               ++argv;
1791             }
1792         }
1793       else if (n_files == 2)
1794         {
1795           off_t o1, o2;
1796           if ((o1 = parse_old_offset (argv[optind])) >= 0
1797               && (o2 = parse_old_offset (argv[optind + 1])) >= 0)
1798             {
1799               n_bytes_to_skip = o1;
1800               flag_pseudo_start = 1;
1801               pseudo_start = o2;
1802               argv += 2;
1803               n_files -= 2;
1804             }
1805           else if ((o2 = parse_old_offset (argv[optind + 1])) >= 0)
1806             {
1807               n_bytes_to_skip = o2;
1808               --n_files;
1809               argv[optind + 1] = argv[optind];
1810               ++argv;
1811             }
1812           else
1813             {
1814               error (0, 0,
1815                      "invalid second operand in compatibility mode `%s'",
1816                      argv[optind + 1]);
1817               usage (1);
1818             }
1819         }
1820       else if (n_files == 3)
1821         {
1822           off_t o1, o2;
1823           if ((o1 = parse_old_offset (argv[optind + 1])) >= 0
1824               && (o2 = parse_old_offset (argv[optind + 2])) >= 0)
1825             {
1826               n_bytes_to_skip = o1;
1827               flag_pseudo_start = 1;
1828               pseudo_start = o2;
1829               argv[optind + 2] = argv[optind];
1830               argv += 2;
1831               n_files -= 2;
1832             }
1833           else
1834             {
1835               error (0, 0,
1836               "in compatibility mode the last 2 arguments must be offsets");
1837               usage (1);
1838             }
1839         }
1840       else
1841         {
1842           error (0, 0,
1843              "in compatibility mode there may be no more than 3 arguments");
1844           usage (1);
1845         }
1846
1847       if (flag_pseudo_start)
1848         {
1849           static char buf[10];
1850
1851           if (output_address_fmt_string == NULL)
1852             {
1853               output_address_fmt_string = "(%07o)";
1854               format_address = format_address_std;
1855             }
1856           else
1857             {
1858               sprintf (buf, "%s (%s)",
1859                        output_address_fmt_string,
1860                        output_address_fmt_string);
1861               output_address_fmt_string = buf;
1862               format_address = format_address_label;
1863             }
1864         }
1865     }
1866
1867   assert (address_pad_len <= MAX_ADDRESS_LENGTH);
1868   for (i = 0; i < address_pad_len; i++)
1869     address_pad[i] = ' ';
1870   address_pad[address_pad_len] = '\0';
1871
1872   if (n_specs == 0)
1873     {
1874       int d_err = decode_one_format ("o2", NULL, &(spec[0]));
1875
1876       assert (d_err == 0);
1877       n_specs = 1;
1878     }
1879
1880   if (n_files > 0)
1881     file_list = (char const *const *) &argv[optind];
1882   else
1883     {
1884       /* If no files were listed on the command line, set up the
1885          global array FILE_LIST so that it contains the null-terminated
1886          list of one name: "-".  */
1887       static char const *const default_file_list[] = {"-", NULL};
1888
1889       file_list = default_file_list;
1890     }
1891
1892   err |= skip (n_bytes_to_skip);
1893   if (in_stream == NULL)
1894     goto cleanup;
1895
1896   pseudo_offset = (flag_pseudo_start ? pseudo_start - n_bytes_to_skip : 0);
1897
1898   /* Compute output block length.  */
1899   l_c_m = get_lcm ();
1900
1901   if (width_specified)
1902     {
1903       if (desired_width != 0 && desired_width % l_c_m == 0)
1904         bytes_per_block = desired_width;
1905       else
1906         {
1907           error (0, 0, "warning: invalid width %lu; using %d instead",
1908                  desired_width, l_c_m);
1909           bytes_per_block = l_c_m;
1910         }
1911     }
1912   else
1913     {
1914       if (l_c_m < DEFAULT_BYTES_PER_BLOCK)
1915         bytes_per_block = l_c_m * (int) (DEFAULT_BYTES_PER_BLOCK / l_c_m);
1916       else
1917         bytes_per_block = l_c_m;
1918     }
1919
1920 #ifdef DEBUG
1921   for (i = 0; i < n_specs; i++)
1922     {
1923       printf ("%d: fmt=\"%s\" width=%d\n",
1924               i, spec[i].fmt_string, width_bytes[spec[i].size]);
1925     }
1926 #endif
1927
1928   err |= (flag_dump_strings ? dump_strings () : dump ());
1929
1930 cleanup:;
1931
1932   if (have_read_stdin && fclose (stdin) == EOF)
1933     error (2, errno, "standard input");
1934
1935   if (fclose (stdout) == EOF)
1936     error (2, errno, "write error");
1937
1938   exit (err);
1939 }