src/od.c

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