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