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 Foundation,
  16    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) (__P (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 (int status)
 302 {
 303   if (status != 0)
 304     fprintf (stderr, _("Try `%s --help' for more information.\n"),
 305              program_name);
 306   else
 307     {
 308       printf (_("\
 309 Usage: %s [OPTION]... [FILE]...\n\
 310   or:  %s --traditional [FILE] [[+]OFFSET [[+]LABEL]]\n\
 311 "),
 312               program_name, program_name);
 313       printf (_("\
 314 Write an unambiguous representation, octal bytes by default, of FILE\n\
 315 to standard output.  With no FILE, or when FILE is -, read standard input.\n\
 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       --traditional           accept arguments in pre-POSIX form\n\
 325       --help                  display this help and exit\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.\n\
 367 "));
 368     }
 369   exit (status);
 370 }
 371
 372 /* Compute the greatest common denominator of U and V
 373    using Euclid's algorithm.  */
 374
 375 static unsigned int
 376 gcd (unsigned int u, unsigned int v)
 377 {
 378   unsigned int t;
 379   while (v != 0)
 380     {
 381       t = u % v;
 382       u = v;
 383       v = t;
 384     }
 385   return u;
 386 }
 387
 388 /* Compute the least common multiple of U and V.  */
 389
 390 static unsigned int
 391 lcm (unsigned int u, unsigned int v)
 392 {
 393   unsigned int t = gcd (u, v);
 394   if (t == 0)
 395     return 0;
 396   return u * v / t;
 397 }
 398
 399 static void
 400 print_s_char (long unsigned int n_bytes, const char *block,
 401               const char *fmt_string)
 402 {
 403   int i;
 404   for (i = n_bytes; i > 0; i--)
 405     {
 406       int tmp = (unsigned) *(const unsigned char *) block;
 407       if (tmp > SCHAR_MAX)
 408         tmp -= SCHAR_MAX - SCHAR_MIN + 1;
 409       assert (tmp <= SCHAR_MAX);
 410       printf (fmt_string, tmp, (i == 1 ? '\n' : ' '));
 411       block += sizeof (unsigned char);
 412     }
 413 }
 414
 415 static void
 416 print_char (long unsigned int n_bytes, const char *block,
 417             const char *fmt_string)
 418 {
 419   int i;
 420   for (i = n_bytes; i > 0; i--)
 421     {
 422       unsigned int tmp = *(const unsigned char *) block;
 423       printf (fmt_string, tmp, (i == 1 ? '\n' : ' '));
 424       block += sizeof (unsigned char);
 425     }
 426 }
 427
 428 static void
 429 print_s_short (long unsigned int n_bytes, const char *block,
 430                const char *fmt_string)
 431 {
 432   int i;
 433   for (i = n_bytes / sizeof (unsigned short); i > 0; i--)
 434     {
 435       int tmp = (unsigned) *(const unsigned short *) block;
 436       if (tmp > SHRT_MAX)
 437         tmp -= SHRT_MAX - SHRT_MIN + 1;
 438       assert (tmp <= SHRT_MAX);
 439       printf (fmt_string, tmp, (i == 1 ? '\n' : ' '));
 440       block += sizeof (unsigned short);
 441     }
 442 }
 443 static void
 444 print_short (long unsigned int n_bytes, const char *block,
 445              const char *fmt_string)
 446 {
 447   int i;
 448   for (i = n_bytes / sizeof (unsigned short); i > 0; i--)
 449     {
 450       unsigned int tmp = *(const unsigned short *) block;
 451       printf (fmt_string, tmp, (i == 1 ? '\n' : ' '));
 452       block += sizeof (unsigned short);
 453     }
 454 }
 455
 456 static void
 457 print_int (long unsigned int n_bytes, const char *block,
 458            const char *fmt_string)
 459 {
 460   int i;
 461   for (i = n_bytes / sizeof (unsigned int); i > 0; i--)
 462     {
 463       unsigned int tmp = *(const unsigned int *) block;
 464       printf (fmt_string, tmp, (i == 1 ? '\n' : ' '));
 465       block += sizeof (unsigned int);
 466     }
 467 }
 468
 469 static void
 470 print_long (long unsigned int n_bytes, const char *block,
 471             const char *fmt_string)
 472 {
 473   int i;
 474   for (i = n_bytes / sizeof (unsigned long); i > 0; i--)
 475     {
 476       unsigned long tmp = *(const unsigned long *) block;
 477       printf (fmt_string, tmp, (i == 1 ? '\n' : ' '));
 478       block += sizeof (unsigned long);
 479     }
 480 }
 481
 482 static void
 483 print_float (long unsigned int n_bytes, const char *block,
 484              const char *fmt_string)
 485 {
 486   int i;
 487   for (i = n_bytes / sizeof (float); i > 0; i--)
 488     {
 489       float tmp = *(const float *) block;
 490       printf (fmt_string, tmp, (i == 1 ? '\n' : ' '));
 491       block += sizeof (float);
 492     }
 493 }
 494
 495 static void
 496 print_double (long unsigned int n_bytes, const char *block,
 497               const char *fmt_string)
 498 {
 499   int i;
 500   for (i = n_bytes / sizeof (double); i > 0; i--)
 501     {
 502       double tmp = *(const double *) block;
 503       printf (fmt_string, tmp, (i == 1 ? '\n' : ' '));
 504       block += sizeof (double);
 505     }
 506 }
 507
 508 #ifdef HAVE_LONG_DOUBLE
 509 static void
 510 print_long_double (long unsigned int n_bytes, const char *block,
 511                    const char *fmt_string)
 512 {
 513   int i;
 514   for (i = n_bytes / sizeof (LONG_DOUBLE); i > 0; i--)
 515     {
 516       LONG_DOUBLE tmp = *(const LONG_DOUBLE *) block;
 517       printf (fmt_string, tmp, (i == 1 ? '\n' : ' '));
 518       block += sizeof (LONG_DOUBLE);
 519     }
 520 }
 521
 522 #endif
 523
 524 static void
 525 print_named_ascii (long unsigned int n_bytes, const char *block,
 526                    const char *unused_fmt_string)
 527 {
 528   int i;
 529   for (i = n_bytes; i > 0; i--)
 530     {
 531       unsigned int c = *(const unsigned char *) block;
 532       unsigned int masked_c = (0x7f & c);
 533       const char *s;
 534       char buf[5];
 535
 536       if (masked_c == 127)
 537         s = "del";
 538       else if (masked_c <= 040)
 539         s = charname[masked_c];
 540       else
 541         {
 542           sprintf (buf, "  %c", masked_c);
 543           s = buf;
 544         }
 545
 546       printf ("%3s%c", s, (i == 1 ? '\n' : ' '));
 547       block += sizeof (unsigned char);
 548     }
 549 }
 550
 551 static void
 552 print_ascii (long unsigned int n_bytes, const char *block,
 553              const char *unused_fmt_string)
 554 {
 555   int i;
 556   for (i = n_bytes; i > 0; i--)
 557     {
 558       unsigned int c = *(const unsigned char *) block;
 559       const char *s;
 560       char buf[5];
 561
 562       switch (c)
 563         {
 564         case '\0':
 565           s = " \\0";
 566           break;
 567
 568         case '\007':
 569           s = " \\a";
 570           break;
 571
 572         case '\b':
 573           s = " \\b";
 574           break;
 575
 576         case '\f':
 577           s = " \\f";
 578           break;
 579
 580         case '\n':
 581           s = " \\n";
 582           break;
 583
 584         case '\r':
 585           s = " \\r";
 586           break;
 587
 588         case '\t':
 589           s = " \\t";
 590           break;
 591
 592         case '\v':
 593           s = " \\v";
 594           break;
 595
 596         default:
 597           sprintf (buf, (ISPRINT (c) ? "  %c" : "%03o"), c);
 598           s = (const char *) buf;
 599         }
 600
 601       printf ("%3s%c", s, (i == 1 ? '\n' : ' '));
 602       block += sizeof (unsigned char);
 603     }
 604 }
 605
 606 /* Convert a null-terminated (possibly zero-length) string S to an
 607    unsigned long integer value.  If S points to a non-digit set *P to S,
 608    *VAL to 0, and return 0.  Otherwise, accumulate the integer value of
 609    the string of digits.  If the string of digits represents a value
 610    larger than ULONG_MAX, don't modify *VAL or *P and return non-zero.
 611    Otherwise, advance *P to the first non-digit after S, set *VAL to
 612    the result of the conversion and return zero.  */
 613
 614 static int
 615 simple_strtoul (const char *s, const char **p, long unsigned int *val)
 616 {
 617   unsigned long int sum;
 618
 619   sum = 0;
 620   while (ISDIGIT (*s))
 621     {
 622       unsigned int c = *s++ - '0';
 623       if (sum > (ULONG_MAX - c) / 10)
 624         return 1;
 625       sum = sum * 10 + c;
 626     }
 627   *p = s;
 628   *val = sum;
 629   return 0;
 630 }
 631
 632 /* If S points to a single valid POSIX-style od format string, put a
 633    description of that format in *TSPEC, make *NEXT point at the character
 634    following the just-decoded format (if *NEXT is non-NULL), and return
 635    zero.  If S is not valid, don't modify *NEXT or *TSPEC and return
 636    non-zero.  For example, if S were "d4afL" *NEXT would be set to "afL"
 637    and *TSPEC would be
 638      {
 639        fmt = SIGNED_DECIMAL;
 640        size = INT or LONG; (whichever integral_type_size[4] resolves to)
 641        print_function = print_int; (assuming size == INT)
 642        fmt_string = "%011d%c";
 643       }
 644    */
 645
 646 static int
 647 decode_one_format (const char *s, const char **next, struct tspec *tspec)
 648 {
 649   enum size_spec size_spec;
 650   unsigned long int size;
 651   enum output_format fmt;
 652   const char *pre_fmt_string;
 653   char *fmt_string;
 654   void (*print_function) ();
 655   const char *p;
 656   unsigned int c;
 657
 658   assert (tspec != NULL);
 659
 660   switch (*s)
 661     {
 662     case 'd':
 663     case 'o':
 664     case 'u':
 665     case 'x':
 666       c = *s;
 667       ++s;
 668       switch (*s)
 669         {
 670         case 'C':
 671           ++s;
 672           size = sizeof (char);
 673           break;
 674
 675         case 'S':
 676           ++s;
 677           size = sizeof (short);
 678           break;
 679
 680         case 'I':
 681           ++s;
 682           size = sizeof (int);
 683           break;
 684
 685         case 'L':
 686           ++s;
 687           size = sizeof (long int);
 688           break;
 689
 690         default:
 691           if (simple_strtoul (s, &p, &size) != 0)
 692             return 1;
 693           if (p == s)
 694             size = sizeof (int);
 695           else
 696             {
 697               if (size > MAX_INTEGRAL_TYPE_SIZE
 698                   || integral_type_size[size] == NO_SIZE)
 699                 return 1;
 700               s = p;
 701             }
 702           break;
 703         }
 704
 705 #define FMT_BYTES_ALLOCATED 9
 706       fmt_string = xmalloc (FMT_BYTES_ALLOCATED);
 707
 708       size_spec = integral_type_size[size];
 709
 710       switch (c)
 711         {
 712         case 'd':
 713           fmt = SIGNED_DECIMAL;
 714           sprintf (fmt_string, "%%%u%sd%%c",
 715                    bytes_to_signed_dec_digits[size],
 716                    (size_spec == LONG ? "l" : ""));
 717           break;
 718
 719         case 'o':
 720           fmt = OCTAL;
 721           sprintf (fmt_string, "%%0%u%so%%c",
 722                    bytes_to_oct_digits[size],
 723                    (size_spec == LONG ? "l" : ""));
 724           break;
 725
 726         case 'u':
 727           fmt = UNSIGNED_DECIMAL;
 728           sprintf (fmt_string, "%%%u%su%%c",
 729                    bytes_to_unsigned_dec_digits[size],
 730                    (size_spec == LONG ? "l" : ""));
 731           break;
 732
 733         case 'x':
 734           fmt = HEXADECIMAL;
 735           sprintf (fmt_string, "%%0%u%sx%%c",
 736                    bytes_to_hex_digits[size],
 737                    (size_spec == LONG ? "l" : ""));
 738           break;
 739
 740         default:
 741           abort ();
 742         }
 743
 744       assert (strlen (fmt_string) < FMT_BYTES_ALLOCATED);
 745
 746       switch (size_spec)
 747         {
 748         case CHAR:
 749           print_function = (fmt == SIGNED_DECIMAL
 750                             ? print_s_char
 751                             : print_char);
 752           break;
 753
 754         case SHORT:
 755           print_function = (fmt == SIGNED_DECIMAL
 756                             ? print_s_short
 757                             : print_short);
 758           break;
 759
 760         case INT:
 761           print_function = print_int;
 762           break;
 763
 764         case LONG:
 765           print_function = print_long;
 766           break;
 767
 768         default:
 769           abort ();
 770         }
 771       break;
 772
 773     case 'f':
 774       fmt = FLOATING_POINT;
 775       ++s;
 776       switch (*s)
 777         {
 778         case 'F':
 779           ++s;
 780           size = sizeof (float);
 781           break;
 782
 783         case 'D':
 784           ++s;
 785           size = sizeof (double);
 786           break;
 787
 788         case 'L':
 789           ++s;
 790           size = sizeof (LONG_DOUBLE);
 791           break;
 792
 793         default:
 794           if (simple_strtoul (s, &p, &size) != 0)
 795             return 1;
 796           if (p == s)
 797             size = sizeof (double);
 798           else
 799             {
 800               if (size > MAX_FP_TYPE_SIZE
 801                   || fp_type_size[size] == NO_SIZE)
 802                 return 1;
 803               s = p;
 804             }
 805           break;
 806         }
 807       size_spec = fp_type_size[size];
 808
 809       switch (size_spec)
 810         {
 811         case FLOAT_SINGLE:
 812           print_function = print_float;
 813           /* Don't use %#e; not all systems support it.  */
 814           pre_fmt_string = "%%%d.%de%%c";
 815           fmt_string = xmalloc (strlen (pre_fmt_string));
 816           sprintf (fmt_string, pre_fmt_string,
 817                    FLT_DIG + 8, FLT_DIG);
 818           break;
 819
 820         case FLOAT_DOUBLE:
 821           print_function = print_double;
 822           pre_fmt_string = "%%%d.%de%%c";
 823           fmt_string = xmalloc (strlen (pre_fmt_string));
 824           sprintf (fmt_string, pre_fmt_string,
 825                    DBL_DIG + 8, DBL_DIG);
 826           break;
 827
 828 #ifdef HAVE_LONG_DOUBLE
 829         case FLOAT_LONG_DOUBLE:
 830           print_function = print_long_double;
 831           pre_fmt_string = "%%%d.%dle%%c";
 832           fmt_string = xmalloc (strlen (pre_fmt_string));
 833           sprintf (fmt_string, pre_fmt_string,
 834                    LDBL_DIG + 8, LDBL_DIG);
 835           break;
 836 #endif
 837
 838         default:
 839           abort ();
 840         }
 841       break;
 842
 843     case 'a':
 844       ++s;
 845       fmt = NAMED_CHARACTER;
 846       size_spec = CHAR;
 847       fmt_string = NULL;
 848       print_function = print_named_ascii;
 849       break;
 850
 851     case 'c':
 852       ++s;
 853       fmt = CHARACTER;
 854       size_spec = CHAR;
 855       fmt_string = NULL;
 856       print_function = print_ascii;
 857       break;
 858
 859     default:
 860       return 1;
 861     }
 862
 863   tspec->size = size_spec;
 864   tspec->fmt = fmt;
 865   tspec->print_function = print_function;
 866   tspec->fmt_string = fmt_string;
 867
 868   if (next != NULL)
 869     *next = s;
 870
 871   return 0;
 872 }
 873
 874 /* Decode the POSIX-style od format string S.  Append the decoded
 875    representation to the global array SPEC, reallocating SPEC if
 876    necessary.  Return zero if S is valid, non-zero otherwise.  */
 877
 878 static int
 879 decode_format_string (const char *s)
 880 {
 881   assert (s != NULL);
 882
 883   while (*s != '\0')
 884     {
 885       struct tspec tspec;
 886       const char *next;
 887
 888       if (decode_one_format (s, &next, &tspec))
 889         return 1;
 890
 891       assert (s != next);
 892       s = next;
 893
 894       if (n_specs >= n_specs_allocated)
 895         {
 896           n_specs_allocated = 1 + (3 * n_specs_allocated) / 2;
 897           spec = (struct tspec *) xrealloc (spec, (n_specs_allocated
 898                                                    * sizeof (struct tspec)));
 899         }
 900
 901       memcpy ((char *) &spec[n_specs], (char *) &tspec, sizeof (struct tspec));
 902       ++n_specs;
 903     }
 904
 905   return 0;
 906 }
 907
 908 /* Given a list of one or more input filenames FILE_LIST, set the global
 909    file pointer IN_STREAM to position N_SKIP in the concatenation of
 910    those files.  If any file operation fails or if there are fewer than
 911    N_SKIP bytes in the combined input, give an error message and return
 912    non-zero.  When possible, use seek- rather than read operations to
 913    advance IN_STREAM.  A file name of "-" is interpreted as standard
 914    input.  */
 915
 916 static int
 917 skip (off_t n_skip)
 918 {
 919   int err;
 920
 921   err = 0;
 922   for ( /* empty */ ; *file_list != NULL; ++file_list)
 923     {
 924       struct stat file_stats;
 925       int j;
 926
 927       if (STREQ (*file_list, "-"))
 928         {
 929           input_filename = _("standard input");
 930           in_stream = stdin;
 931           have_read_stdin = 1;
 932         }
 933       else
 934         {
 935           input_filename = *file_list;
 936           in_stream = fopen (input_filename, "r");
 937           if (in_stream == NULL)
 938             {
 939               error (0, errno, "%s", input_filename);
 940               err = 1;
 941               continue;
 942             }
 943         }
 944
 945       if (n_skip == 0)
 946         break;
 947
 948       /* First try using fseek.  For large offsets, this extra work is
 949          worthwhile.  If the offset is below some threshold it may be
 950          more efficient to move the pointer by reading.  There are two
 951          issues when trying to use fseek:
 952            - the file must be seekable.
 953            - before seeking to the specified position, make sure
 954              that the new position is in the current file.
 955              Try to do that by getting file's size using fstat().
 956              But that will work only for regular files and dirs.  */
 957
 958       if (fstat (fileno (in_stream), &file_stats))
 959         {
 960           error (0, errno, "%s", input_filename);
 961           err = 1;
 962           continue;
 963         }
 964
 965       /* The st_size field is valid only for regular files and
 966          directories.  FIXME: is the preceding true?
 967          If the number of bytes left to skip is at least as large as
 968          the size of the current file, we can decrement
 969          n_skip and go on to the next file.  */
 970       if (S_ISREG (file_stats.st_mode) || S_ISDIR (file_stats.st_mode))
 971         {
 972           if (n_skip >= file_stats.st_size)
 973             {
 974               n_skip -= file_stats.st_size;
 975               if (in_stream != stdin && fclose (in_stream) == EOF)
 976                 {
 977                   error (0, errno, "%s", input_filename);
 978                   err = 1;
 979                 }
 980               continue;
 981             }
 982           else
 983             {
 984               /* fseek may work on some streams for which lseek doesn't.
 985                  But fseek's offset argument is restricted to the range
 986                  of type `long'.  So if N_SKIP is too large or if fseek
 987                  fails, try lseek.  */
 988               if ((n_skip <= LONG_MAX
 989                    && fseek (in_stream, (long) n_skip, SEEK_SET) == 0)
 990                   || lseek (fileno (in_stream), n_skip, SEEK_SET) >= 0)
 991                 {
 992                   n_skip = 0;
 993                   break;
 994                 }
 995             }
 996         }
 997
 998       /* Seek didn't work or wasn't attempted;  position the file pointer
 999          by reading.  */
1000
1001       for (j = n_skip / BUFSIZ; j >= 0; j--)
1002         {
1003           char buf[BUFSIZ];
1004           size_t n_bytes_to_read = (j > 0
1005                                     ? BUFSIZ
1006                                     : n_skip % BUFSIZ);
1007           size_t n_bytes_read;
1008           n_bytes_read = fread (buf, 1, n_bytes_to_read, in_stream);
1009           n_skip -= n_bytes_read;
1010           if (n_bytes_read != n_bytes_to_read)
1011             break;
1012         }
1013
1014       if (n_skip == 0)
1015         break;
1016     }
1017
1018   if (n_skip != 0)
1019     error (2, 0, _("cannot skip past end of combined input"));
1020
1021   return err;
1022 }
1023
1024 static const char *
1025 format_address_none (long unsigned int address)
1026 {
1027   return "";
1028 }
1029
1030 static const char *
1031 format_address_std (long unsigned int address)
1032 {
1033   const char *address_string;
1034
1035   sprintf (address_fmt_buffer, output_address_fmt_string, address);
1036   address_string = address_fmt_buffer;
1037   return address_string;
1038 }
1039
1040 static const char *
1041 format_address_label (long unsigned int address)
1042 {
1043   const char *address_string;
1044   assert (output_address_fmt_string != NULL);
1045
1046   sprintf (address_fmt_buffer, output_address_fmt_string,
1047            address, address + pseudo_offset);
1048   address_string = address_fmt_buffer;
1049   return address_string;
1050 }
1051
1052 /* Write N_BYTES bytes from CURR_BLOCK to standard output once for each
1053    of the N_SPEC format specs.  CURRENT_OFFSET is the byte address of
1054    CURR_BLOCK in the concatenation of input files, and it is printed
1055    (optionally) only before the output line associated with the first
1056    format spec.  When duplicate blocks are being abbreviated, the output
1057    for a sequence of identical input blocks is the output for the first
1058    block followed by an asterisk alone on a line.  It is valid to compare
1059    the blocks PREV_BLOCK and CURR_BLOCK only when N_BYTES == BYTES_PER_BLOCK.
1060    That condition may be false only for the last input block -- and then
1061    only when it has not been padded to length BYTES_PER_BLOCK.  */
1062
1063 static void
1064 write_block (long unsigned int current_offset, long unsigned int n_bytes,
1065              const char *prev_block, const char *curr_block)
1066 {
1067   static int first = 1;
1068   static int prev_pair_equal = 0;
1069
1070 #define EQUAL_BLOCKS(b1, b2) (memcmp ((b1), (b2), bytes_per_block) == 0)
1071
1072   if (abbreviate_duplicate_blocks
1073       && !first && n_bytes == bytes_per_block
1074       && EQUAL_BLOCKS (prev_block, curr_block))
1075     {
1076       if (prev_pair_equal)
1077         {
1078           /* The two preceding blocks were equal, and the current
1079              block is the same as the last one, so print nothing.  */
1080         }
1081       else
1082         {
1083           printf ("*\n");
1084           prev_pair_equal = 1;
1085         }
1086     }
1087   else
1088     {
1089       unsigned int i;
1090
1091       prev_pair_equal = 0;
1092       for (i = 0; i < n_specs; i++)
1093         {
1094           printf ("%s ", (i == 0
1095                           ? format_address (current_offset)
1096                           : address_pad));
1097           (*spec[i].print_function) (n_bytes, curr_block, spec[i].fmt_string);
1098         }
1099     }
1100   first = 0;
1101 }
1102
1103 /* Test whether there have been errors on in_stream, and close it if
1104    it is not standard input.  Return non-zero if there has been an error
1105    on in_stream or stdout; return zero otherwise.  This function will
1106    report more than one error only if both a read and a write error
1107    have occurred.  */
1108
1109 static int
1110 check_and_close (void)
1111 {
1112   int err;
1113
1114   err = 0;
1115   if (ferror (in_stream))
1116     {
1117       error (0, errno, "%s", input_filename);
1118       if (in_stream != stdin)
1119         fclose (in_stream);
1120       err = 1;
1121     }
1122   else if (in_stream != stdin && fclose (in_stream) == EOF)
1123     {
1124       error (0, errno, "%s", input_filename);
1125       err = 1;
1126     }
1127
1128   if (ferror (stdout))
1129     {
1130       error (0, errno, _("standard output"));
1131       err = 1;
1132     }
1133
1134   return err;
1135 }
1136
1137 /* Read a single byte into *C from the concatenation of the input files
1138    named in the global array FILE_LIST.  On the first call to this
1139    function, the global variable IN_STREAM is expected to be an open
1140    stream associated with the input file *FILE_LIST.  If IN_STREAM is
1141    at end-of-file, close it and update the global variables IN_STREAM,
1142    FILE_LIST, and INPUT_FILENAME so they correspond to the next file in
1143    the list.  Then try to read a byte from the newly opened file.
1144    Repeat if necessary until *FILE_LIST is NULL.  When EOF is reached
1145    for the last file in FILE_LIST, set *C to EOF and return.  Subsequent
1146    calls do likewise.  The return value is non-zero if any errors
1147    occured, zero otherwise.  */
1148
1149 static int
1150 read_char (int *c)
1151 {
1152   int err;
1153
1154   if (*file_list == NULL)
1155     {
1156       *c = EOF;
1157       return 0;
1158     }
1159
1160   err = 0;
1161   while (1)
1162     {
1163       *c = fgetc (in_stream);
1164
1165       if (*c != EOF)
1166         return err;
1167
1168       err |= check_and_close ();
1169
1170       do
1171         {
1172           ++file_list;
1173           if (*file_list == NULL)
1174             return err;
1175
1176           if (STREQ (*file_list, "-"))
1177             {
1178               input_filename = _("standard input");
1179               in_stream = stdin;
1180               have_read_stdin = 1;
1181             }
1182           else
1183             {
1184               input_filename = *file_list;
1185               in_stream = fopen (input_filename, "r");
1186               if (in_stream == NULL)
1187                 {
1188                   error (0, errno, "%s", input_filename);
1189                   err = 1;
1190                 }
1191             }
1192         }
1193       while (in_stream == NULL);
1194     }
1195 }
1196
1197 /* Read N bytes into BLOCK from the concatenation of the input files
1198    named in the global array FILE_LIST.  On the first call to this
1199    function, the global variable IN_STREAM is expected to be an open
1200    stream associated with the input file *FILE_LIST.  On subsequent
1201    calls, if *FILE_LIST is NULL, don't modify BLOCK and return zero.
1202    If all N bytes cannot be read from IN_STREAM, close IN_STREAM and
1203    update the global variables IN_STREAM, FILE_LIST, and INPUT_FILENAME.
1204    Then try to read the remaining bytes from the newly opened file.
1205    Repeat if necessary until *FILE_LIST is NULL.  Set *N_BYTES_IN_BUFFER
1206    to the number of bytes read.  If an error occurs, it will be detected
1207    through ferror when the stream is about to be closed.  If there is an
1208    error, give a message but continue reading as usual and return non-zero.
1209    Otherwise return zero.  */
1210
1211 static int
1212 read_block (size_t n, char *block, size_t *n_bytes_in_buffer)
1213 {
1214   int err;
1215
1216   assert (n > 0 && n <= bytes_per_block);
1217
1218   *n_bytes_in_buffer = 0;
1219
1220   if (n == 0)
1221     return 0;
1222
1223   if (*file_list == NULL)
1224     return 0;                   /* EOF.  */
1225
1226   err = 0;
1227   while (1)
1228     {
1229       size_t n_needed;
1230       size_t n_read;
1231
1232       n_needed = n - *n_bytes_in_buffer;
1233       n_read = fread (block + *n_bytes_in_buffer, 1, n_needed, in_stream);
1234
1235       *n_bytes_in_buffer += n_read;
1236
1237       if (n_read == n_needed)
1238         return err;
1239
1240       err |= check_and_close ();
1241
1242       do
1243         {
1244           ++file_list;
1245           if (*file_list == NULL)
1246             return err;
1247
1248           if (STREQ (*file_list, "-"))
1249             {
1250               input_filename = _("standard input");
1251               in_stream = stdin;
1252               have_read_stdin = 1;
1253             }
1254           else
1255             {
1256               input_filename = *file_list;
1257               in_stream = fopen (input_filename, "r");
1258               if (in_stream == NULL)
1259                 {
1260                   error (0, errno, "%s", input_filename);
1261                   err = 1;
1262                 }
1263             }
1264         }
1265       while (in_stream == NULL);
1266     }
1267 }
1268
1269 /* Return the least common multiple of the sizes associated
1270    with the format specs.  */
1271
1272 static int
1273 get_lcm (void)
1274 {
1275   unsigned int i;
1276   int l_c_m = 1;
1277
1278   for (i = 0; i < n_specs; i++)
1279     l_c_m = lcm (l_c_m, width_bytes[(int) spec[i].size]);
1280   return l_c_m;
1281 }
1282
1283 /* If S is a valid pre-POSIX offset specification with an optional leading '+'
1284    return the offset it denotes.  Otherwise, return -1.  */
1285
1286 off_t
1287 parse_old_offset (const char *s)
1288 {
1289   int radix;
1290   off_t offset;
1291   enum strtol_error s_err;
1292   long unsigned int tmp;
1293
1294   if (*s == '\0')
1295     return -1;
1296
1297   /* Skip over any leading '+'. */
1298   if (s[0] == '+')
1299     ++s;
1300
1301   /* Determine the radix we'll use to interpret S.  If there is a `.',
1302      it's decimal, otherwise, if the string begins with `0X'or `0x',
1303      it's hexadecimal, else octal.  */
1304   if (strchr (s, '.') != NULL)
1305     radix = 10;
1306   else
1307     {
1308       if (s[0] == '0' && (s[1] == 'x' || s[1] == 'X'))
1309         radix = 16;
1310       else
1311         radix = 8;
1312     }
1313
1314   s_err = xstrtoul (s, NULL, radix, &tmp, "Bb");
1315   if (s_err != LONGINT_OK)
1316     {
1317       STRTOL_FAIL_WARN (s, _("old-style offset"), s_err);
1318       return -1;
1319     }
1320   offset = tmp;
1321   return offset;
1322 }
1323
1324 /* Read a chunk of size BYTES_PER_BLOCK from the input files, write the
1325    formatted block to standard output, and repeat until the specified
1326    maximum number of bytes has been read or until all input has been
1327    processed.  If the last block read is smaller than BYTES_PER_BLOCK
1328    and its size is not a multiple of the size associated with a format
1329    spec, extend the input block with zero bytes until its length is a
1330    multiple of all format spec sizes.  Write the final block.  Finally,
1331    write on a line by itself the offset of the byte after the last byte
1332    read.  Accumulate return values from calls to read_block and
1333    check_and_close, and if any was non-zero, return non-zero.
1334    Otherwise, return zero.  */
1335
1336 static int
1337 dump (void)
1338 {
1339   char *block[2];
1340   off_t current_offset;
1341   off_t end_offset;
1342   int idx;
1343   int err;
1344   size_t n_bytes_read;
1345
1346 #ifdef lint  /* Suppress `used before initialized' warning.  */
1347   end_offset = 0;
1348 #endif
1349
1350   block[0] = (char *) alloca (bytes_per_block);
1351   block[1] = (char *) alloca (bytes_per_block);
1352
1353   current_offset = n_bytes_to_skip;
1354
1355   idx = 0;
1356   err = 0;
1357   if (limit_bytes_to_format)
1358     {
1359       end_offset = n_bytes_to_skip + max_bytes_to_format;
1360
1361       while (1)
1362         {
1363           size_t n_needed;
1364           if (current_offset >= end_offset)
1365             {
1366               n_bytes_read = 0;
1367               break;
1368             }
1369           n_needed = MIN (end_offset - current_offset,
1370                           (off_t) bytes_per_block);
1371           err |= read_block (n_needed, block[idx], &n_bytes_read);
1372           if (n_bytes_read < bytes_per_block)
1373             break;
1374           assert (n_bytes_read == bytes_per_block);
1375           write_block (current_offset, n_bytes_read,
1376                        block[!idx], block[idx]);
1377           current_offset += n_bytes_read;
1378           idx = !idx;
1379         }
1380     }
1381   else
1382     {
1383       while (1)
1384         {
1385           err |= read_block (bytes_per_block, block[idx], &n_bytes_read);
1386           if (n_bytes_read < bytes_per_block)
1387             break;
1388           assert (n_bytes_read == bytes_per_block);
1389           write_block (current_offset, n_bytes_read,
1390                        block[!idx], block[idx]);
1391           current_offset += n_bytes_read;
1392           idx = !idx;
1393         }
1394     }
1395
1396   if (n_bytes_read > 0)
1397     {
1398       int l_c_m;
1399       size_t bytes_to_write;
1400
1401       l_c_m = get_lcm ();
1402
1403       /* Make bytes_to_write the smallest multiple of l_c_m that
1404          is at least as large as n_bytes_read.  */
1405       bytes_to_write = l_c_m * (int) ((n_bytes_read + l_c_m - 1) / l_c_m);
1406
1407       memset (block[idx] + n_bytes_read, 0, bytes_to_write - n_bytes_read);
1408       write_block (current_offset, bytes_to_write,
1409                    block[!idx], block[idx]);
1410       current_offset += n_bytes_read;
1411     }
1412
1413   if (output_address_fmt_string != NULL)
1414     printf ("%s\n", format_address (current_offset));
1415
1416   if (limit_bytes_to_format && current_offset > end_offset)
1417     err |= check_and_close ();
1418
1419   return err;
1420 }
1421
1422 /* STRINGS mode.  Find each "string constant" in the input.
1423    A string constant is a run of at least `string_min' ASCII
1424    graphic (or formatting) characters terminated by a null.
1425    Based on a function written by Richard Stallman for a
1426    pre-POSIX version of od.  Return non-zero if an error
1427    occurs.  Otherwise, return zero.  */
1428
1429 static int
1430 dump_strings (void)
1431 {
1432   size_t bufsize = MAX (100, string_min);
1433   char *buf = xmalloc (bufsize);
1434   off_t address = n_bytes_to_skip;
1435   int err;
1436
1437   err = 0;
1438   while (1)
1439     {
1440       unsigned int i;
1441       int c;
1442
1443       /* See if the next `string_min' chars are all printing chars.  */
1444     tryline:
1445
1446       if (limit_bytes_to_format
1447           && address >= (n_bytes_to_skip + max_bytes_to_format - string_min))
1448         break;
1449
1450       for (i = 0; i < string_min; i++)
1451         {
1452           err |= read_char (&c);
1453           address++;
1454           if (c < 0)
1455             {
1456               free (buf);
1457               return err;
1458             }
1459           if (!ISPRINT (c))
1460             /* Found a non-printing.  Try again starting with next char.  */
1461             goto tryline;
1462           buf[i] = c;
1463         }
1464
1465       /* We found a run of `string_min' printable characters.
1466          Now see if it is terminated with a null byte.  */
1467       while (!limit_bytes_to_format
1468              || address < n_bytes_to_skip + max_bytes_to_format)
1469         {
1470           if (i == bufsize)
1471             {
1472               bufsize = 1 + 3 * bufsize / 2;
1473               buf = xrealloc (buf, bufsize);
1474             }
1475           err |= read_char (&c);
1476           address++;
1477           if (c < 0)
1478             {
1479               free (buf);
1480               return err;
1481             }
1482           if (c == '\0')
1483             break;              /* It is; print this string.  */
1484           if (!ISPRINT (c))
1485             goto tryline;       /* It isn't; give up on this string.  */
1486           buf[i++] = c;         /* String continues; store it all.  */
1487         }
1488
1489       /* If we get here, the string is all printable and null-terminated,
1490          so print it.  It is all in `buf' and `i' is its length.  */
1491       buf[i] = 0;
1492       if (output_address_fmt_string != NULL)
1493         {
1494           printf ("%s ", format_address (address - i - 1));
1495         }
1496       for (i = 0; (c = buf[i]); i++)
1497         {
1498           switch (c)
1499             {
1500             case '\007':
1501               fputs ("\\a", stdout);
1502               break;
1503
1504             case '\b':
1505               fputs ("\\b", stdout);
1506               break;
1507
1508             case '\f':
1509               fputs ("\\f", stdout);
1510               break;
1511
1512             case '\n':
1513               fputs ("\\n", stdout);
1514               break;
1515
1516             case '\r':
1517               fputs ("\\r", stdout);
1518               break;
1519
1520             case '\t':
1521               fputs ("\\t", stdout);
1522               break;
1523
1524             case '\v':
1525               fputs ("\\v", stdout);
1526               break;
1527
1528             default:
1529               putc (c, stdout);
1530             }
1531         }
1532       putchar ('\n');
1533     }
1534
1535   /* We reach this point only if we search through
1536      (max_bytes_to_format - string_min) bytes before reachine EOF.  */
1537
1538   free (buf);
1539
1540   err |= check_and_close ();
1541   return err;
1542 }
1543
1544 int
1545 main (int argc, char **argv)
1546 {
1547   int c;
1548   int n_files;
1549   unsigned int i;
1550   unsigned int l_c_m;
1551   unsigned int address_pad_len;
1552   unsigned long int desired_width;
1553   int width_specified = 0;
1554   int err;
1555
1556   /* The old-style `pseudo starting address' to be printed in parentheses
1557      after any true address.  */
1558   long int pseudo_start;
1559
1560 #ifdef lint  /* Suppress `used before initialized' warning.  */
1561   pseudo_start = 0;
1562 #endif
1563
1564   program_name = argv[0];
1565   err = 0;
1566
1567   for (i = 0; i <= MAX_INTEGRAL_TYPE_SIZE; i++)
1568     integral_type_size[i] = NO_SIZE;
1569
1570   integral_type_size[sizeof (char)] = CHAR;
1571   integral_type_size[sizeof (short int)] = SHORT;
1572   integral_type_size[sizeof (int)] = INT;
1573   integral_type_size[sizeof (long int)] = LONG;
1574
1575   for (i = 0; i <= MAX_FP_TYPE_SIZE; i++)
1576     fp_type_size[i] = NO_SIZE;
1577
1578   fp_type_size[sizeof (float)] = FLOAT_SINGLE;
1579   /* The array entry for `double' is filled in after that for LONG_DOUBLE
1580      so that if `long double' is the same type or if long double isn't
1581      supported FLOAT_LONG_DOUBLE will never be used.  */
1582   fp_type_size[sizeof (LONG_DOUBLE)] = FLOAT_LONG_DOUBLE;
1583   fp_type_size[sizeof (double)] = FLOAT_DOUBLE;
1584
1585   n_specs = 0;
1586   n_specs_allocated = 5;
1587   spec = (struct tspec *) xmalloc (n_specs_allocated * sizeof (struct tspec));
1588
1589   output_address_fmt_string = "%07o";
1590   format_address = format_address_std;
1591   address_pad_len = 7;
1592   flag_dump_strings = 0;
1593
1594   while ((c = getopt_long (argc, argv, "abcdfhilos::xw::A:j:N:t:v",
1595                            long_options, (int *) 0))
1596          != EOF)
1597     {
1598       unsigned long int tmp;
1599       enum strtol_error s_err;
1600
1601       switch (c)
1602         {
1603         case 0:
1604           break;
1605
1606         case 'A':
1607           switch (optarg[0])
1608             {
1609             case 'd':
1610               output_address_fmt_string = "%07d";
1611               format_address = format_address_std;
1612               address_pad_len = 7;
1613               break;
1614             case 'o':
1615               output_address_fmt_string = "%07o";
1616               format_address = format_address_std;
1617               address_pad_len = 7;
1618               break;
1619             case 'x':
1620               output_address_fmt_string = "%06x";
1621               format_address = format_address_std;
1622               address_pad_len = 6;
1623               break;
1624             case 'n':
1625               output_address_fmt_string = NULL;
1626               format_address = format_address_none;
1627               address_pad_len = 0;
1628               break;
1629             default:
1630               error (2, 0,
1631                      _("invalid output address radix `%c'; it must be one character from [doxn]"),
1632                      optarg[0]);
1633               break;
1634             }
1635           break;
1636
1637         case 'j':
1638           s_err = xstrtoul (optarg, NULL, 0, &tmp, "bkm");
1639           n_bytes_to_skip = tmp;
1640           if (s_err != LONGINT_OK)
1641             STRTOL_FATAL_ERROR (optarg, _("skip argument"), s_err);
1642           break;
1643
1644         case 'N':
1645           limit_bytes_to_format = 1;
1646
1647           /* FIXME: if off_t is long long and that's an 8-byte type,
1648              use xstrtouq here.  */
1649           s_err = xstrtoul (optarg, NULL, 0, &tmp, "bkm");
1650           max_bytes_to_format = tmp;
1651           if (s_err != LONGINT_OK)
1652             STRTOL_FATAL_ERROR (optarg, _("limit argument"), s_err);
1653
1654           if (tmp > OFF_T_MAX)
1655             error (2, 0, _("specified number of bytes `%s' is larger than \
1656 the maximum\nrepresentable value of type off_t"), optarg);
1657           break;
1658
1659         case 's':
1660           if (optarg == NULL)
1661             string_min = 3;
1662           else
1663             {
1664               s_err = xstrtoul (optarg, NULL, 0, &string_min, "bkm");
1665               if (s_err != LONGINT_OK)
1666                 STRTOL_FATAL_ERROR (optarg, _("minimum string length"), s_err);
1667             }
1668           ++flag_dump_strings;
1669           break;
1670
1671         case 't':
1672           if (decode_format_string (optarg))
1673             error (2, 0, _("invalid type string `%s'"), optarg);
1674           break;
1675
1676         case 'v':
1677           abbreviate_duplicate_blocks = 0;
1678           break;
1679
1680         case 'B':
1681           traditional = 1;
1682           break;
1683
1684           /* The next several cases map the old, pre-POSIX format
1685              specification options to the corresponding POSIX format
1686              specs.  GNU od accepts any combination of old- and
1687              new-style options.  Format specification options accumulate.  */
1688
1689 #define CASE_OLD_ARG(old_char,new_string)               \
1690         case old_char:                                  \
1691           {                                             \
1692             int tmp;                                    \
1693             tmp = decode_format_string (new_string);    \
1694             assert (tmp == 0);                          \
1695           }                                             \
1696           break
1697
1698           CASE_OLD_ARG ('a', "a");
1699           CASE_OLD_ARG ('b', "oC");
1700           CASE_OLD_ARG ('c', "c");
1701           CASE_OLD_ARG ('d', "u2");
1702           CASE_OLD_ARG ('f', "fF");
1703           CASE_OLD_ARG ('h', "x2");
1704           CASE_OLD_ARG ('i', "d2");
1705           CASE_OLD_ARG ('l', "d4");
1706           CASE_OLD_ARG ('o', "o2");
1707           CASE_OLD_ARG ('x', "x2");
1708
1709 #undef CASE_OLD_ARG
1710
1711         case 'w':
1712           width_specified = 1;
1713           if (optarg == NULL)
1714             {
1715               desired_width = 32;
1716             }
1717           else
1718             {
1719               s_err = xstrtoul (optarg, NULL, 10, &desired_width, NULL);
1720               if (s_err != LONGINT_OK)
1721                 STRTOL_FATAL_ERROR (optarg, _("width specification"), s_err);
1722             }
1723           break;
1724
1725         default:
1726           usage (1);
1727           break;
1728         }
1729     }
1730
1731   if (show_version)
1732     {
1733       printf ("od - %s\n", version_string);
1734       exit (0);
1735     }
1736
1737   if (show_help)
1738     usage (0);
1739
1740   if (flag_dump_strings && n_specs > 0)
1741     error (2, 0, _("no type may be specified when dumping strings"));
1742
1743   n_files = argc - optind;
1744
1745   /* If the --backward-compatible option is used, there may be from
1746      0 to 3 remaining command line arguments;  handle each case
1747      separately.
1748         od [file] [[+]offset[.][b] [[+]label[.][b]]]
1749      The offset and pseudo_start have the same syntax.  */
1750
1751   if (traditional)
1752     {
1753       off_t offset;
1754
1755       if (n_files == 1)
1756         {
1757           if ((offset = parse_old_offset (argv[optind])) >= 0)
1758             {
1759               n_bytes_to_skip = offset;
1760               --n_files;
1761               ++argv;
1762             }
1763         }
1764       else if (n_files == 2)
1765         {
1766           off_t o1, o2;
1767           if ((o1 = parse_old_offset (argv[optind])) >= 0
1768               && (o2 = parse_old_offset (argv[optind + 1])) >= 0)
1769             {
1770               n_bytes_to_skip = o1;
1771               flag_pseudo_start = 1;
1772               pseudo_start = o2;
1773               argv += 2;
1774               n_files -= 2;
1775             }
1776           else if ((o2 = parse_old_offset (argv[optind + 1])) >= 0)
1777             {
1778               n_bytes_to_skip = o2;
1779               --n_files;
1780               argv[optind + 1] = argv[optind];
1781               ++argv;
1782             }
1783           else
1784             {
1785               error (0, 0,
1786                      _("invalid second operand in compatibility mode `%s'"),
1787                      argv[optind + 1]);
1788               usage (1);
1789             }
1790         }
1791       else if (n_files == 3)
1792         {
1793           off_t o1, o2;
1794           if ((o1 = parse_old_offset (argv[optind + 1])) >= 0
1795               && (o2 = parse_old_offset (argv[optind + 2])) >= 0)
1796             {
1797               n_bytes_to_skip = o1;
1798               flag_pseudo_start = 1;
1799               pseudo_start = o2;
1800               argv[optind + 2] = argv[optind];
1801               argv += 2;
1802               n_files -= 2;
1803             }
1804           else
1805             {
1806               error (0, 0,
1807               _("in compatibility mode the last 2 arguments must be offsets"));
1808               usage (1);
1809             }
1810         }
1811       else
1812         {
1813           error (0, 0,
1814              _("in compatibility mode there may be no more than 3 arguments"));
1815           usage (1);
1816         }
1817
1818       if (flag_pseudo_start)
1819         {
1820           static char buf[10];
1821
1822           if (output_address_fmt_string == NULL)
1823             {
1824               output_address_fmt_string = "(%07o)";
1825               format_address = format_address_std;
1826             }
1827           else
1828             {
1829               sprintf (buf, "%s (%s)",
1830                        output_address_fmt_string,
1831                        output_address_fmt_string);
1832               output_address_fmt_string = buf;
1833               format_address = format_address_label;
1834             }
1835         }
1836     }
1837
1838   assert (address_pad_len <= MAX_ADDRESS_LENGTH);
1839   for (i = 0; i < address_pad_len; i++)
1840     address_pad[i] = ' ';
1841   address_pad[address_pad_len] = '\0';
1842
1843   if (n_specs == 0)
1844     {
1845       int d_err = decode_one_format ("o2", NULL, &(spec[0]));
1846
1847       assert (d_err == 0);
1848       n_specs = 1;
1849     }
1850
1851   if (n_files > 0)
1852     file_list = (char const *const *) &argv[optind];
1853   else
1854     {
1855       /* If no files were listed on the command line, set up the
1856          global array FILE_LIST so that it contains the null-terminated
1857          list of one name: "-".  */
1858       static char const *const default_file_list[] = {"-", NULL};
1859
1860       file_list = default_file_list;
1861     }
1862
1863   err |= skip (n_bytes_to_skip);
1864   if (in_stream == NULL)
1865     goto cleanup;
1866
1867   pseudo_offset = (flag_pseudo_start ? pseudo_start - n_bytes_to_skip : 0);
1868
1869   /* Compute output block length.  */
1870   l_c_m = get_lcm ();
1871
1872   if (width_specified)
1873     {
1874       if (desired_width != 0 && desired_width % l_c_m == 0)
1875         bytes_per_block = desired_width;
1876       else
1877         {
1878           error (0, 0, _("warning: invalid width %lu; using %d instead"),
1879                  desired_width, l_c_m);
1880           bytes_per_block = l_c_m;
1881         }
1882     }
1883   else
1884     {
1885       if (l_c_m < DEFAULT_BYTES_PER_BLOCK)
1886         bytes_per_block = l_c_m * (int) (DEFAULT_BYTES_PER_BLOCK / l_c_m);
1887       else
1888         bytes_per_block = l_c_m;
1889     }
1890
1891 #ifdef DEBUG
1892   for (i = 0; i < n_specs; i++)
1893     {
1894       printf (_("%d: fmt=\"%s\" width=%d\n"),
1895               i, spec[i].fmt_string, width_bytes[spec[i].size]);
1896     }
1897 #endif
1898
1899   err |= (flag_dump_strings ? dump_strings () : dump ());
1900
1901 cleanup:;
1902
1903   if (have_read_stdin && fclose (stdin) == EOF)
1904     error (2, errno, _("standard input"));
1905
1906   if (fclose (stdout) == EOF)
1907     error (2, errno, _("write error"));
1908
1909   exit (err);
1910 }