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