src/od.c

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