global: convert indentation-TABs to spaces
[coreutils.git] / src / od.c
blob085d6406cf01c909a898ae134034de2ff1f6d583
1 /* od -- dump files in octal and other formats
2 Copyright (C) 92, 1995-2009 Free Software Foundation, Inc.
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 3 of the License, or
7 (at your option) any later version.
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.
14 You should have received a copy of the GNU General Public License
15 along with this program. If not, see <http://www.gnu.org/licenses/>. */
17 /* Written by Jim Meyering. */
19 #include <config.h>
21 #include <stdio.h>
22 #include <assert.h>
23 #include <getopt.h>
24 #include <sys/types.h>
25 #include "system.h"
26 #include "error.h"
27 #include "quote.h"
28 #include "xfreopen.h"
29 #include "xprintf.h"
30 #include "xstrtol.h"
32 /* The official name of this program (e.g., no `g' prefix). */
33 #define PROGRAM_NAME "od"
35 #define AUTHORS proper_name ("Jim Meyering")
37 #include <float.h>
39 /* The default number of input bytes per output line. */
40 #define DEFAULT_BYTES_PER_BLOCK 16
42 /* The number of decimal digits of precision in a float. */
43 #ifndef FLT_DIG
44 # define FLT_DIG 7
45 #endif
47 /* The number of decimal digits of precision in a double. */
48 #ifndef DBL_DIG
49 # define DBL_DIG 15
50 #endif
52 #if HAVE_UNSIGNED_LONG_LONG_INT
53 typedef unsigned long long int unsigned_long_long_int;
54 #else
55 /* This is just a place-holder to avoid a few `#if' directives.
56 In this case, the type isn't actually used. */
57 typedef unsigned long int unsigned_long_long_int;
58 #endif
60 enum size_spec
62 NO_SIZE,
63 CHAR,
64 SHORT,
65 INT,
66 LONG,
67 LONG_LONG,
68 /* FIXME: add INTMAX support, too */
69 FLOAT_SINGLE,
70 FLOAT_DOUBLE,
71 FLOAT_LONG_DOUBLE,
72 N_SIZE_SPECS
75 enum output_format
77 SIGNED_DECIMAL,
78 UNSIGNED_DECIMAL,
79 OCTAL,
80 HEXADECIMAL,
81 FLOATING_POINT,
82 NAMED_CHARACTER,
83 CHARACTER
86 #define MAX_INTEGRAL_TYPE_SIZE sizeof (unsigned_long_long_int)
88 /* The maximum number of bytes needed for a format string, including
89 the trailing nul. Each format string expects a variable amount of
90 padding (guaranteed to be at least 1 plus the field width), then an
91 element that will be formatted in the field. */
92 enum
94 FMT_BYTES_ALLOCATED =
95 MAX ((sizeof "%*.99" - 1
96 + MAX (sizeof "ld",
97 MAX (sizeof PRIdMAX,
98 MAX (sizeof PRIoMAX,
99 MAX (sizeof PRIuMAX,
100 sizeof PRIxMAX))))),
101 sizeof "%*.99Le")
104 /* Ensure that our choice for FMT_BYTES_ALLOCATED is reasonable. */
105 verify (LDBL_DIG <= 99);
106 verify (MAX_INTEGRAL_TYPE_SIZE * CHAR_BIT / 3 <= 99);
108 /* Each output format specification (from `-t spec' or from
109 old-style options) is represented by one of these structures. */
110 struct tspec
112 enum output_format fmt;
113 enum size_spec size; /* Type of input object. */
114 /* FIELDS is the number of fields per line, BLANK is the number of
115 fields to leave blank. WIDTH is width of one field, excluding
116 leading space, and PAD is total pad to divide among FIELDS.
117 PAD is at least as large as FIELDS. */
118 void (*print_function) (size_t fields, size_t blank, void const *data,
119 char const *fmt, int width, int pad);
120 char fmt_string[FMT_BYTES_ALLOCATED]; /* Of the style "%*d". */
121 bool hexl_mode_trailer;
122 int field_width; /* Minimum width of a field, excluding leading space. */
123 int pad_width; /* Total padding to be divided among fields. */
126 /* Convert the number of 8-bit bytes of a binary representation to
127 the number of characters (digits + sign if the type is signed)
128 required to represent the same quantity in the specified base/type.
129 For example, a 32-bit (4-byte) quantity may require a field width
130 as wide as the following for these types:
131 11 unsigned octal
132 11 signed decimal
133 10 unsigned decimal
134 8 unsigned hexadecimal */
136 static unsigned int const bytes_to_oct_digits[] =
137 {0, 3, 6, 8, 11, 14, 16, 19, 22, 25, 27, 30, 32, 35, 38, 41, 43};
139 static unsigned int const bytes_to_signed_dec_digits[] =
140 {1, 4, 6, 8, 11, 13, 16, 18, 20, 23, 25, 28, 30, 33, 35, 37, 40};
142 static unsigned int const bytes_to_unsigned_dec_digits[] =
143 {0, 3, 5, 8, 10, 13, 15, 17, 20, 22, 25, 27, 29, 32, 34, 37, 39};
145 static unsigned int const bytes_to_hex_digits[] =
146 {0, 2, 4, 6, 8, 10, 12, 14, 16, 18, 20, 22, 24, 26, 28, 30, 32};
148 /* It'll be a while before we see integral types wider than 16 bytes,
149 but if/when it happens, this check will catch it. Without this check,
150 a wider type would provoke a buffer overrun. */
151 verify (MAX_INTEGRAL_TYPE_SIZE < ARRAY_CARDINALITY (bytes_to_hex_digits));
153 /* Make sure the other arrays have the same length. */
154 verify (sizeof bytes_to_oct_digits == sizeof bytes_to_signed_dec_digits);
155 verify (sizeof bytes_to_oct_digits == sizeof bytes_to_unsigned_dec_digits);
156 verify (sizeof bytes_to_oct_digits == sizeof bytes_to_hex_digits);
158 /* Convert enum size_spec to the size of the named type. */
159 static const int width_bytes[] =
162 sizeof (char),
163 sizeof (short int),
164 sizeof (int),
165 sizeof (long int),
166 sizeof (unsigned_long_long_int),
167 sizeof (float),
168 sizeof (double),
169 sizeof (long double)
172 /* Ensure that for each member of `enum size_spec' there is an
173 initializer in the width_bytes array. */
174 verify (ARRAY_CARDINALITY (width_bytes) == N_SIZE_SPECS);
176 /* Names for some non-printing characters. */
177 static char const charname[33][4] =
179 "nul", "soh", "stx", "etx", "eot", "enq", "ack", "bel",
180 "bs", "ht", "nl", "vt", "ff", "cr", "so", "si",
181 "dle", "dc1", "dc2", "dc3", "dc4", "nak", "syn", "etb",
182 "can", "em", "sub", "esc", "fs", "gs", "rs", "us",
183 "sp"
186 /* Address base (8, 10 or 16). */
187 static int address_base;
189 /* The number of octal digits required to represent the largest
190 address value. */
191 #define MAX_ADDRESS_LENGTH \
192 ((sizeof (uintmax_t) * CHAR_BIT + CHAR_BIT - 1) / 3)
194 /* Width of a normal address. */
195 static int address_pad_len;
197 /* Minimum length when detecting --strings. */
198 static size_t string_min;
200 /* True when in --strings mode. */
201 static bool flag_dump_strings;
203 /* True if we should recognize the older non-option arguments
204 that specified at most one file and optional arguments specifying
205 offset and pseudo-start address. */
206 static bool traditional;
208 /* True if an old-style `pseudo-address' was specified. */
209 static bool flag_pseudo_start;
211 /* The difference between the old-style pseudo starting address and
212 the number of bytes to skip. */
213 static uintmax_t pseudo_offset;
215 /* Function that accepts an address and an optional following char,
216 and prints the address and char to stdout. */
217 static void (*format_address) (uintmax_t, char);
219 /* The number of input bytes to skip before formatting and writing. */
220 static uintmax_t n_bytes_to_skip = 0;
222 /* When false, MAX_BYTES_TO_FORMAT and END_OFFSET are ignored, and all
223 input is formatted. */
224 static bool limit_bytes_to_format = false;
226 /* The maximum number of bytes that will be formatted. */
227 static uintmax_t max_bytes_to_format;
229 /* The offset of the first byte after the last byte to be formatted. */
230 static uintmax_t end_offset;
232 /* When true and two or more consecutive blocks are equal, format
233 only the first block and output an asterisk alone on the following
234 line to indicate that identical blocks have been elided. */
235 static bool abbreviate_duplicate_blocks = true;
237 /* An array of specs describing how to format each input block. */
238 static struct tspec *spec;
240 /* The number of format specs. */
241 static size_t n_specs;
243 /* The allocated length of SPEC. */
244 static size_t n_specs_allocated;
246 /* The number of input bytes formatted per output line. It must be
247 a multiple of the least common multiple of the sizes associated with
248 the specified output types. It should be as large as possible, but
249 no larger than 16 -- unless specified with the -w option. */
250 static size_t bytes_per_block;
252 /* Human-readable representation of *file_list (for error messages).
253 It differs from file_list[-1] only when file_list[-1] is "-". */
254 static char const *input_filename;
256 /* A NULL-terminated list of the file-arguments from the command line. */
257 static char const *const *file_list;
259 /* Initializer for file_list if no file-arguments
260 were specified on the command line. */
261 static char const *const default_file_list[] = {"-", NULL};
263 /* The input stream associated with the current file. */
264 static FILE *in_stream;
266 /* If true, at least one of the files we read was standard input. */
267 static bool have_read_stdin;
269 /* Map the size in bytes to a type identifier. */
270 static enum size_spec integral_type_size[MAX_INTEGRAL_TYPE_SIZE + 1];
272 #define MAX_FP_TYPE_SIZE sizeof (long double)
273 static enum size_spec fp_type_size[MAX_FP_TYPE_SIZE + 1];
275 static char const short_options[] = "A:aBbcDdeFfHhIij:LlN:OoS:st:vw::Xx";
277 /* For long options that have no equivalent short option, use a
278 non-character as a pseudo short option, starting with CHAR_MAX + 1. */
279 enum
281 TRADITIONAL_OPTION = CHAR_MAX + 1
284 static struct option const long_options[] =
286 {"skip-bytes", required_argument, NULL, 'j'},
287 {"address-radix", required_argument, NULL, 'A'},
288 {"read-bytes", required_argument, NULL, 'N'},
289 {"format", required_argument, NULL, 't'},
290 {"output-duplicates", no_argument, NULL, 'v'},
291 {"strings", optional_argument, NULL, 'S'},
292 {"traditional", no_argument, NULL, TRADITIONAL_OPTION},
293 {"width", optional_argument, NULL, 'w'},
295 {GETOPT_HELP_OPTION_DECL},
296 {GETOPT_VERSION_OPTION_DECL},
297 {NULL, 0, NULL, 0}
300 void
301 usage (int status)
303 if (status != EXIT_SUCCESS)
304 fprintf (stderr, _("Try `%s --help' for more information.\n"),
305 program_name);
306 else
308 printf (_("\
309 Usage: %s [OPTION]... [FILE]...\n\
310 or: %s [-abcdfilosx]... [FILE] [[+]OFFSET[.][b]]\n\
311 or: %s --traditional [OPTION]... [FILE] [[+]OFFSET[.][b] [+][LABEL][.][b]]\n\
313 program_name, program_name, program_name);
314 fputs (_("\n\
315 Write an unambiguous representation, octal bytes by default,\n\
316 of FILE to standard output. With more than one FILE argument,\n\
317 concatenate them in the listed order to form the input.\n\
318 With no FILE, or when FILE is -, read standard input.\n\
320 "), stdout);
321 fputs (_("\
322 All arguments to long options are mandatory for short options.\n\
323 "), stdout);
324 fputs (_("\
325 -A, --address-radix=RADIX decide how file offsets are printed\n\
326 -j, --skip-bytes=BYTES skip BYTES input bytes first\n\
327 "), stdout);
328 fputs (_("\
329 -N, --read-bytes=BYTES limit dump to BYTES input bytes\n\
330 -S, --strings[=BYTES] output strings of at least BYTES graphic chars\n\
331 -t, --format=TYPE select output format or formats\n\
332 -v, --output-duplicates do not use * to mark line suppression\n\
333 -w, --width[=BYTES] output BYTES bytes per output line\n\
334 --traditional accept arguments in traditional form\n\
335 "), stdout);
336 fputs (HELP_OPTION_DESCRIPTION, stdout);
337 fputs (VERSION_OPTION_DESCRIPTION, stdout);
338 fputs (_("\
340 Traditional format specifications may be intermixed; they accumulate:\n\
341 -a same as -t a, select named characters, ignoring high-order bit\n\
342 -b same as -t o1, select octal bytes\n\
343 -c same as -t c, select ASCII characters or backslash escapes\n\
344 -d same as -t u2, select unsigned decimal 2-byte units\n\
345 "), stdout);
346 fputs (_("\
347 -f same as -t fF, select floats\n\
348 -i same as -t dI, select decimal ints\n\
349 -l same as -t dL, select decimal longs\n\
350 -o same as -t o2, select octal 2-byte units\n\
351 -s same as -t d2, select decimal 2-byte units\n\
352 -x same as -t x2, select hexadecimal 2-byte units\n\
353 "), stdout);
354 fputs (_("\
356 If first and second call formats both apply, the second format is assumed\n\
357 if the last operand begins with + or (if there are 2 operands) a digit.\n\
358 An OFFSET operand means -j OFFSET. LABEL is the pseudo-address\n\
359 at first byte printed, incremented when dump is progressing.\n\
360 For OFFSET and LABEL, a 0x or 0X prefix indicates hexadecimal;\n\
361 suffixes may be . for octal and b for multiply by 512.\n\
362 "), stdout);
363 fputs (_("\
365 TYPE is made up of one or more of these specifications:\n\
367 a named character, ignoring high-order bit\n\
368 c ASCII character or backslash escape\n\
369 "), stdout);
370 fputs (_("\
371 d[SIZE] signed decimal, SIZE bytes per integer\n\
372 f[SIZE] floating point, SIZE bytes per integer\n\
373 o[SIZE] octal, SIZE bytes per integer\n\
374 u[SIZE] unsigned decimal, SIZE bytes per integer\n\
375 x[SIZE] hexadecimal, SIZE bytes per integer\n\
376 "), stdout);
377 fputs (_("\
379 SIZE is a number. For TYPE in doux, SIZE may also be C for\n\
380 sizeof(char), S for sizeof(short), I for sizeof(int) or L for\n\
381 sizeof(long). If TYPE is f, SIZE may also be F for sizeof(float), D\n\
382 for sizeof(double) or L for sizeof(long double).\n\
383 "), stdout);
384 fputs (_("\
386 RADIX is d for decimal, o for octal, x for hexadecimal or n for none.\n\
387 BYTES is hexadecimal with 0x or 0X prefix, and may have a multiplier suffix:\n\
388 b 512, kB 1000, K 1024, MB 1000*1000, M 1024*1024,\n\
389 GB 1000*1000*1000, G 1024*1024*1024, and so on for T, P, E, Z, Y.\n\
390 Adding a z suffix to any type displays printable characters at the end of each\n\
391 output line.\n\
392 "), stdout);
393 fputs (_("\
394 Option --string without a number implies 3; option --width without a number\n\
395 implies 32. By default, od uses -A o -t oS -w16.\n\
396 "), stdout);
397 emit_bug_reporting_address ();
399 exit (status);
402 /* Define the print functions. */
404 #define PRINT_TYPE(N, T) \
405 static void \
406 N (size_t fields, size_t blank, void const *block, \
407 char const *fmt_string, int width, int pad) \
409 T const *p = block; \
410 size_t i; \
411 int pad_remaining = pad; \
412 for (i = fields; blank < i; i--) \
414 int next_pad = pad * (i - 1) / fields; \
415 xprintf (fmt_string, pad_remaining - next_pad + width, *p++); \
416 pad_remaining = next_pad; \
420 PRINT_TYPE (print_s_char, signed char)
421 PRINT_TYPE (print_char, unsigned char)
422 PRINT_TYPE (print_s_short, short int)
423 PRINT_TYPE (print_short, unsigned short int)
424 PRINT_TYPE (print_int, unsigned int)
425 PRINT_TYPE (print_long, unsigned long int)
426 PRINT_TYPE (print_long_long, unsigned_long_long_int)
427 PRINT_TYPE (print_float, float)
428 PRINT_TYPE (print_double, double)
429 PRINT_TYPE (print_long_double, long double)
431 #undef PRINT_TYPE
433 static void
434 dump_hexl_mode_trailer (size_t n_bytes, const char *block)
436 size_t i;
437 fputs (" >", stdout);
438 for (i = n_bytes; i > 0; i--)
440 unsigned char c = *block++;
441 unsigned char c2 = (isprint (c) ? c : '.');
442 putchar (c2);
444 putchar ('<');
447 static void
448 print_named_ascii (size_t fields, size_t blank, void const *block,
449 const char *unused_fmt_string ATTRIBUTE_UNUSED,
450 int width, int pad)
452 unsigned char const *p = block;
453 size_t i;
454 int pad_remaining = pad;
455 for (i = fields; blank < i; i--)
457 int next_pad = pad * (i - 1) / fields;
458 int masked_c = *p++ & 0x7f;
459 const char *s;
460 char buf[2];
462 if (masked_c == 127)
463 s = "del";
464 else if (masked_c <= 040)
465 s = charname[masked_c];
466 else
468 buf[0] = masked_c;
469 buf[1] = 0;
470 s = buf;
473 xprintf ("%*s", pad_remaining - next_pad + width, s);
474 pad_remaining = next_pad;
478 static void
479 print_ascii (size_t fields, size_t blank, void const *block,
480 const char *unused_fmt_string ATTRIBUTE_UNUSED, int width,
481 int pad)
483 unsigned char const *p = block;
484 size_t i;
485 int pad_remaining = pad;
486 for (i = fields; blank < i; i--)
488 int next_pad = pad * (i - 1) / fields;
489 unsigned char c = *p++;
490 const char *s;
491 char buf[4];
493 switch (c)
495 case '\0':
496 s = "\\0";
497 break;
499 case '\a':
500 s = "\\a";
501 break;
503 case '\b':
504 s = "\\b";
505 break;
507 case '\f':
508 s = "\\f";
509 break;
511 case '\n':
512 s = "\\n";
513 break;
515 case '\r':
516 s = "\\r";
517 break;
519 case '\t':
520 s = "\\t";
521 break;
523 case '\v':
524 s = "\\v";
525 break;
527 default:
528 sprintf (buf, (isprint (c) ? "%c" : "%03o"), c);
529 s = buf;
532 xprintf ("%*s", pad_remaining - next_pad + width, s);
533 pad_remaining = next_pad;
537 /* Convert a null-terminated (possibly zero-length) string S to an
538 unsigned long integer value. If S points to a non-digit set *P to S,
539 *VAL to 0, and return true. Otherwise, accumulate the integer value of
540 the string of digits. If the string of digits represents a value
541 larger than ULONG_MAX, don't modify *VAL or *P and return false.
542 Otherwise, advance *P to the first non-digit after S, set *VAL to
543 the result of the conversion and return true. */
545 static bool
546 simple_strtoul (const char *s, const char **p, unsigned long int *val)
548 unsigned long int sum;
550 sum = 0;
551 while (ISDIGIT (*s))
553 int c = *s++ - '0';
554 if (sum > (ULONG_MAX - c) / 10)
555 return false;
556 sum = sum * 10 + c;
558 *p = s;
559 *val = sum;
560 return true;
563 /* If S points to a single valid modern od format string, put
564 a description of that format in *TSPEC, make *NEXT point at the
565 character following the just-decoded format (if *NEXT is non-NULL),
566 and return true. If S is not valid, don't modify *NEXT or *TSPEC,
567 give a diagnostic, and return false. For example, if S were
568 "d4afL" *NEXT would be set to "afL" and *TSPEC would be
570 fmt = SIGNED_DECIMAL;
571 size = INT or LONG; (whichever integral_type_size[4] resolves to)
572 print_function = print_int; (assuming size == INT)
573 field_width = 11;
574 fmt_string = "%*d";
576 pad_width is determined later, but is at least as large as the
577 number of fields printed per row.
578 S_ORIG is solely for reporting errors. It should be the full format
579 string argument.
582 static bool
583 decode_one_format (const char *s_orig, const char *s, const char **next,
584 struct tspec *tspec)
586 enum size_spec size_spec;
587 unsigned long int size;
588 enum output_format fmt;
589 const char *pre_fmt_string;
590 void (*print_function) (size_t, size_t, void const *, char const *,
591 int, int);
592 const char *p;
593 char c;
594 int field_width;
595 int precision;
597 assert (tspec != NULL);
599 switch (*s)
601 case 'd':
602 case 'o':
603 case 'u':
604 case 'x':
605 c = *s;
606 ++s;
607 switch (*s)
609 case 'C':
610 ++s;
611 size = sizeof (char);
612 break;
614 case 'S':
615 ++s;
616 size = sizeof (short int);
617 break;
619 case 'I':
620 ++s;
621 size = sizeof (int);
622 break;
624 case 'L':
625 ++s;
626 size = sizeof (long int);
627 break;
629 default:
630 if (! simple_strtoul (s, &p, &size))
632 /* The integer at P in S would overflow an unsigned long int.
633 A digit string that long is sufficiently odd looking
634 that the following diagnostic is sufficient. */
635 error (0, 0, _("invalid type string %s"), quote (s_orig));
636 return false;
638 if (p == s)
639 size = sizeof (int);
640 else
642 if (MAX_INTEGRAL_TYPE_SIZE < size
643 || integral_type_size[size] == NO_SIZE)
645 error (0, 0, _("invalid type string %s;\n\
646 this system doesn't provide a %lu-byte integral type"), quote (s_orig), size);
647 return false;
649 s = p;
651 break;
654 #define ISPEC_TO_FORMAT(Spec, Min_format, Long_format, Max_format) \
655 ((Spec) == LONG_LONG ? (Max_format) \
656 : ((Spec) == LONG ? (Long_format) \
657 : (Min_format))) \
659 size_spec = integral_type_size[size];
661 switch (c)
663 case 'd':
664 fmt = SIGNED_DECIMAL;
665 field_width = bytes_to_signed_dec_digits[size];
666 sprintf (tspec->fmt_string, "%%*%s",
667 ISPEC_TO_FORMAT (size_spec, "d", "ld", PRIdMAX));
668 break;
670 case 'o':
671 fmt = OCTAL;
672 sprintf (tspec->fmt_string, "%%*.%d%s",
673 (field_width = bytes_to_oct_digits[size]),
674 ISPEC_TO_FORMAT (size_spec, "o", "lo", PRIoMAX));
675 break;
677 case 'u':
678 fmt = UNSIGNED_DECIMAL;
679 field_width = bytes_to_unsigned_dec_digits[size];
680 sprintf (tspec->fmt_string, "%%*%s",
681 ISPEC_TO_FORMAT (size_spec, "u", "lu", PRIuMAX));
682 break;
684 case 'x':
685 fmt = HEXADECIMAL;
686 sprintf (tspec->fmt_string, "%%*.%d%s",
687 (field_width = bytes_to_hex_digits[size]),
688 ISPEC_TO_FORMAT (size_spec, "x", "lx", PRIxMAX));
689 break;
691 default:
692 abort ();
695 assert (strlen (tspec->fmt_string) < FMT_BYTES_ALLOCATED);
697 switch (size_spec)
699 case CHAR:
700 print_function = (fmt == SIGNED_DECIMAL
701 ? print_s_char
702 : print_char);
703 break;
705 case SHORT:
706 print_function = (fmt == SIGNED_DECIMAL
707 ? print_s_short
708 : print_short);
709 break;
711 case INT:
712 print_function = print_int;
713 break;
715 case LONG:
716 print_function = print_long;
717 break;
719 case LONG_LONG:
720 print_function = print_long_long;
721 break;
723 default:
724 abort ();
726 break;
728 case 'f':
729 fmt = FLOATING_POINT;
730 ++s;
731 switch (*s)
733 case 'F':
734 ++s;
735 size = sizeof (float);
736 break;
738 case 'D':
739 ++s;
740 size = sizeof (double);
741 break;
743 case 'L':
744 ++s;
745 size = sizeof (long double);
746 break;
748 default:
749 if (! simple_strtoul (s, &p, &size))
751 /* The integer at P in S would overflow an unsigned long int.
752 A digit string that long is sufficiently odd looking
753 that the following diagnostic is sufficient. */
754 error (0, 0, _("invalid type string %s"), quote (s_orig));
755 return false;
757 if (p == s)
758 size = sizeof (double);
759 else
761 if (size > MAX_FP_TYPE_SIZE
762 || fp_type_size[size] == NO_SIZE)
764 error (0, 0, _("invalid type string %s;\n\
765 this system doesn't provide a %lu-byte floating point type"),
766 quote (s_orig), size);
767 return false;
769 s = p;
771 break;
773 size_spec = fp_type_size[size];
775 switch (size_spec)
777 case FLOAT_SINGLE:
778 print_function = print_float;
779 /* FIXME - should we use %g instead of %e? */
780 pre_fmt_string = "%%*.%de";
781 precision = FLT_DIG;
782 break;
784 case FLOAT_DOUBLE:
785 print_function = print_double;
786 pre_fmt_string = "%%*.%de";
787 precision = DBL_DIG;
788 break;
790 case FLOAT_LONG_DOUBLE:
791 print_function = print_long_double;
792 pre_fmt_string = "%%*.%dLe";
793 precision = LDBL_DIG;
794 break;
796 default:
797 abort ();
800 field_width = precision + 8;
801 sprintf (tspec->fmt_string, pre_fmt_string, precision);
802 assert (strlen (tspec->fmt_string) < FMT_BYTES_ALLOCATED);
803 break;
805 case 'a':
806 ++s;
807 fmt = NAMED_CHARACTER;
808 size_spec = CHAR;
809 print_function = print_named_ascii;
810 field_width = 3;
811 break;
813 case 'c':
814 ++s;
815 fmt = CHARACTER;
816 size_spec = CHAR;
817 print_function = print_ascii;
818 field_width = 3;
819 break;
821 default:
822 error (0, 0, _("invalid character `%c' in type string %s"),
823 *s, quote (s_orig));
824 return false;
827 tspec->size = size_spec;
828 tspec->fmt = fmt;
829 tspec->print_function = print_function;
831 tspec->field_width = field_width;
832 tspec->hexl_mode_trailer = (*s == 'z');
833 if (tspec->hexl_mode_trailer)
834 s++;
836 if (next != NULL)
837 *next = s;
839 return true;
842 /* Given a list of one or more input filenames FILE_LIST, set the global
843 file pointer IN_STREAM and the global string INPUT_FILENAME to the
844 first one that can be successfully opened. Modify FILE_LIST to
845 reference the next filename in the list. A file name of "-" is
846 interpreted as standard input. If any file open fails, give an error
847 message and return false. */
849 static bool
850 open_next_file (void)
852 bool ok = true;
856 input_filename = *file_list;
857 if (input_filename == NULL)
858 return ok;
859 ++file_list;
861 if (STREQ (input_filename, "-"))
863 input_filename = _("standard input");
864 in_stream = stdin;
865 have_read_stdin = true;
866 if (O_BINARY && ! isatty (STDIN_FILENO))
867 xfreopen (NULL, "rb", stdin);
869 else
871 in_stream = fopen (input_filename, (O_BINARY ? "rb" : "r"));
872 if (in_stream == NULL)
874 error (0, errno, "%s", input_filename);
875 ok = false;
879 while (in_stream == NULL);
881 if (limit_bytes_to_format & !flag_dump_strings)
882 setvbuf (in_stream, NULL, _IONBF, 0);
884 return ok;
887 /* Test whether there have been errors on in_stream, and close it if
888 it is not standard input. Return false if there has been an error
889 on in_stream or stdout; return true otherwise. This function will
890 report more than one error only if both a read and a write error
891 have occurred. IN_ERRNO, if nonzero, is the error number
892 corresponding to the most recent action for IN_STREAM. */
894 static bool
895 check_and_close (int in_errno)
897 bool ok = true;
899 if (in_stream != NULL)
901 if (ferror (in_stream))
903 error (0, in_errno, _("%s: read error"), input_filename);
904 if (! STREQ (file_list[-1], "-"))
905 fclose (in_stream);
906 ok = false;
908 else if (! STREQ (file_list[-1], "-") && fclose (in_stream) != 0)
910 error (0, errno, "%s", input_filename);
911 ok = false;
914 in_stream = NULL;
917 if (ferror (stdout))
919 error (0, 0, _("write error"));
920 ok = false;
923 return ok;
926 /* Decode the modern od format string S. Append the decoded
927 representation to the global array SPEC, reallocating SPEC if
928 necessary. Return true if S is valid. */
930 static bool
931 decode_format_string (const char *s)
933 const char *s_orig = s;
934 assert (s != NULL);
936 while (*s != '\0')
938 const char *next;
940 if (n_specs_allocated <= n_specs)
941 spec = X2NREALLOC (spec, &n_specs_allocated);
943 if (! decode_one_format (s_orig, s, &next, &spec[n_specs]))
944 return false;
946 assert (s != next);
947 s = next;
948 ++n_specs;
951 return true;
954 /* Given a list of one or more input filenames FILE_LIST, set the global
955 file pointer IN_STREAM to position N_SKIP in the concatenation of
956 those files. If any file operation fails or if there are fewer than
957 N_SKIP bytes in the combined input, give an error message and return
958 false. When possible, use seek rather than read operations to
959 advance IN_STREAM. */
961 static bool
962 skip (uintmax_t n_skip)
964 bool ok = true;
965 int in_errno = 0;
967 if (n_skip == 0)
968 return true;
970 while (in_stream != NULL) /* EOF. */
972 struct stat file_stats;
974 /* First try seeking. For large offsets, this extra work is
975 worthwhile. If the offset is below some threshold it may be
976 more efficient to move the pointer by reading. There are two
977 issues when trying to seek:
978 - the file must be seekable.
979 - before seeking to the specified position, make sure
980 that the new position is in the current file.
981 Try to do that by getting file's size using fstat.
982 But that will work only for regular files. */
984 if (fstat (fileno (in_stream), &file_stats) == 0)
986 /* The st_size field is valid only for regular files
987 (and for symbolic links, which cannot occur here).
988 If the number of bytes left to skip is larger than
989 the size of the current file, we can decrement n_skip
990 and go on to the next file. Skip this optimization also
991 when st_size is 0, because some kernels report that
992 nonempty files in /proc have st_size == 0. */
993 if (S_ISREG (file_stats.st_mode) && 0 < file_stats.st_size)
995 if ((uintmax_t) file_stats.st_size < n_skip)
996 n_skip -= file_stats.st_size;
997 else
999 if (fseeko (in_stream, n_skip, SEEK_CUR) != 0)
1001 in_errno = errno;
1002 ok = false;
1004 n_skip = 0;
1008 /* If it's not a regular file with nonnegative size,
1009 position the file pointer by reading. */
1011 else
1013 char buf[BUFSIZ];
1014 size_t n_bytes_read, n_bytes_to_read = BUFSIZ;
1016 while (0 < n_skip)
1018 if (n_skip < n_bytes_to_read)
1019 n_bytes_to_read = n_skip;
1020 n_bytes_read = fread (buf, 1, n_bytes_to_read, in_stream);
1021 n_skip -= n_bytes_read;
1022 if (n_bytes_read != n_bytes_to_read)
1024 in_errno = errno;
1025 ok = false;
1026 n_skip = 0;
1027 break;
1032 if (n_skip == 0)
1033 break;
1036 else /* cannot fstat() file */
1038 error (0, errno, "%s", input_filename);
1039 ok = false;
1042 ok &= check_and_close (in_errno);
1044 ok &= open_next_file ();
1047 if (n_skip != 0)
1048 error (EXIT_FAILURE, 0, _("cannot skip past end of combined input"));
1050 return ok;
1053 static void
1054 format_address_none (uintmax_t address ATTRIBUTE_UNUSED, char c ATTRIBUTE_UNUSED)
1058 static void
1059 format_address_std (uintmax_t address, char c)
1061 char buf[MAX_ADDRESS_LENGTH + 2];
1062 char *p = buf + sizeof buf;
1063 char const *pbound;
1065 *--p = '\0';
1066 *--p = c;
1067 pbound = p - address_pad_len;
1069 /* Use a special case of the code for each base. This is measurably
1070 faster than generic code. */
1071 switch (address_base)
1073 case 8:
1075 *--p = '0' + (address & 7);
1076 while ((address >>= 3) != 0);
1077 break;
1079 case 10:
1081 *--p = '0' + (address % 10);
1082 while ((address /= 10) != 0);
1083 break;
1085 case 16:
1087 *--p = "0123456789abcdef"[address & 15];
1088 while ((address >>= 4) != 0);
1089 break;
1092 while (pbound < p)
1093 *--p = '0';
1095 fputs (p, stdout);
1098 static void
1099 format_address_paren (uintmax_t address, char c)
1101 putchar ('(');
1102 format_address_std (address, ')');
1103 if (c)
1104 putchar (c);
1107 static void
1108 format_address_label (uintmax_t address, char c)
1110 format_address_std (address, ' ');
1111 format_address_paren (address + pseudo_offset, c);
1114 /* Write N_BYTES bytes from CURR_BLOCK to standard output once for each
1115 of the N_SPEC format specs. CURRENT_OFFSET is the byte address of
1116 CURR_BLOCK in the concatenation of input files, and it is printed
1117 (optionally) only before the output line associated with the first
1118 format spec. When duplicate blocks are being abbreviated, the output
1119 for a sequence of identical input blocks is the output for the first
1120 block followed by an asterisk alone on a line. It is valid to compare
1121 the blocks PREV_BLOCK and CURR_BLOCK only when N_BYTES == BYTES_PER_BLOCK.
1122 That condition may be false only for the last input block. */
1124 static void
1125 write_block (uintmax_t current_offset, size_t n_bytes,
1126 const char *prev_block, const char *curr_block)
1128 static bool first = true;
1129 static bool prev_pair_equal = false;
1131 #define EQUAL_BLOCKS(b1, b2) (memcmp (b1, b2, bytes_per_block) == 0)
1133 if (abbreviate_duplicate_blocks
1134 && !first && n_bytes == bytes_per_block
1135 && EQUAL_BLOCKS (prev_block, curr_block))
1137 if (prev_pair_equal)
1139 /* The two preceding blocks were equal, and the current
1140 block is the same as the last one, so print nothing. */
1142 else
1144 printf ("*\n");
1145 prev_pair_equal = true;
1148 else
1150 size_t i;
1152 prev_pair_equal = false;
1153 for (i = 0; i < n_specs; i++)
1155 int datum_width = width_bytes[spec[i].size];
1156 int fields_per_block = bytes_per_block / datum_width;
1157 int blank_fields = (bytes_per_block - n_bytes) / datum_width;
1158 if (i == 0)
1159 format_address (current_offset, '\0');
1160 else
1161 printf ("%*s", address_pad_len, "");
1162 (*spec[i].print_function) (fields_per_block, blank_fields,
1163 curr_block, spec[i].fmt_string,
1164 spec[i].field_width, spec[i].pad_width);
1165 if (spec[i].hexl_mode_trailer)
1167 /* space-pad out to full line width, then dump the trailer */
1168 int field_width = spec[i].field_width;
1169 int pad_width = (spec[i].pad_width * blank_fields
1170 / fields_per_block);
1171 printf ("%*s", blank_fields * field_width + pad_width, "");
1172 dump_hexl_mode_trailer (n_bytes, curr_block);
1174 putchar ('\n');
1177 first = false;
1180 /* Read a single byte into *C from the concatenation of the input files
1181 named in the global array FILE_LIST. On the first call to this
1182 function, the global variable IN_STREAM is expected to be an open
1183 stream associated with the input file INPUT_FILENAME. If IN_STREAM
1184 is at end-of-file, close it and update the global variables IN_STREAM
1185 and INPUT_FILENAME so they correspond to the next file in the list.
1186 Then try to read a byte from the newly opened file. Repeat if
1187 necessary until EOF is reached for the last file in FILE_LIST, then
1188 set *C to EOF and return. Subsequent calls do likewise. Return
1189 true if successful. */
1191 static bool
1192 read_char (int *c)
1194 bool ok = true;
1196 *c = EOF;
1198 while (in_stream != NULL) /* EOF. */
1200 *c = fgetc (in_stream);
1202 if (*c != EOF)
1203 break;
1205 ok &= check_and_close (errno);
1207 ok &= open_next_file ();
1210 return ok;
1213 /* Read N bytes into BLOCK from the concatenation of the input files
1214 named in the global array FILE_LIST. On the first call to this
1215 function, the global variable IN_STREAM is expected to be an open
1216 stream associated with the input file INPUT_FILENAME. If all N
1217 bytes cannot be read from IN_STREAM, close IN_STREAM and update
1218 the global variables IN_STREAM and INPUT_FILENAME. Then try to
1219 read the remaining bytes from the newly opened file. Repeat if
1220 necessary until EOF is reached for the last file in FILE_LIST.
1221 On subsequent calls, don't modify BLOCK and return true. Set
1222 *N_BYTES_IN_BUFFER to the number of bytes read. If an error occurs,
1223 it will be detected through ferror when the stream is about to be
1224 closed. If there is an error, give a message but continue reading
1225 as usual and return false. Otherwise return true. */
1227 static bool
1228 read_block (size_t n, char *block, size_t *n_bytes_in_buffer)
1230 bool ok = true;
1232 assert (0 < n && n <= bytes_per_block);
1234 *n_bytes_in_buffer = 0;
1236 if (n == 0)
1237 return true;
1239 while (in_stream != NULL) /* EOF. */
1241 size_t n_needed;
1242 size_t n_read;
1244 n_needed = n - *n_bytes_in_buffer;
1245 n_read = fread (block + *n_bytes_in_buffer, 1, n_needed, in_stream);
1247 *n_bytes_in_buffer += n_read;
1249 if (n_read == n_needed)
1250 break;
1252 ok &= check_and_close (errno);
1254 ok &= open_next_file ();
1257 return ok;
1260 /* Return the least common multiple of the sizes associated
1261 with the format specs. */
1263 static int
1264 get_lcm (void)
1266 size_t i;
1267 int l_c_m = 1;
1269 for (i = 0; i < n_specs; i++)
1270 l_c_m = lcm (l_c_m, width_bytes[spec[i].size]);
1271 return l_c_m;
1274 /* If S is a valid traditional offset specification with an optional
1275 leading '+' return true and set *OFFSET to the offset it denotes. */
1277 static bool
1278 parse_old_offset (const char *s, uintmax_t *offset)
1280 int radix;
1282 if (*s == '\0')
1283 return false;
1285 /* Skip over any leading '+'. */
1286 if (s[0] == '+')
1287 ++s;
1289 /* Determine the radix we'll use to interpret S. If there is a `.',
1290 it's decimal, otherwise, if the string begins with `0X'or `0x',
1291 it's hexadecimal, else octal. */
1292 if (strchr (s, '.') != NULL)
1293 radix = 10;
1294 else
1296 if (s[0] == '0' && (s[1] == 'x' || s[1] == 'X'))
1297 radix = 16;
1298 else
1299 radix = 8;
1302 return xstrtoumax (s, NULL, radix, offset, "Bb") == LONGINT_OK;
1305 /* Read a chunk of size BYTES_PER_BLOCK from the input files, write the
1306 formatted block to standard output, and repeat until the specified
1307 maximum number of bytes has been read or until all input has been
1308 processed. If the last block read is smaller than BYTES_PER_BLOCK
1309 and its size is not a multiple of the size associated with a format
1310 spec, extend the input block with zero bytes until its length is a
1311 multiple of all format spec sizes. Write the final block. Finally,
1312 write on a line by itself the offset of the byte after the last byte
1313 read. Accumulate return values from calls to read_block and
1314 check_and_close, and if any was false, return false.
1315 Otherwise, return true. */
1317 static bool
1318 dump (void)
1320 char *block[2];
1321 uintmax_t current_offset;
1322 bool idx = false;
1323 bool ok = true;
1324 size_t n_bytes_read;
1326 block[0] = xnmalloc (2, bytes_per_block);
1327 block[1] = block[0] + bytes_per_block;
1329 current_offset = n_bytes_to_skip;
1331 if (limit_bytes_to_format)
1333 while (1)
1335 size_t n_needed;
1336 if (current_offset >= end_offset)
1338 n_bytes_read = 0;
1339 break;
1341 n_needed = MIN (end_offset - current_offset,
1342 (uintmax_t) bytes_per_block);
1343 ok &= read_block (n_needed, block[idx], &n_bytes_read);
1344 if (n_bytes_read < bytes_per_block)
1345 break;
1346 assert (n_bytes_read == bytes_per_block);
1347 write_block (current_offset, n_bytes_read,
1348 block[!idx], block[idx]);
1349 current_offset += n_bytes_read;
1350 idx = !idx;
1353 else
1355 while (1)
1357 ok &= read_block (bytes_per_block, block[idx], &n_bytes_read);
1358 if (n_bytes_read < bytes_per_block)
1359 break;
1360 assert (n_bytes_read == bytes_per_block);
1361 write_block (current_offset, n_bytes_read,
1362 block[!idx], block[idx]);
1363 current_offset += n_bytes_read;
1364 idx = !idx;
1368 if (n_bytes_read > 0)
1370 int l_c_m;
1371 size_t bytes_to_write;
1373 l_c_m = get_lcm ();
1375 /* Ensure zero-byte padding up to the smallest multiple of l_c_m that
1376 is at least as large as n_bytes_read. */
1377 bytes_to_write = l_c_m * ((n_bytes_read + l_c_m - 1) / l_c_m);
1379 memset (block[idx] + n_bytes_read, 0, bytes_to_write - n_bytes_read);
1380 write_block (current_offset, n_bytes_read, block[!idx], block[idx]);
1381 current_offset += n_bytes_read;
1384 format_address (current_offset, '\n');
1386 if (limit_bytes_to_format && current_offset >= end_offset)
1387 ok &= check_and_close (0);
1389 free (block[0]);
1391 return ok;
1394 /* STRINGS mode. Find each "string constant" in the input.
1395 A string constant is a run of at least `string_min' ASCII
1396 graphic (or formatting) characters terminated by a null.
1397 Based on a function written by Richard Stallman for a
1398 traditional version of od. Return true if successful. */
1400 static bool
1401 dump_strings (void)
1403 size_t bufsize = MAX (100, string_min);
1404 char *buf = xmalloc (bufsize);
1405 uintmax_t address = n_bytes_to_skip;
1406 bool ok = true;
1408 while (1)
1410 size_t i;
1411 int c;
1413 /* See if the next `string_min' chars are all printing chars. */
1414 tryline:
1416 if (limit_bytes_to_format
1417 && (end_offset < string_min || end_offset - string_min <= address))
1418 break;
1420 for (i = 0; i < string_min; i++)
1422 ok &= read_char (&c);
1423 address++;
1424 if (c < 0)
1426 free (buf);
1427 return ok;
1429 if (! isprint (c))
1430 /* Found a non-printing. Try again starting with next char. */
1431 goto tryline;
1432 buf[i] = c;
1435 /* We found a run of `string_min' printable characters.
1436 Now see if it is terminated with a null byte. */
1437 while (!limit_bytes_to_format || address < end_offset)
1439 if (i == bufsize)
1441 buf = X2REALLOC (buf, &bufsize);
1443 ok &= read_char (&c);
1444 address++;
1445 if (c < 0)
1447 free (buf);
1448 return ok;
1450 if (c == '\0')
1451 break; /* It is; print this string. */
1452 if (! isprint (c))
1453 goto tryline; /* It isn't; give up on this string. */
1454 buf[i++] = c; /* String continues; store it all. */
1457 /* If we get here, the string is all printable and null-terminated,
1458 so print it. It is all in `buf' and `i' is its length. */
1459 buf[i] = 0;
1460 format_address (address - i - 1, ' ');
1462 for (i = 0; (c = buf[i]); i++)
1464 switch (c)
1466 case '\a':
1467 fputs ("\\a", stdout);
1468 break;
1470 case '\b':
1471 fputs ("\\b", stdout);
1472 break;
1474 case '\f':
1475 fputs ("\\f", stdout);
1476 break;
1478 case '\n':
1479 fputs ("\\n", stdout);
1480 break;
1482 case '\r':
1483 fputs ("\\r", stdout);
1484 break;
1486 case '\t':
1487 fputs ("\\t", stdout);
1488 break;
1490 case '\v':
1491 fputs ("\\v", stdout);
1492 break;
1494 default:
1495 putc (c, stdout);
1498 putchar ('\n');
1501 /* We reach this point only if we search through
1502 (max_bytes_to_format - string_min) bytes before reaching EOF. */
1504 free (buf);
1506 ok &= check_and_close (0);
1507 return ok;
1511 main (int argc, char **argv)
1513 int n_files;
1514 size_t i;
1515 int l_c_m;
1516 size_t desired_width IF_LINT (= 0);
1517 bool modern = false;
1518 bool width_specified = false;
1519 bool ok = true;
1520 size_t width_per_block = 0;
1521 static char const multipliers[] = "bEGKkMmPTYZ0";
1523 /* The old-style `pseudo starting address' to be printed in parentheses
1524 after any true address. */
1525 uintmax_t pseudo_start IF_LINT (= 0);
1527 initialize_main (&argc, &argv);
1528 set_program_name (argv[0]);
1529 setlocale (LC_ALL, "");
1530 bindtextdomain (PACKAGE, LOCALEDIR);
1531 textdomain (PACKAGE);
1533 atexit (close_stdout);
1535 for (i = 0; i <= MAX_INTEGRAL_TYPE_SIZE; i++)
1536 integral_type_size[i] = NO_SIZE;
1538 integral_type_size[sizeof (char)] = CHAR;
1539 integral_type_size[sizeof (short int)] = SHORT;
1540 integral_type_size[sizeof (int)] = INT;
1541 integral_type_size[sizeof (long int)] = LONG;
1542 #if HAVE_UNSIGNED_LONG_LONG_INT
1543 /* If `long int' and `long long int' have the same size, it's fine
1544 to overwrite the entry for `long' with this one. */
1545 integral_type_size[sizeof (unsigned_long_long_int)] = LONG_LONG;
1546 #endif
1548 for (i = 0; i <= MAX_FP_TYPE_SIZE; i++)
1549 fp_type_size[i] = NO_SIZE;
1551 fp_type_size[sizeof (float)] = FLOAT_SINGLE;
1552 /* The array entry for `double' is filled in after that for `long double'
1553 so that if they are the same size, we avoid any overhead of
1554 long double computation in libc. */
1555 fp_type_size[sizeof (long double)] = FLOAT_LONG_DOUBLE;
1556 fp_type_size[sizeof (double)] = FLOAT_DOUBLE;
1558 n_specs = 0;
1559 n_specs_allocated = 0;
1560 spec = NULL;
1562 format_address = format_address_std;
1563 address_base = 8;
1564 address_pad_len = 7;
1565 flag_dump_strings = false;
1567 for (;;)
1569 uintmax_t tmp;
1570 enum strtol_error s_err;
1571 int oi = -1;
1572 int c = getopt_long (argc, argv, short_options, long_options, &oi);
1573 if (c == -1)
1574 break;
1576 switch (c)
1578 case 'A':
1579 modern = true;
1580 switch (optarg[0])
1582 case 'd':
1583 format_address = format_address_std;
1584 address_base = 10;
1585 address_pad_len = 7;
1586 break;
1587 case 'o':
1588 format_address = format_address_std;
1589 address_base = 8;
1590 address_pad_len = 7;
1591 break;
1592 case 'x':
1593 format_address = format_address_std;
1594 address_base = 16;
1595 address_pad_len = 6;
1596 break;
1597 case 'n':
1598 format_address = format_address_none;
1599 address_pad_len = 0;
1600 break;
1601 default:
1602 error (EXIT_FAILURE, 0,
1603 _("invalid output address radix `%c'; \
1604 it must be one character from [doxn]"),
1605 optarg[0]);
1606 break;
1608 break;
1610 case 'j':
1611 modern = true;
1612 s_err = xstrtoumax (optarg, NULL, 0, &n_bytes_to_skip, multipliers);
1613 if (s_err != LONGINT_OK)
1614 xstrtol_fatal (s_err, oi, c, long_options, optarg);
1615 break;
1617 case 'N':
1618 modern = true;
1619 limit_bytes_to_format = true;
1621 s_err = xstrtoumax (optarg, NULL, 0, &max_bytes_to_format,
1622 multipliers);
1623 if (s_err != LONGINT_OK)
1624 xstrtol_fatal (s_err, oi, c, long_options, optarg);
1625 break;
1627 case 'S':
1628 modern = true;
1629 if (optarg == NULL)
1630 string_min = 3;
1631 else
1633 s_err = xstrtoumax (optarg, NULL, 0, &tmp, multipliers);
1634 if (s_err != LONGINT_OK)
1635 xstrtol_fatal (s_err, oi, c, long_options, optarg);
1637 /* The minimum string length may be no larger than SIZE_MAX,
1638 since we may allocate a buffer of this size. */
1639 if (SIZE_MAX < tmp)
1640 error (EXIT_FAILURE, 0, _("%s is too large"), optarg);
1642 string_min = tmp;
1644 flag_dump_strings = true;
1645 break;
1647 case 't':
1648 modern = true;
1649 ok &= decode_format_string (optarg);
1650 break;
1652 case 'v':
1653 modern = true;
1654 abbreviate_duplicate_blocks = false;
1655 break;
1657 case TRADITIONAL_OPTION:
1658 traditional = true;
1659 break;
1661 /* The next several cases map the traditional format
1662 specification options to the corresponding modern format
1663 specs. GNU od accepts any combination of old- and
1664 new-style options. Format specification options accumulate.
1665 The obsolescent and undocumented formats are compatible
1666 with FreeBSD 4.10 od. */
1668 #define CASE_OLD_ARG(old_char,new_string) \
1669 case old_char: \
1670 ok &= decode_format_string (new_string); \
1671 break
1673 CASE_OLD_ARG ('a', "a");
1674 CASE_OLD_ARG ('b', "o1");
1675 CASE_OLD_ARG ('c', "c");
1676 CASE_OLD_ARG ('D', "u4"); /* obsolescent and undocumented */
1677 CASE_OLD_ARG ('d', "u2");
1678 case 'F': /* obsolescent and undocumented alias */
1679 CASE_OLD_ARG ('e', "fD"); /* obsolescent and undocumented */
1680 CASE_OLD_ARG ('f', "fF");
1681 case 'X': /* obsolescent and undocumented alias */
1682 CASE_OLD_ARG ('H', "x4"); /* obsolescent and undocumented */
1683 CASE_OLD_ARG ('i', "dI");
1684 case 'I': case 'L': /* obsolescent and undocumented aliases */
1685 CASE_OLD_ARG ('l', "dL");
1686 CASE_OLD_ARG ('O', "o4"); /* obsolesent and undocumented */
1687 case 'B': /* obsolescent and undocumented alias */
1688 CASE_OLD_ARG ('o', "o2");
1689 CASE_OLD_ARG ('s', "d2");
1690 case 'h': /* obsolescent and undocumented alias */
1691 CASE_OLD_ARG ('x', "x2");
1693 #undef CASE_OLD_ARG
1695 case 'w':
1696 modern = true;
1697 width_specified = true;
1698 if (optarg == NULL)
1700 desired_width = 32;
1702 else
1704 uintmax_t w_tmp;
1705 s_err = xstrtoumax (optarg, NULL, 10, &w_tmp, "");
1706 if (s_err != LONGINT_OK)
1707 xstrtol_fatal (s_err, oi, c, long_options, optarg);
1708 if (SIZE_MAX < w_tmp)
1709 error (EXIT_FAILURE, 0, _("%s is too large"), optarg);
1710 desired_width = w_tmp;
1712 break;
1714 case_GETOPT_HELP_CHAR;
1716 case_GETOPT_VERSION_CHAR (PROGRAM_NAME, AUTHORS);
1718 default:
1719 usage (EXIT_FAILURE);
1720 break;
1724 if (!ok)
1725 exit (EXIT_FAILURE);
1727 if (flag_dump_strings && n_specs > 0)
1728 error (EXIT_FAILURE, 0,
1729 _("no type may be specified when dumping strings"));
1731 n_files = argc - optind;
1733 /* If the --traditional option is used, there may be from
1734 0 to 3 remaining command line arguments; handle each case
1735 separately.
1736 od [file] [[+]offset[.][b] [[+]label[.][b]]]
1737 The offset and label have the same syntax.
1739 If --traditional is not given, and if no modern options are
1740 given, and if the offset begins with + or (if there are two
1741 operands) a digit, accept only this form, as per POSIX:
1742 od [file] [[+]offset[.][b]]
1745 if (!modern | traditional)
1747 uintmax_t o1;
1748 uintmax_t o2;
1750 switch (n_files)
1752 case 1:
1753 if ((traditional || argv[optind][0] == '+')
1754 && parse_old_offset (argv[optind], &o1))
1756 n_bytes_to_skip = o1;
1757 --n_files;
1758 ++argv;
1760 break;
1762 case 2:
1763 if ((traditional || argv[optind + 1][0] == '+'
1764 || ISDIGIT (argv[optind + 1][0]))
1765 && parse_old_offset (argv[optind + 1], &o2))
1767 if (traditional && parse_old_offset (argv[optind], &o1))
1769 n_bytes_to_skip = o1;
1770 flag_pseudo_start = true;
1771 pseudo_start = o2;
1772 argv += 2;
1773 n_files -= 2;
1775 else
1777 n_bytes_to_skip = o2;
1778 --n_files;
1779 argv[optind + 1] = argv[optind];
1780 ++argv;
1783 break;
1785 case 3:
1786 if (traditional
1787 && parse_old_offset (argv[optind + 1], &o1)
1788 && parse_old_offset (argv[optind + 2], &o2))
1790 n_bytes_to_skip = o1;
1791 flag_pseudo_start = true;
1792 pseudo_start = o2;
1793 argv[optind + 2] = argv[optind];
1794 argv += 2;
1795 n_files -= 2;
1797 break;
1800 if (traditional && 1 < n_files)
1802 error (0, 0, _("extra operand %s"), quote (argv[optind + 1]));
1803 error (0, 0, "%s\n",
1804 _("compatibility mode supports at most one file"));
1805 usage (EXIT_FAILURE);
1809 if (flag_pseudo_start)
1811 if (format_address == format_address_none)
1813 address_base = 8;
1814 address_pad_len = 7;
1815 format_address = format_address_paren;
1817 else
1818 format_address = format_address_label;
1821 if (limit_bytes_to_format)
1823 end_offset = n_bytes_to_skip + max_bytes_to_format;
1824 if (end_offset < n_bytes_to_skip)
1825 error (EXIT_FAILURE, 0, _("skip-bytes + read-bytes is too large"));
1828 if (n_specs == 0)
1829 decode_format_string ("oS");
1831 if (n_files > 0)
1833 /* Set the global pointer FILE_LIST so that it
1834 references the first file-argument on the command-line. */
1836 file_list = (char const *const *) &argv[optind];
1838 else
1840 /* No files were listed on the command line.
1841 Set the global pointer FILE_LIST so that it
1842 references the null-terminated list of one name: "-". */
1844 file_list = default_file_list;
1847 /* open the first input file */
1848 ok = open_next_file ();
1849 if (in_stream == NULL)
1850 goto cleanup;
1852 /* skip over any unwanted header bytes */
1853 ok &= skip (n_bytes_to_skip);
1854 if (in_stream == NULL)
1855 goto cleanup;
1857 pseudo_offset = (flag_pseudo_start ? pseudo_start - n_bytes_to_skip : 0);
1859 /* Compute output block length. */
1860 l_c_m = get_lcm ();
1862 if (width_specified)
1864 if (desired_width != 0 && desired_width % l_c_m == 0)
1865 bytes_per_block = desired_width;
1866 else
1868 error (0, 0, _("warning: invalid width %lu; using %d instead"),
1869 (unsigned long int) desired_width, l_c_m);
1870 bytes_per_block = l_c_m;
1873 else
1875 if (l_c_m < DEFAULT_BYTES_PER_BLOCK)
1876 bytes_per_block = l_c_m * (DEFAULT_BYTES_PER_BLOCK / l_c_m);
1877 else
1878 bytes_per_block = l_c_m;
1881 /* Compute padding necessary to align output block. */
1882 for (i = 0; i < n_specs; i++)
1884 int fields_per_block = bytes_per_block / width_bytes[spec[i].size];
1885 int block_width = (spec[i].field_width + 1) * fields_per_block;
1886 if (width_per_block < block_width)
1887 width_per_block = block_width;
1889 for (i = 0; i < n_specs; i++)
1891 int fields_per_block = bytes_per_block / width_bytes[spec[i].size];
1892 int block_width = spec[i].field_width * fields_per_block;
1893 spec[i].pad_width = width_per_block - block_width;
1896 #ifdef DEBUG
1897 printf ("lcm=%d, width_per_block=%zu\n", l_c_m, width_per_block);
1898 for (i = 0; i < n_specs; i++)
1900 int fields_per_block = bytes_per_block / width_bytes[spec[i].size];
1901 assert (bytes_per_block % width_bytes[spec[i].size] == 0);
1902 assert (1 <= spec[i].pad_width / fields_per_block);
1903 printf ("%d: fmt=\"%s\" in_width=%d out_width=%d pad=%d\n",
1904 i, spec[i].fmt_string, width_bytes[spec[i].size],
1905 spec[i].field_width, spec[i].pad_width);
1907 #endif
1909 ok &= (flag_dump_strings ? dump_strings () : dump ());
1911 cleanup:;
1913 if (have_read_stdin && fclose (stdin) == EOF)
1914 error (EXIT_FAILURE, errno, _("standard input"));
1916 exit (ok ? EXIT_SUCCESS : EXIT_FAILURE);