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., 59 Temple Place - Suite 330, Boston, MA 02111-1307, 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       while (1)
1401         {
1402           size_t n_needed;
1403           if (current_offset >= end_offset)
1404             {
1405               n_bytes_read = 0;
1406               break;
1407             }
1408           n_needed = MIN (end_offset - current_offset,
1409                           (off_t) bytes_per_block);
1410           err |= read_block (n_needed, block[idx], &n_bytes_read);
1411           if (n_bytes_read < bytes_per_block)
1412             break;
1413           assert (n_bytes_read == bytes_per_block);
1414           write_block (current_offset, n_bytes_read,
1415                        block[!idx], block[idx]);
1416           current_offset += n_bytes_read;
1417           idx = !idx;
1418         }
1419     }
1420   else
1421     {
1422       while (1)
1423         {
1424           err |= read_block (bytes_per_block, block[idx], &n_bytes_read);
1425           if (n_bytes_read < bytes_per_block)
1426             break;
1427           assert (n_bytes_read == bytes_per_block);
1428           write_block (current_offset, n_bytes_read,
1429                        block[!idx], block[idx]);
1430           current_offset += n_bytes_read;
1431           idx = !idx;
1432         }
1433     }
1434
1435   if (n_bytes_read > 0)
1436     {
1437       int l_c_m;
1438       size_t bytes_to_write;
1439
1440       l_c_m = get_lcm ();
1441
1442       /* Make bytes_to_write the smallest multiple of l_c_m that
1443          is at least as large as n_bytes_read.  */
1444       bytes_to_write = l_c_m * (int) ((n_bytes_read + l_c_m - 1) / l_c_m);
1445
1446       memset (block[idx] + n_bytes_read, 0, bytes_to_write - n_bytes_read);
1447       write_block (current_offset, bytes_to_write,
1448                    block[!idx], block[idx]);
1449       current_offset += n_bytes_read;
1450     }
1451
1452   if (output_address_fmt_string != NULL)
1453     printf ("%s\n", format_address (current_offset));
1454
1455   if (limit_bytes_to_format && current_offset > end_offset)
1456     err |= check_and_close ();
1457
1458   return err;
1459 }
1460
1461 /* STRINGS mode.  Find each "string constant" in the input.
1462    A string constant is a run of at least `string_min' ASCII
1463    graphic (or formatting) characters terminated by a null.
1464    Based on a function written by Richard Stallman for a
1465    pre-POSIX version of od.  Return non-zero if an error
1466    occurs.  Otherwise, return zero.  */
1467
1468 static int
1469 dump_strings ()
1470 {
1471   size_t bufsize = MAX (100, string_min);
1472   char *buf = xmalloc (bufsize);
1473   off_t address = n_bytes_to_skip;
1474   int err;
1475
1476   err = 0;
1477   while (1)
1478     {
1479       unsigned int i;
1480       int c;
1481
1482       /* See if the next `string_min' chars are all printing chars.  */
1483     tryline:
1484
1485       if (limit_bytes_to_format
1486           && address >= (n_bytes_to_skip + max_bytes_to_format - string_min))
1487         break;
1488
1489       for (i = 0; i < string_min; i++)
1490         {
1491           err |= read_char (&c);
1492           address++;
1493           if (c < 0)
1494             {
1495               free (buf);
1496               return err;
1497             }
1498           if (!ISPRINT (c))
1499             /* Found a non-printing.  Try again starting with next char.  */
1500             goto tryline;
1501           buf[i] = c;
1502         }
1503
1504       /* We found a run of `string_min' printable characters.
1505          Now see if it is terminated with a null byte.  */
1506       while (!limit_bytes_to_format
1507              || address < n_bytes_to_skip + max_bytes_to_format)
1508         {
1509           if (i == bufsize)
1510             {
1511               bufsize = 1 + 3 * bufsize / 2;
1512               buf = xrealloc (buf, bufsize);
1513             }
1514           err |= read_char (&c);
1515           address++;
1516           if (c < 0)
1517             {
1518               free (buf);
1519               return err;
1520             }
1521           if (c == '\0')
1522             break;              /* It is; print this string.  */
1523           if (!ISPRINT (c))
1524             goto tryline;       /* It isn't; give up on this string.  */
1525           buf[i++] = c;         /* String continues; store it all.  */
1526         }
1527
1528       /* If we get here, the string is all printable and null-terminated,
1529          so print it.  It is all in `buf' and `i' is its length.  */
1530       buf[i] = 0;
1531       if (output_address_fmt_string != NULL)
1532         {
1533           printf ("%s ", format_address (address - i - 1));
1534         }
1535       for (i = 0; (c = buf[i]); i++)
1536         {
1537           switch (c)
1538             {
1539             case '\007':
1540               fputs ("\\a", stdout);
1541               break;
1542
1543             case '\b':
1544               fputs ("\\b", stdout);
1545               break;
1546
1547             case '\f':
1548               fputs ("\\f", stdout);
1549               break;
1550
1551             case '\n':
1552               fputs ("\\n", stdout);
1553               break;
1554
1555             case '\r':
1556               fputs ("\\r", stdout);
1557               break;
1558
1559             case '\t':
1560               fputs ("\\t", stdout);
1561               break;
1562
1563             case '\v':
1564               fputs ("\\v", stdout);
1565               break;
1566
1567             default:
1568               putc (c, stdout);
1569             }
1570         }
1571       putchar ('\n');
1572     }
1573
1574   /* We reach this point only if we search through
1575      (max_bytes_to_format - string_min) bytes before reachine EOF.  */
1576
1577   free (buf);
1578
1579   err |= check_and_close ();
1580   return err;
1581 }
1582
1583 int
1584 main (argc, argv)
1585      int argc;
1586      char **argv;
1587 {
1588   int c;
1589   int n_files;
1590   unsigned int i;
1591   unsigned int l_c_m;
1592   unsigned int address_pad_len;
1593   unsigned long int desired_width;
1594   int width_specified = 0;
1595   int err;
1596
1597   /* The old-style `pseudo starting address' to be printed in parentheses
1598      after any true address.  */
1599   long int pseudo_start;
1600
1601 #ifdef lint  /* Suppress `used before initialized' warning.  */
1602   pseudo_start = 0;
1603 #endif
1604
1605   program_name = argv[0];
1606   err = 0;
1607
1608   for (i = 0; i <= MAX_INTEGRAL_TYPE_SIZE; i++)
1609     integral_type_size[i] = NO_SIZE;
1610
1611   integral_type_size[sizeof (char)] = CHAR;
1612   integral_type_size[sizeof (short int)] = SHORT;
1613   integral_type_size[sizeof (int)] = INT;
1614   integral_type_size[sizeof (long int)] = LONG;
1615
1616   for (i = 0; i <= MAX_FP_TYPE_SIZE; i++)
1617     fp_type_size[i] = NO_SIZE;
1618
1619   fp_type_size[sizeof (float)] = FLOAT_SINGLE;
1620   /* The array entry for `double' is filled in after that for LONG_DOUBLE
1621      so that if `long double' is the same type or if long double isn't
1622      supported FLOAT_LONG_DOUBLE will never be used.  */
1623   fp_type_size[sizeof (LONG_DOUBLE)] = FLOAT_LONG_DOUBLE;
1624   fp_type_size[sizeof (double)] = FLOAT_DOUBLE;
1625
1626   n_specs = 0;
1627   n_specs_allocated = 5;
1628   spec = (struct tspec *) xmalloc (n_specs_allocated * sizeof (struct tspec));
1629
1630   output_address_fmt_string = "%07o";
1631   format_address = format_address_std;
1632   address_pad_len = 7;
1633   flag_dump_strings = 0;
1634
1635   while ((c = getopt_long (argc, argv, "abcdfhilos::xw::A:j:N:t:v",
1636                            long_options, (int *) 0))
1637          != EOF)
1638     {
1639       unsigned long int tmp;
1640       enum strtol_error s_err;
1641
1642       switch (c)
1643         {
1644         case 0:
1645           break;
1646
1647         case 'A':
1648           switch (optarg[0])
1649             {
1650             case 'd':
1651               output_address_fmt_string = "%07d";
1652               format_address = format_address_std;
1653               address_pad_len = 7;
1654               break;
1655             case 'o':
1656               output_address_fmt_string = "%07o";
1657               format_address = format_address_std;
1658               address_pad_len = 7;
1659               break;
1660             case 'x':
1661               output_address_fmt_string = "%06x";
1662               format_address = format_address_std;
1663               address_pad_len = 6;
1664               break;
1665             case 'n':
1666               output_address_fmt_string = NULL;
1667               format_address = format_address_none;
1668               address_pad_len = 0;
1669               break;
1670             default:
1671               error (2, 0,
1672                      _("invalid output address radix `%c'; it must be one character from [doxn]"),
1673                      optarg[0]);
1674               break;
1675             }
1676           break;
1677
1678         case 'j':
1679           s_err = xstrtoul (optarg, NULL, 0, &tmp, "bkm");
1680           n_bytes_to_skip = tmp;
1681           if (s_err != LONGINT_OK)
1682             STRTOL_FATAL_ERROR (optarg, _("skip argument"), s_err);
1683           break;
1684
1685         case 'N':
1686           limit_bytes_to_format = 1;
1687
1688           /* FIXME: if off_t is long long and that's an 8-byte type,
1689              use xstrtouq here.  */
1690           s_err = xstrtoul (optarg, NULL, 0, &tmp, "bkm");
1691           max_bytes_to_format = tmp;
1692           if (s_err != LONGINT_OK)
1693             STRTOL_FATAL_ERROR (optarg, _("limit argument"), s_err);
1694
1695           if (tmp > OFF_T_MAX)
1696             error (2, 0, _("specified number of bytes `%s' is larger than \
1697 the maximum\nrepresentable value of type off_t"), optarg);
1698           break;
1699
1700         case 's':
1701           if (optarg == NULL)
1702             string_min = 3;
1703           else
1704             {
1705               s_err = xstrtoul (optarg, NULL, 0, &string_min, "bkm");
1706               if (s_err != LONGINT_OK)
1707                 STRTOL_FATAL_ERROR (optarg, _("minimum string length"), s_err);
1708             }
1709           ++flag_dump_strings;
1710           break;
1711
1712         case 't':
1713           if (decode_format_string (optarg))
1714             error (2, 0, _("invalid type string `%s'"), optarg);
1715           break;
1716
1717         case 'v':
1718           abbreviate_duplicate_blocks = 0;
1719           break;
1720
1721         case 'B':
1722           traditional = 1;
1723           break;
1724
1725           /* The next several cases map the old, pre-POSIX format
1726              specification options to the corresponding POSIX format
1727              specs.  GNU od accepts any combination of old- and
1728              new-style options.  Format specification options accumulate.  */
1729
1730 #define CASE_OLD_ARG(old_char,new_string)               \
1731         case old_char:                                  \
1732           {                                             \
1733             int tmp;                                    \
1734             tmp = decode_format_string (new_string);    \
1735             assert (tmp == 0);                          \
1736           }                                             \
1737           break
1738
1739           CASE_OLD_ARG ('a', "a");
1740           CASE_OLD_ARG ('b', "oC");
1741           CASE_OLD_ARG ('c', "c");
1742           CASE_OLD_ARG ('d', "u2");
1743           CASE_OLD_ARG ('f', "fF");
1744           CASE_OLD_ARG ('h', "x2");
1745           CASE_OLD_ARG ('i', "d2");
1746           CASE_OLD_ARG ('l', "d4");
1747           CASE_OLD_ARG ('o', "o2");
1748           CASE_OLD_ARG ('x', "x2");
1749
1750 #undef CASE_OLD_ARG
1751
1752         case 'w':
1753           width_specified = 1;
1754           if (optarg == NULL)
1755             {
1756               desired_width = 32;
1757             }
1758           else
1759             {
1760               s_err = xstrtoul (optarg, NULL, 10, &desired_width, NULL);
1761               if (s_err != LONGINT_OK)
1762                 STRTOL_FATAL_ERROR (optarg, _("width specification"), s_err);
1763             }
1764           break;
1765
1766         default:
1767           usage (1);
1768           break;
1769         }
1770     }
1771
1772   if (show_version)
1773     {
1774       printf ("od - %s\n", version_string);
1775       exit (0);
1776     }
1777
1778   if (show_help)
1779     usage (0);
1780
1781   if (flag_dump_strings && n_specs > 0)
1782     error (2, 0, _("no type may be specified when dumping strings"));
1783
1784   n_files = argc - optind;
1785
1786   /* If the --backward-compatible option is used, there may be from
1787      0 to 3 remaining command line arguments;  handle each case
1788      separately.
1789         od [file] [[+]offset[.][b] [[+]label[.][b]]]
1790      The offset and pseudo_start have the same syntax.  */
1791
1792   if (traditional)
1793     {
1794       off_t offset;
1795
1796       if (n_files == 1)
1797         {
1798           if ((offset = parse_old_offset (argv[optind])) >= 0)
1799             {
1800               n_bytes_to_skip = offset;
1801               --n_files;
1802               ++argv;
1803             }
1804         }
1805       else if (n_files == 2)
1806         {
1807           off_t o1, o2;
1808           if ((o1 = parse_old_offset (argv[optind])) >= 0
1809               && (o2 = parse_old_offset (argv[optind + 1])) >= 0)
1810             {
1811               n_bytes_to_skip = o1;
1812               flag_pseudo_start = 1;
1813               pseudo_start = o2;
1814               argv += 2;
1815               n_files -= 2;
1816             }
1817           else if ((o2 = parse_old_offset (argv[optind + 1])) >= 0)
1818             {
1819               n_bytes_to_skip = o2;
1820               --n_files;
1821               argv[optind + 1] = argv[optind];
1822               ++argv;
1823             }
1824           else
1825             {
1826               error (0, 0,
1827                      _("invalid second operand in compatibility mode `%s'"),
1828                      argv[optind + 1]);
1829               usage (1);
1830             }
1831         }
1832       else if (n_files == 3)
1833         {
1834           off_t o1, o2;
1835           if ((o1 = parse_old_offset (argv[optind + 1])) >= 0
1836               && (o2 = parse_old_offset (argv[optind + 2])) >= 0)
1837             {
1838               n_bytes_to_skip = o1;
1839               flag_pseudo_start = 1;
1840               pseudo_start = o2;
1841               argv[optind + 2] = argv[optind];
1842               argv += 2;
1843               n_files -= 2;
1844             }
1845           else
1846             {
1847               error (0, 0,
1848               _("in compatibility mode the last 2 arguments must be offsets"));
1849               usage (1);
1850             }
1851         }
1852       else
1853         {
1854           error (0, 0,
1855              _("in compatibility mode there may be no more than 3 arguments"));
1856           usage (1);
1857         }
1858
1859       if (flag_pseudo_start)
1860         {
1861           static char buf[10];
1862
1863           if (output_address_fmt_string == NULL)
1864             {
1865               output_address_fmt_string = "(%07o)";
1866               format_address = format_address_std;
1867             }
1868           else
1869             {
1870               sprintf (buf, "%s (%s)",
1871                        output_address_fmt_string,
1872                        output_address_fmt_string);
1873               output_address_fmt_string = buf;
1874               format_address = format_address_label;
1875             }
1876         }
1877     }
1878
1879   assert (address_pad_len <= MAX_ADDRESS_LENGTH);
1880   for (i = 0; i < address_pad_len; i++)
1881     address_pad[i] = ' ';
1882   address_pad[address_pad_len] = '\0';
1883
1884   if (n_specs == 0)
1885     {
1886       int d_err = decode_one_format ("o2", NULL, &(spec[0]));
1887
1888       assert (d_err == 0);
1889       n_specs = 1;
1890     }
1891
1892   if (n_files > 0)
1893     file_list = (char const *const *) &argv[optind];
1894   else
1895     {
1896       /* If no files were listed on the command line, set up the
1897          global array FILE_LIST so that it contains the null-terminated
1898          list of one name: "-".  */
1899       static char const *const default_file_list[] = {"-", NULL};
1900
1901       file_list = default_file_list;
1902     }
1903
1904   err |= skip (n_bytes_to_skip);
1905   if (in_stream == NULL)
1906     goto cleanup;
1907
1908   pseudo_offset = (flag_pseudo_start ? pseudo_start - n_bytes_to_skip : 0);
1909
1910   /* Compute output block length.  */
1911   l_c_m = get_lcm ();
1912
1913   if (width_specified)
1914     {
1915       if (desired_width != 0 && desired_width % l_c_m == 0)
1916         bytes_per_block = desired_width;
1917       else
1918         {
1919           error (0, 0, _("warning: invalid width %lu; using %d instead"),
1920                  desired_width, l_c_m);
1921           bytes_per_block = l_c_m;
1922         }
1923     }
1924   else
1925     {
1926       if (l_c_m < DEFAULT_BYTES_PER_BLOCK)
1927         bytes_per_block = l_c_m * (int) (DEFAULT_BYTES_PER_BLOCK / l_c_m);
1928       else
1929         bytes_per_block = l_c_m;
1930     }
1931
1932 #ifdef DEBUG
1933   for (i = 0; i < n_specs; i++)
1934     {
1935       printf (_("%d: fmt=\"%s\" width=%d\n"),
1936               i, spec[i].fmt_string, width_bytes[spec[i].size]);
1937     }
1938 #endif
1939
1940   err |= (flag_dump_strings ? dump_strings () : dump ());
1941
1942 cleanup:;
1943
1944   if (have_read_stdin && fclose (stdin) == EOF)
1945     error (2, errno, _("standard input"));
1946
1947   if (fclose (stdout) == EOF)
1948     error (2, errno, _("write error"));
1949
1950   exit (err);
1951 }