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