1 /* od -- dump files in octal and other formats
2 Copyright (C) 1992, 1995-2011 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. */
24 #include <sys/types.h>
33 /* The official name of this program (e.g., no `g' prefix). */
34 #define PROGRAM_NAME "od"
36 #define AUTHORS proper_name ("Jim Meyering")
38 /* The default number of input bytes per output line. */
39 #define DEFAULT_BYTES_PER_BLOCK 16
41 #if HAVE_UNSIGNED_LONG_LONG_INT
42 typedef unsigned long long int unsigned_long_long_int;
44 /* This is just a place-holder to avoid a few `#if' directives.
45 In this case, the type isn't actually used. */
46 typedef unsigned long int unsigned_long_long_int;
57 /* FIXME: add INTMAX support, too */
75 #define MAX_INTEGRAL_TYPE_SIZE sizeof (unsigned_long_long_int)
77 /* The maximum number of bytes needed for a format string, including
78 the trailing nul. Each format string expects a variable amount of
79 padding (guaranteed to be at least 1 plus the field width), then an
80 element that will be formatted in the field. */
92 /* Ensure that our choice for FMT_BYTES_ALLOCATED is reasonable. */
93 verify (MAX_INTEGRAL_TYPE_SIZE * CHAR_BIT / 3 <= 99);
95 /* Each output format specification (from `-t spec' or from
96 old-style options) is represented by one of these structures. */
99 enum output_format fmt;
100 enum size_spec size; /* Type of input object. */
101 /* FIELDS is the number of fields per line, BLANK is the number of
102 fields to leave blank. WIDTH is width of one field, excluding
103 leading space, and PAD is total pad to divide among FIELDS.
104 PAD is at least as large as FIELDS. */
105 void (*print_function) (size_t fields, size_t blank, void const *data,
106 char const *fmt, int width, int pad);
107 char fmt_string[FMT_BYTES_ALLOCATED]; /* Of the style "%*d". */
108 bool hexl_mode_trailer;
109 int field_width; /* Minimum width of a field, excluding leading space. */
110 int pad_width; /* Total padding to be divided among fields. */
113 /* Convert the number of 8-bit bytes of a binary representation to
114 the number of characters (digits + sign if the type is signed)
115 required to represent the same quantity in the specified base/type.
116 For example, a 32-bit (4-byte) quantity may require a field width
117 as wide as the following for these types:
121 8 unsigned hexadecimal */
123 static unsigned int const bytes_to_oct_digits[] =
124 {0, 3, 6, 8, 11, 14, 16, 19, 22, 25, 27, 30, 32, 35, 38, 41, 43};
126 static unsigned int const bytes_to_signed_dec_digits[] =
127 {1, 4, 6, 8, 11, 13, 16, 18, 20, 23, 25, 28, 30, 33, 35, 37, 40};
129 static unsigned int const bytes_to_unsigned_dec_digits[] =
130 {0, 3, 5, 8, 10, 13, 15, 17, 20, 22, 25, 27, 29, 32, 34, 37, 39};
132 static unsigned int const bytes_to_hex_digits[] =
133 {0, 2, 4, 6, 8, 10, 12, 14, 16, 18, 20, 22, 24, 26, 28, 30, 32};
135 /* It'll be a while before we see integral types wider than 16 bytes,
136 but if/when it happens, this check will catch it. Without this check,
137 a wider type would provoke a buffer overrun. */
138 verify (MAX_INTEGRAL_TYPE_SIZE < ARRAY_CARDINALITY (bytes_to_hex_digits));
140 /* Make sure the other arrays have the same length. */
141 verify (sizeof bytes_to_oct_digits == sizeof bytes_to_signed_dec_digits);
142 verify (sizeof bytes_to_oct_digits == sizeof bytes_to_unsigned_dec_digits);
143 verify (sizeof bytes_to_oct_digits == sizeof bytes_to_hex_digits);
145 /* Convert enum size_spec to the size of the named type. */
146 static const int width_bytes[] =
153 sizeof (unsigned_long_long_int),
159 /* Ensure that for each member of `enum size_spec' there is an
160 initializer in the width_bytes array. */
161 verify (ARRAY_CARDINALITY (width_bytes) == N_SIZE_SPECS);
163 /* Names for some non-printing characters. */
164 static char const charname[33][4] =
166 "nul", "soh", "stx", "etx", "eot", "enq", "ack", "bel",
167 "bs", "ht", "nl", "vt", "ff", "cr", "so", "si",
168 "dle", "dc1", "dc2", "dc3", "dc4", "nak", "syn", "etb",
169 "can", "em", "sub", "esc", "fs", "gs", "rs", "us",
173 /* Address base (8, 10 or 16). */
174 static int address_base;
176 /* The number of octal digits required to represent the largest
178 #define MAX_ADDRESS_LENGTH \
179 ((sizeof (uintmax_t) * CHAR_BIT + CHAR_BIT - 1) / 3)
181 /* Width of a normal address. */
182 static int address_pad_len;
184 /* Minimum length when detecting --strings. */
185 static size_t string_min;
187 /* True when in --strings mode. */
188 static bool flag_dump_strings;
190 /* True if we should recognize the older non-option arguments
191 that specified at most one file and optional arguments specifying
192 offset and pseudo-start address. */
193 static bool traditional;
195 /* True if an old-style `pseudo-address' was specified. */
196 static bool flag_pseudo_start;
198 /* The difference between the old-style pseudo starting address and
199 the number of bytes to skip. */
200 static uintmax_t pseudo_offset;
202 /* Function that accepts an address and an optional following char,
203 and prints the address and char to stdout. */
204 static void (*format_address) (uintmax_t, char);
206 /* The number of input bytes to skip before formatting and writing. */
207 static uintmax_t n_bytes_to_skip = 0;
209 /* When false, MAX_BYTES_TO_FORMAT and END_OFFSET are ignored, and all
210 input is formatted. */
211 static bool limit_bytes_to_format = false;
213 /* The maximum number of bytes that will be formatted. */
214 static uintmax_t max_bytes_to_format;
216 /* The offset of the first byte after the last byte to be formatted. */
217 static uintmax_t end_offset;
219 /* When true and two or more consecutive blocks are equal, format
220 only the first block and output an asterisk alone on the following
221 line to indicate that identical blocks have been elided. */
222 static bool abbreviate_duplicate_blocks = true;
224 /* An array of specs describing how to format each input block. */
225 static struct tspec *spec;
227 /* The number of format specs. */
228 static size_t n_specs;
230 /* The allocated length of SPEC. */
231 static size_t n_specs_allocated;
233 /* The number of input bytes formatted per output line. It must be
234 a multiple of the least common multiple of the sizes associated with
235 the specified output types. It should be as large as possible, but
236 no larger than 16 -- unless specified with the -w option. */
237 static size_t bytes_per_block;
239 /* Human-readable representation of *file_list (for error messages).
240 It differs from file_list[-1] only when file_list[-1] is "-". */
241 static char const *input_filename;
243 /* A NULL-terminated list of the file-arguments from the command line. */
244 static char const *const *file_list;
246 /* Initializer for file_list if no file-arguments
247 were specified on the command line. */
248 static char const *const default_file_list[] = {"-", NULL};
250 /* The input stream associated with the current file. */
251 static FILE *in_stream;
253 /* If true, at least one of the files we read was standard input. */
254 static bool have_read_stdin;
256 /* Map the size in bytes to a type identifier. */
257 static enum size_spec integral_type_size[MAX_INTEGRAL_TYPE_SIZE + 1];
259 #define MAX_FP_TYPE_SIZE sizeof (long double)
260 static enum size_spec fp_type_size[MAX_FP_TYPE_SIZE + 1];
262 static char const short_options[] = "A:aBbcDdeFfHhIij:LlN:OoS:st:vw::Xx";
264 /* For long options that have no equivalent short option, use a
265 non-character as a pseudo short option, starting with CHAR_MAX + 1. */
268 TRADITIONAL_OPTION = CHAR_MAX + 1
271 static struct option const long_options[] =
273 {"skip-bytes", required_argument, NULL, 'j'},
274 {"address-radix", required_argument, NULL, 'A'},
275 {"read-bytes", required_argument, NULL, 'N'},
276 {"format", required_argument, NULL, 't'},
277 {"output-duplicates", no_argument, NULL, 'v'},
278 {"strings", optional_argument, NULL, 'S'},
279 {"traditional", no_argument, NULL, TRADITIONAL_OPTION},
280 {"width", optional_argument, NULL, 'w'},
282 {GETOPT_HELP_OPTION_DECL},
283 {GETOPT_VERSION_OPTION_DECL},
290 if (status != EXIT_SUCCESS)
291 fprintf (stderr, _("Try `%s --help' for more information.\n"),
296 Usage: %s [OPTION]... [FILE]...\n\
297 or: %s [-abcdfilosx]... [FILE] [[+]OFFSET[.][b]]\n\
298 or: %s --traditional [OPTION]... [FILE] [[+]OFFSET[.][b] [+][LABEL][.][b]]\n\
300 program_name, program_name, program_name);
302 Write an unambiguous representation, octal bytes by default,\n\
303 of FILE to standard output. With more than one FILE argument,\n\
304 concatenate them in the listed order to form the input.\n\
305 With no FILE, or when FILE is -, read standard input.\n\
309 All arguments to long options are mandatory for short options.\n\
312 -A, --address-radix=RADIX decide how file offsets are printed\n\
313 -j, --skip-bytes=BYTES skip BYTES input bytes first\n\
316 -N, --read-bytes=BYTES limit dump to BYTES input bytes\n\
317 -S, --strings[=BYTES] output strings of at least BYTES graphic chars\n\
318 -t, --format=TYPE select output format or formats\n\
319 -v, --output-duplicates do not use * to mark line suppression\n\
320 -w, --width[=BYTES] output BYTES bytes per output line\n\
321 --traditional accept arguments in traditional form\n\
323 fputs (HELP_OPTION_DESCRIPTION, stdout);
324 fputs (VERSION_OPTION_DESCRIPTION, stdout);
327 Traditional format specifications may be intermixed; they accumulate:\n\
328 -a same as -t a, select named characters, ignoring high-order bit\n\
329 -b same as -t o1, select octal bytes\n\
330 -c same as -t c, select ASCII characters or backslash escapes\n\
331 -d same as -t u2, select unsigned decimal 2-byte units\n\
334 -f same as -t fF, select floats\n\
335 -i same as -t dI, select decimal ints\n\
336 -l same as -t dL, select decimal longs\n\
337 -o same as -t o2, select octal 2-byte units\n\
338 -s same as -t d2, select decimal 2-byte units\n\
339 -x same as -t x2, select hexadecimal 2-byte units\n\
343 If first and second call formats both apply, the second format is assumed\n\
344 if the last operand begins with + or (if there are 2 operands) a digit.\n\
345 An OFFSET operand means -j OFFSET. LABEL is the pseudo-address\n\
346 at first byte printed, incremented when dump is progressing.\n\
347 For OFFSET and LABEL, a 0x or 0X prefix indicates hexadecimal;\n\
348 suffixes may be . for octal and b for multiply by 512.\n\
352 TYPE is made up of one or more of these specifications:\n\
354 a named character, ignoring high-order bit\n\
355 c ASCII character or backslash escape\n\
358 d[SIZE] signed decimal, SIZE bytes per integer\n\
359 f[SIZE] floating point, SIZE bytes per integer\n\
360 o[SIZE] octal, SIZE bytes per integer\n\
361 u[SIZE] unsigned decimal, SIZE bytes per integer\n\
362 x[SIZE] hexadecimal, SIZE bytes per integer\n\
366 SIZE is a number. For TYPE in doux, SIZE may also be C for\n\
367 sizeof(char), S for sizeof(short), I for sizeof(int) or L for\n\
368 sizeof(long). If TYPE is f, SIZE may also be F for sizeof(float), D\n\
369 for sizeof(double) or L for sizeof(long double).\n\
373 RADIX is d for decimal, o for octal, x for hexadecimal or n for none.\n\
374 BYTES is hexadecimal with 0x or 0X prefix, and may have a multiplier suffix:\n\
375 b 512, kB 1000, K 1024, MB 1000*1000, M 1024*1024,\n\
376 GB 1000*1000*1000, G 1024*1024*1024, and so on for T, P, E, Z, Y.\n\
377 Adding a z suffix to any type displays printable characters at the end of each\
382 Option --string without a number implies 3; option --width without a number\n\
383 implies 32. By default, od uses -A o -t oS -w16.\n\
385 emit_ancillary_info ();
390 /* Define the print functions. */
392 #define PRINT_FIELDS(N, T, FMT_STRING, ACTION) \
394 N (size_t fields, size_t blank, void const *block, \
395 char const *FMT_STRING, int width, int pad) \
397 T const *p = block; \
399 int pad_remaining = pad; \
400 for (i = fields; blank < i; i--) \
402 int next_pad = pad * (i - 1) / fields; \
403 int adjusted_width = pad_remaining - next_pad + width; \
406 pad_remaining = next_pad; \
410 #define PRINT_TYPE(N, T) \
411 PRINT_FIELDS (N, T, fmt_string, xprintf (fmt_string, adjusted_width, x))
413 #define PRINT_FLOATTYPE(N, T, FTOASTR, BUFSIZE) \
414 PRINT_FIELDS (N, T, fmt_string ATTRIBUTE_UNUSED, \
416 FTOASTR (buf, sizeof buf, 0, 0, x); \
417 xprintf ("%*s", adjusted_width, buf))
419 PRINT_TYPE (print_s_char, signed char)
420 PRINT_TYPE (print_char, unsigned char)
421 PRINT_TYPE (print_s_short, short int)
422 PRINT_TYPE (print_short, unsigned short int)
423 PRINT_TYPE (print_int, unsigned int)
424 PRINT_TYPE (print_long, unsigned long int)
425 PRINT_TYPE (print_long_long, unsigned_long_long_int)
427 PRINT_FLOATTYPE (print_float, float, ftoastr, FLT_BUFSIZE_BOUND)
428 PRINT_FLOATTYPE (print_double, double, dtoastr, DBL_BUFSIZE_BOUND)
429 PRINT_FLOATTYPE (print_long_double, long double, ldtoastr, LDBL_BUFSIZE_BOUND)
432 #undef PRINT_FLOATTYPE
435 dump_hexl_mode_trailer (size_t n_bytes, const char *block)
438 fputs (" >", stdout);
439 for (i = n_bytes; i > 0; i--)
441 unsigned char c = *block++;
442 unsigned char c2 = (isprint (c) ? c : '.');
449 print_named_ascii (size_t fields, size_t blank, void const *block,
450 const char *unused_fmt_string ATTRIBUTE_UNUSED,
453 unsigned char const *p = block;
455 int pad_remaining = pad;
456 for (i = fields; blank < i; i--)
458 int next_pad = pad * (i - 1) / fields;
459 int masked_c = *p++ & 0x7f;
465 else if (masked_c <= 040)
466 s = charname[masked_c];
474 xprintf ("%*s", pad_remaining - next_pad + width, s);
475 pad_remaining = next_pad;
480 print_ascii (size_t fields, size_t blank, void const *block,
481 const char *unused_fmt_string ATTRIBUTE_UNUSED, int width,
484 unsigned char const *p = block;
486 int pad_remaining = pad;
487 for (i = fields; blank < i; i--)
489 int next_pad = pad * (i - 1) / fields;
490 unsigned char c = *p++;
529 sprintf (buf, (isprint (c) ? "%c" : "%03o"), c);
533 xprintf ("%*s", pad_remaining - next_pad + width, s);
534 pad_remaining = next_pad;
538 /* Convert a null-terminated (possibly zero-length) string S to an
539 unsigned long integer value. If S points to a non-digit set *P to S,
540 *VAL to 0, and return true. Otherwise, accumulate the integer value of
541 the string of digits. If the string of digits represents a value
542 larger than ULONG_MAX, don't modify *VAL or *P and return false.
543 Otherwise, advance *P to the first non-digit after S, set *VAL to
544 the result of the conversion and return true. */
547 simple_strtoul (const char *s, const char **p, unsigned long int *val)
549 unsigned long int sum;
555 if (sum > (ULONG_MAX - c) / 10)
564 /* If S points to a single valid modern od format string, put
565 a description of that format in *TSPEC, make *NEXT point at the
566 character following the just-decoded format (if *NEXT is non-NULL),
567 and return true. If S is not valid, don't modify *NEXT or *TSPEC,
568 give a diagnostic, and return false. For example, if S were
569 "d4afL" *NEXT would be set to "afL" and *TSPEC would be
571 fmt = SIGNED_DECIMAL;
572 size = INT or LONG; (whichever integral_type_size[4] resolves to)
573 print_function = print_int; (assuming size == INT)
577 pad_width is determined later, but is at least as large as the
578 number of fields printed per row.
579 S_ORIG is solely for reporting errors. It should be the full format
584 decode_one_format (const char *s_orig, const char *s, const char **next,
587 enum size_spec size_spec;
588 unsigned long int size;
589 enum output_format fmt;
590 void (*print_function) (size_t, size_t, void const *, char const *,
596 assert (tspec != NULL);
610 size = sizeof (char);
615 size = sizeof (short int);
625 size = sizeof (long int);
629 if (! simple_strtoul (s, &p, &size))
631 /* The integer at P in S would overflow an unsigned long int.
632 A digit string that long is sufficiently odd looking
633 that the following diagnostic is sufficient. */
634 error (0, 0, _("invalid type string %s"), quote (s_orig));
641 if (MAX_INTEGRAL_TYPE_SIZE < size
642 || integral_type_size[size] == NO_SIZE)
644 error (0, 0, _("invalid type string %s;\n\
645 this system doesn't provide a %lu-byte integral type"), quote (s_orig), size);
653 #define ISPEC_TO_FORMAT(Spec, Min_format, Long_format, Max_format) \
654 ((Spec) == LONG_LONG ? (Max_format) \
655 : ((Spec) == LONG ? (Long_format) \
658 size_spec = integral_type_size[size];
663 fmt = SIGNED_DECIMAL;
664 field_width = bytes_to_signed_dec_digits[size];
665 sprintf (tspec->fmt_string, "%%*%s",
666 ISPEC_TO_FORMAT (size_spec, "d", "ld", PRIdMAX));
671 sprintf (tspec->fmt_string, "%%*.%d%s",
672 (field_width = bytes_to_oct_digits[size]),
673 ISPEC_TO_FORMAT (size_spec, "o", "lo", PRIoMAX));
677 fmt = UNSIGNED_DECIMAL;
678 field_width = bytes_to_unsigned_dec_digits[size];
679 sprintf (tspec->fmt_string, "%%*%s",
680 ISPEC_TO_FORMAT (size_spec, "u", "lu", PRIuMAX));
685 sprintf (tspec->fmt_string, "%%*.%d%s",
686 (field_width = bytes_to_hex_digits[size]),
687 ISPEC_TO_FORMAT (size_spec, "x", "lx", PRIxMAX));
694 assert (strlen (tspec->fmt_string) < FMT_BYTES_ALLOCATED);
699 print_function = (fmt == SIGNED_DECIMAL
705 print_function = (fmt == SIGNED_DECIMAL
711 print_function = print_int;
715 print_function = print_long;
719 print_function = print_long_long;
728 fmt = FLOATING_POINT;
734 size = sizeof (float);
739 size = sizeof (double);
744 size = sizeof (long double);
748 if (! simple_strtoul (s, &p, &size))
750 /* The integer at P in S would overflow an unsigned long int.
751 A digit string that long is sufficiently odd looking
752 that the following diagnostic is sufficient. */
753 error (0, 0, _("invalid type string %s"), quote (s_orig));
757 size = sizeof (double);
760 if (size > MAX_FP_TYPE_SIZE
761 || fp_type_size[size] == NO_SIZE)
763 error (0, 0, _("invalid type string %s;\n\
764 this system doesn't provide a %lu-byte floating point type"),
765 quote (s_orig), size);
772 size_spec = fp_type_size[size];
775 struct lconv const *locale = localeconv ();
776 size_t decimal_point_len =
777 (locale->decimal_point[0] ? strlen (locale->decimal_point) : 1);
782 print_function = print_float;
783 field_width = FLT_STRLEN_BOUND_L (decimal_point_len);
787 print_function = print_double;
788 field_width = DBL_STRLEN_BOUND_L (decimal_point_len);
791 case FLOAT_LONG_DOUBLE:
792 print_function = print_long_double;
793 field_width = LDBL_STRLEN_BOUND_L (decimal_point_len);
805 fmt = NAMED_CHARACTER;
807 print_function = print_named_ascii;
815 print_function = print_ascii;
820 error (0, 0, _("invalid character `%c' in type string %s"),
825 tspec->size = size_spec;
827 tspec->print_function = print_function;
829 tspec->field_width = field_width;
830 tspec->hexl_mode_trailer = (*s == 'z');
831 if (tspec->hexl_mode_trailer)
840 /* Given a list of one or more input filenames FILE_LIST, set the global
841 file pointer IN_STREAM and the global string INPUT_FILENAME to the
842 first one that can be successfully opened. Modify FILE_LIST to
843 reference the next filename in the list. A file name of "-" is
844 interpreted as standard input. If any file open fails, give an error
845 message and return false. */
848 open_next_file (void)
854 input_filename = *file_list;
855 if (input_filename == NULL)
859 if (STREQ (input_filename, "-"))
861 input_filename = _("standard input");
863 have_read_stdin = true;
864 if (O_BINARY && ! isatty (STDIN_FILENO))
865 xfreopen (NULL, "rb", stdin);
869 in_stream = fopen (input_filename, (O_BINARY ? "rb" : "r"));
870 if (in_stream == NULL)
872 error (0, errno, "%s", input_filename);
877 while (in_stream == NULL);
879 if (limit_bytes_to_format && !flag_dump_strings)
880 setvbuf (in_stream, NULL, _IONBF, 0);
885 /* Test whether there have been errors on in_stream, and close it if
886 it is not standard input. Return false if there has been an error
887 on in_stream or stdout; return true otherwise. This function will
888 report more than one error only if both a read and a write error
889 have occurred. IN_ERRNO, if nonzero, is the error number
890 corresponding to the most recent action for IN_STREAM. */
893 check_and_close (int in_errno)
897 if (in_stream != NULL)
899 if (ferror (in_stream))
901 error (0, in_errno, _("%s: read error"), input_filename);
902 if (! STREQ (file_list[-1], "-"))
906 else if (! STREQ (file_list[-1], "-") && fclose (in_stream) != 0)
908 error (0, errno, "%s", input_filename);
917 error (0, 0, _("write error"));
924 /* Decode the modern od format string S. Append the decoded
925 representation to the global array SPEC, reallocating SPEC if
926 necessary. Return true if S is valid. */
929 decode_format_string (const char *s)
931 const char *s_orig = s;
938 if (n_specs_allocated <= n_specs)
939 spec = X2NREALLOC (spec, &n_specs_allocated);
941 if (! decode_one_format (s_orig, s, &next, &spec[n_specs]))
952 /* Given a list of one or more input filenames FILE_LIST, set the global
953 file pointer IN_STREAM to position N_SKIP in the concatenation of
954 those files. If any file operation fails or if there are fewer than
955 N_SKIP bytes in the combined input, give an error message and return
956 false. When possible, use seek rather than read operations to
957 advance IN_STREAM. */
960 skip (uintmax_t n_skip)
968 while (in_stream != NULL) /* EOF. */
970 struct stat file_stats;
972 /* First try seeking. For large offsets, this extra work is
973 worthwhile. If the offset is below some threshold it may be
974 more efficient to move the pointer by reading. There are two
975 issues when trying to seek:
976 - the file must be seekable.
977 - before seeking to the specified position, make sure
978 that the new position is in the current file.
979 Try to do that by getting file's size using fstat.
980 But that will work only for regular files. */
982 if (fstat (fileno (in_stream), &file_stats) == 0)
984 /* The st_size field is valid only for regular files
985 (and for symbolic links, which cannot occur here).
986 If the number of bytes left to skip is larger than
987 the size of the current file, we can decrement n_skip
988 and go on to the next file. Skip this optimization also
989 when st_size is 0, because some kernels report that
990 nonempty files in /proc have st_size == 0. */
991 if (S_ISREG (file_stats.st_mode) && 0 < file_stats.st_size)
993 if ((uintmax_t) file_stats.st_size < n_skip)
994 n_skip -= file_stats.st_size;
997 if (fseeko (in_stream, n_skip, SEEK_CUR) != 0)
1006 /* If it's not a regular file with nonnegative size,
1007 position the file pointer by reading. */
1012 size_t n_bytes_read, n_bytes_to_read = BUFSIZ;
1016 if (n_skip < n_bytes_to_read)
1017 n_bytes_to_read = n_skip;
1018 n_bytes_read = fread (buf, 1, n_bytes_to_read, in_stream);
1019 n_skip -= n_bytes_read;
1020 if (n_bytes_read != n_bytes_to_read)
1034 else /* cannot fstat() file */
1036 error (0, errno, "%s", input_filename);
1040 ok &= check_and_close (in_errno);
1042 ok &= open_next_file ();
1046 error (EXIT_FAILURE, 0, _("cannot skip past end of combined input"));
1052 format_address_none (uintmax_t address ATTRIBUTE_UNUSED,
1053 char c ATTRIBUTE_UNUSED)
1058 format_address_std (uintmax_t address, char c)
1060 char buf[MAX_ADDRESS_LENGTH + 2];
1061 char *p = buf + sizeof buf;
1066 pbound = p - address_pad_len;
1068 /* Use a special case of the code for each base. This is measurably
1069 faster than generic code. */
1070 switch (address_base)
1074 *--p = '0' + (address & 7);
1075 while ((address >>= 3) != 0);
1080 *--p = '0' + (address % 10);
1081 while ((address /= 10) != 0);
1086 *--p = "0123456789abcdef"[address & 15];
1087 while ((address >>= 4) != 0);
1098 format_address_paren (uintmax_t address, char c)
1101 format_address_std (address, ')');
1107 format_address_label (uintmax_t address, char c)
1109 format_address_std (address, ' ');
1110 format_address_paren (address + pseudo_offset, c);
1113 /* Write N_BYTES bytes from CURR_BLOCK to standard output once for each
1114 of the N_SPEC format specs. CURRENT_OFFSET is the byte address of
1115 CURR_BLOCK in the concatenation of input files, and it is printed
1116 (optionally) only before the output line associated with the first
1117 format spec. When duplicate blocks are being abbreviated, the output
1118 for a sequence of identical input blocks is the output for the first
1119 block followed by an asterisk alone on a line. It is valid to compare
1120 the blocks PREV_BLOCK and CURR_BLOCK only when N_BYTES == BYTES_PER_BLOCK.
1121 That condition may be false only for the last input block. */
1124 write_block (uintmax_t current_offset, size_t n_bytes,
1125 const char *prev_block, const char *curr_block)
1127 static bool first = true;
1128 static bool prev_pair_equal = false;
1130 #define EQUAL_BLOCKS(b1, b2) (memcmp (b1, b2, bytes_per_block) == 0)
1132 if (abbreviate_duplicate_blocks
1133 && !first && n_bytes == bytes_per_block
1134 && EQUAL_BLOCKS (prev_block, curr_block))
1136 if (prev_pair_equal)
1138 /* The two preceding blocks were equal, and the current
1139 block is the same as the last one, so print nothing. */
1144 prev_pair_equal = true;
1151 prev_pair_equal = false;
1152 for (i = 0; i < n_specs; i++)
1154 int datum_width = width_bytes[spec[i].size];
1155 int fields_per_block = bytes_per_block / datum_width;
1156 int blank_fields = (bytes_per_block - n_bytes) / datum_width;
1158 format_address (current_offset, '\0');
1160 printf ("%*s", address_pad_len, "");
1161 (*spec[i].print_function) (fields_per_block, blank_fields,
1162 curr_block, spec[i].fmt_string,
1163 spec[i].field_width, spec[i].pad_width);
1164 if (spec[i].hexl_mode_trailer)
1166 /* space-pad out to full line width, then dump the trailer */
1167 int field_width = spec[i].field_width;
1168 int pad_width = (spec[i].pad_width * blank_fields
1169 / fields_per_block);
1170 printf ("%*s", blank_fields * field_width + pad_width, "");
1171 dump_hexl_mode_trailer (n_bytes, curr_block);
1179 /* Read a single byte into *C from the concatenation of the input files
1180 named in the global array FILE_LIST. On the first call to this
1181 function, the global variable IN_STREAM is expected to be an open
1182 stream associated with the input file INPUT_FILENAME. If IN_STREAM
1183 is at end-of-file, close it and update the global variables IN_STREAM
1184 and INPUT_FILENAME so they correspond to the next file in the list.
1185 Then try to read a byte from the newly opened file. Repeat if
1186 necessary until EOF is reached for the last file in FILE_LIST, then
1187 set *C to EOF and return. Subsequent calls do likewise. Return
1188 true if successful. */
1197 while (in_stream != NULL) /* EOF. */
1199 *c = fgetc (in_stream);
1204 ok &= check_and_close (errno);
1206 ok &= open_next_file ();
1212 /* Read N bytes into BLOCK from the concatenation of the input files
1213 named in the global array FILE_LIST. On the first call to this
1214 function, the global variable IN_STREAM is expected to be an open
1215 stream associated with the input file INPUT_FILENAME. If all N
1216 bytes cannot be read from IN_STREAM, close IN_STREAM and update
1217 the global variables IN_STREAM and INPUT_FILENAME. Then try to
1218 read the remaining bytes from the newly opened file. Repeat if
1219 necessary until EOF is reached for the last file in FILE_LIST.
1220 On subsequent calls, don't modify BLOCK and return true. Set
1221 *N_BYTES_IN_BUFFER to the number of bytes read. If an error occurs,
1222 it will be detected through ferror when the stream is about to be
1223 closed. If there is an error, give a message but continue reading
1224 as usual and return false. Otherwise return true. */
1227 read_block (size_t n, char *block, size_t *n_bytes_in_buffer)
1231 assert (0 < n && n <= bytes_per_block);
1233 *n_bytes_in_buffer = 0;
1238 while (in_stream != NULL) /* EOF. */
1243 n_needed = n - *n_bytes_in_buffer;
1244 n_read = fread (block + *n_bytes_in_buffer, 1, n_needed, in_stream);
1246 *n_bytes_in_buffer += n_read;
1248 if (n_read == n_needed)
1251 ok &= check_and_close (errno);
1253 ok &= open_next_file ();
1259 /* Return the least common multiple of the sizes associated
1260 with the format specs. */
1262 static int _GL_ATTRIBUTE_PURE
1268 for (i = 0; i < n_specs; i++)
1269 l_c_m = lcm (l_c_m, width_bytes[spec[i].size]);
1273 /* If S is a valid traditional offset specification with an optional
1274 leading '+' return true and set *OFFSET to the offset it denotes. */
1277 parse_old_offset (const char *s, uintmax_t *offset)
1284 /* Skip over any leading '+'. */
1288 /* Determine the radix we'll use to interpret S. If there is a `.',
1289 it's decimal, otherwise, if the string begins with `0X'or `0x',
1290 it's hexadecimal, else octal. */
1291 if (strchr (s, '.') != NULL)
1295 if (s[0] == '0' && (s[1] == 'x' || s[1] == 'X'))
1301 return xstrtoumax (s, NULL, radix, offset, "Bb") == LONGINT_OK;
1304 /* Read a chunk of size BYTES_PER_BLOCK from the input files, write the
1305 formatted block to standard output, and repeat until the specified
1306 maximum number of bytes has been read or until all input has been
1307 processed. If the last block read is smaller than BYTES_PER_BLOCK
1308 and its size is not a multiple of the size associated with a format
1309 spec, extend the input block with zero bytes until its length is a
1310 multiple of all format spec sizes. Write the final block. Finally,
1311 write on a line by itself the offset of the byte after the last byte
1312 read. Accumulate return values from calls to read_block and
1313 check_and_close, and if any was false, return false.
1314 Otherwise, return true. */
1320 uintmax_t current_offset;
1323 size_t n_bytes_read;
1325 block[0] = xnmalloc (2, bytes_per_block);
1326 block[1] = block[0] + bytes_per_block;
1328 current_offset = n_bytes_to_skip;
1330 if (limit_bytes_to_format)
1335 if (current_offset >= end_offset)
1340 n_needed = MIN (end_offset - current_offset,
1341 (uintmax_t) bytes_per_block);
1342 ok &= read_block (n_needed, block[idx], &n_bytes_read);
1343 if (n_bytes_read < bytes_per_block)
1345 assert (n_bytes_read == bytes_per_block);
1346 write_block (current_offset, n_bytes_read,
1347 block[!idx], block[idx]);
1348 current_offset += n_bytes_read;
1356 ok &= read_block (bytes_per_block, block[idx], &n_bytes_read);
1357 if (n_bytes_read < bytes_per_block)
1359 assert (n_bytes_read == bytes_per_block);
1360 write_block (current_offset, n_bytes_read,
1361 block[!idx], block[idx]);
1362 current_offset += n_bytes_read;
1367 if (n_bytes_read > 0)
1370 size_t bytes_to_write;
1374 /* Ensure zero-byte padding up to the smallest multiple of l_c_m that
1375 is at least as large as n_bytes_read. */
1376 bytes_to_write = l_c_m * ((n_bytes_read + l_c_m - 1) / l_c_m);
1378 memset (block[idx] + n_bytes_read, 0, bytes_to_write - n_bytes_read);
1379 write_block (current_offset, n_bytes_read, block[!idx], block[idx]);
1380 current_offset += n_bytes_read;
1383 format_address (current_offset, '\n');
1385 if (limit_bytes_to_format && current_offset >= end_offset)
1386 ok &= check_and_close (0);
1393 /* STRINGS mode. Find each "string constant" in the input.
1394 A string constant is a run of at least `string_min' ASCII
1395 graphic (or formatting) characters terminated by a null.
1396 Based on a function written by Richard Stallman for a
1397 traditional version of od. Return true if successful. */
1402 size_t bufsize = MAX (100, string_min);
1403 char *buf = xmalloc (bufsize);
1404 uintmax_t address = n_bytes_to_skip;
1412 /* See if the next `string_min' chars are all printing chars. */
1415 if (limit_bytes_to_format
1416 && (end_offset < string_min || end_offset - string_min <= address))
1419 for (i = 0; i < string_min; i++)
1421 ok &= read_char (&c);
1429 /* Found a non-printing. Try again starting with next char. */
1434 /* We found a run of `string_min' printable characters.
1435 Now see if it is terminated with a null byte. */
1436 while (!limit_bytes_to_format || address < end_offset)
1440 buf = X2REALLOC (buf, &bufsize);
1442 ok &= read_char (&c);
1450 break; /* It is; print this string. */
1452 goto tryline; /* It isn't; give up on this string. */
1453 buf[i++] = c; /* String continues; store it all. */
1456 /* If we get here, the string is all printable and null-terminated,
1457 so print it. It is all in `buf' and `i' is its length. */
1459 format_address (address - i - 1, ' ');
1461 for (i = 0; (c = buf[i]); i++)
1466 fputs ("\\a", stdout);
1470 fputs ("\\b", stdout);
1474 fputs ("\\f", stdout);
1478 fputs ("\\n", stdout);
1482 fputs ("\\r", stdout);
1486 fputs ("\\t", stdout);
1490 fputs ("\\v", stdout);
1500 /* We reach this point only if we search through
1501 (max_bytes_to_format - string_min) bytes before reaching EOF. */
1505 ok &= check_and_close (0);
1510 main (int argc, char **argv)
1515 size_t desired_width IF_LINT ( = 0);
1516 bool modern = false;
1517 bool width_specified = false;
1519 size_t width_per_block = 0;
1520 static char const multipliers[] = "bEGKkMmPTYZ0";
1522 /* The old-style `pseudo starting address' to be printed in parentheses
1523 after any true address. */
1524 uintmax_t pseudo_start IF_LINT ( = 0);
1526 initialize_main (&argc, &argv);
1527 set_program_name (argv[0]);
1528 setlocale (LC_ALL, "");
1529 bindtextdomain (PACKAGE, LOCALEDIR);
1530 textdomain (PACKAGE);
1532 atexit (close_stdout);
1534 for (i = 0; i <= MAX_INTEGRAL_TYPE_SIZE; i++)
1535 integral_type_size[i] = NO_SIZE;
1537 integral_type_size[sizeof (char)] = CHAR;
1538 integral_type_size[sizeof (short int)] = SHORT;
1539 integral_type_size[sizeof (int)] = INT;
1540 integral_type_size[sizeof (long int)] = LONG;
1541 #if HAVE_UNSIGNED_LONG_LONG_INT
1542 /* If `long int' and `long long int' have the same size, it's fine
1543 to overwrite the entry for `long' with this one. */
1544 integral_type_size[sizeof (unsigned_long_long_int)] = LONG_LONG;
1547 for (i = 0; i <= MAX_FP_TYPE_SIZE; i++)
1548 fp_type_size[i] = NO_SIZE;
1550 fp_type_size[sizeof (float)] = FLOAT_SINGLE;
1551 /* The array entry for `double' is filled in after that for `long double'
1552 so that if they are the same size, we avoid any overhead of
1553 long double computation in libc. */
1554 fp_type_size[sizeof (long double)] = FLOAT_LONG_DOUBLE;
1555 fp_type_size[sizeof (double)] = FLOAT_DOUBLE;
1558 n_specs_allocated = 0;
1561 format_address = format_address_std;
1563 address_pad_len = 7;
1564 flag_dump_strings = false;
1569 enum strtol_error s_err;
1571 int c = getopt_long (argc, argv, short_options, long_options, &oi);
1582 format_address = format_address_std;
1584 address_pad_len = 7;
1587 format_address = format_address_std;
1589 address_pad_len = 7;
1592 format_address = format_address_std;
1594 address_pad_len = 6;
1597 format_address = format_address_none;
1598 address_pad_len = 0;
1601 error (EXIT_FAILURE, 0,
1602 _("invalid output address radix `%c'; \
1603 it must be one character from [doxn]"),
1611 s_err = xstrtoumax (optarg, NULL, 0, &n_bytes_to_skip, multipliers);
1612 if (s_err != LONGINT_OK)
1613 xstrtol_fatal (s_err, oi, c, long_options, optarg);
1618 limit_bytes_to_format = true;
1620 s_err = xstrtoumax (optarg, NULL, 0, &max_bytes_to_format,
1622 if (s_err != LONGINT_OK)
1623 xstrtol_fatal (s_err, oi, c, long_options, optarg);
1632 s_err = xstrtoumax (optarg, NULL, 0, &tmp, multipliers);
1633 if (s_err != LONGINT_OK)
1634 xstrtol_fatal (s_err, oi, c, long_options, optarg);
1636 /* The minimum string length may be no larger than SIZE_MAX,
1637 since we may allocate a buffer of this size. */
1639 error (EXIT_FAILURE, 0, _("%s is too large"), optarg);
1643 flag_dump_strings = true;
1648 ok &= decode_format_string (optarg);
1653 abbreviate_duplicate_blocks = false;
1656 case TRADITIONAL_OPTION:
1660 /* The next several cases map the traditional format
1661 specification options to the corresponding modern format
1662 specs. GNU od accepts any combination of old- and
1663 new-style options. Format specification options accumulate.
1664 The obsolescent and undocumented formats are compatible
1665 with FreeBSD 4.10 od. */
1667 #define CASE_OLD_ARG(old_char,new_string) \
1669 ok &= decode_format_string (new_string); \
1672 CASE_OLD_ARG ('a', "a");
1673 CASE_OLD_ARG ('b', "o1");
1674 CASE_OLD_ARG ('c', "c");
1675 CASE_OLD_ARG ('D', "u4"); /* obsolescent and undocumented */
1676 CASE_OLD_ARG ('d', "u2");
1677 case 'F': /* obsolescent and undocumented alias */
1678 CASE_OLD_ARG ('e', "fD"); /* obsolescent and undocumented */
1679 CASE_OLD_ARG ('f', "fF");
1680 case 'X': /* obsolescent and undocumented alias */
1681 CASE_OLD_ARG ('H', "x4"); /* obsolescent and undocumented */
1682 CASE_OLD_ARG ('i', "dI");
1683 case 'I': case 'L': /* obsolescent and undocumented aliases */
1684 CASE_OLD_ARG ('l', "dL");
1685 CASE_OLD_ARG ('O', "o4"); /* obsolesent and undocumented */
1686 case 'B': /* obsolescent and undocumented alias */
1687 CASE_OLD_ARG ('o', "o2");
1688 CASE_OLD_ARG ('s', "d2");
1689 case 'h': /* obsolescent and undocumented alias */
1690 CASE_OLD_ARG ('x', "x2");
1696 width_specified = true;
1704 s_err = xstrtoumax (optarg, NULL, 10, &w_tmp, "");
1705 if (s_err != LONGINT_OK)
1706 xstrtol_fatal (s_err, oi, c, long_options, optarg);
1707 if (SIZE_MAX < w_tmp)
1708 error (EXIT_FAILURE, 0, _("%s is too large"), optarg);
1709 desired_width = w_tmp;
1713 case_GETOPT_HELP_CHAR;
1715 case_GETOPT_VERSION_CHAR (PROGRAM_NAME, AUTHORS);
1718 usage (EXIT_FAILURE);
1724 exit (EXIT_FAILURE);
1726 if (flag_dump_strings && n_specs > 0)
1727 error (EXIT_FAILURE, 0,
1728 _("no type may be specified when dumping strings"));
1730 n_files = argc - optind;
1732 /* If the --traditional option is used, there may be from
1733 0 to 3 remaining command line arguments; handle each case
1735 od [file] [[+]offset[.][b] [[+]label[.][b]]]
1736 The offset and label have the same syntax.
1738 If --traditional is not given, and if no modern options are
1739 given, and if the offset begins with + or (if there are two
1740 operands) a digit, accept only this form, as per POSIX:
1741 od [file] [[+]offset[.][b]]
1744 if (!modern || traditional)
1752 if ((traditional || argv[optind][0] == '+')
1753 && parse_old_offset (argv[optind], &o1))
1755 n_bytes_to_skip = o1;
1762 if ((traditional || argv[optind + 1][0] == '+'
1763 || ISDIGIT (argv[optind + 1][0]))
1764 && parse_old_offset (argv[optind + 1], &o2))
1766 if (traditional && parse_old_offset (argv[optind], &o1))
1768 n_bytes_to_skip = o1;
1769 flag_pseudo_start = true;
1776 n_bytes_to_skip = o2;
1778 argv[optind + 1] = argv[optind];
1786 && parse_old_offset (argv[optind + 1], &o1)
1787 && parse_old_offset (argv[optind + 2], &o2))
1789 n_bytes_to_skip = o1;
1790 flag_pseudo_start = true;
1792 argv[optind + 2] = argv[optind];
1799 if (traditional && 1 < n_files)
1801 error (0, 0, _("extra operand %s"), quote (argv[optind + 1]));
1803 _("compatibility mode supports at most one file"));
1804 usage (EXIT_FAILURE);
1808 if (flag_pseudo_start)
1810 if (format_address == format_address_none)
1813 address_pad_len = 7;
1814 format_address = format_address_paren;
1817 format_address = format_address_label;
1820 if (limit_bytes_to_format)
1822 end_offset = n_bytes_to_skip + max_bytes_to_format;
1823 if (end_offset < n_bytes_to_skip)
1824 error (EXIT_FAILURE, 0, _("skip-bytes + read-bytes is too large"));
1828 decode_format_string ("oS");
1832 /* Set the global pointer FILE_LIST so that it
1833 references the first file-argument on the command-line. */
1835 file_list = (char const *const *) &argv[optind];
1839 /* No files were listed on the command line.
1840 Set the global pointer FILE_LIST so that it
1841 references the null-terminated list of one name: "-". */
1843 file_list = default_file_list;
1846 /* open the first input file */
1847 ok = open_next_file ();
1848 if (in_stream == NULL)
1851 /* skip over any unwanted header bytes */
1852 ok &= skip (n_bytes_to_skip);
1853 if (in_stream == NULL)
1856 pseudo_offset = (flag_pseudo_start ? pseudo_start - n_bytes_to_skip : 0);
1858 /* Compute output block length. */
1861 if (width_specified)
1863 if (desired_width != 0 && desired_width % l_c_m == 0)
1864 bytes_per_block = desired_width;
1867 error (0, 0, _("warning: invalid width %lu; using %d instead"),
1868 (unsigned long int) desired_width, l_c_m);
1869 bytes_per_block = l_c_m;
1874 if (l_c_m < DEFAULT_BYTES_PER_BLOCK)
1875 bytes_per_block = l_c_m * (DEFAULT_BYTES_PER_BLOCK / l_c_m);
1877 bytes_per_block = l_c_m;
1880 /* Compute padding necessary to align output block. */
1881 for (i = 0; i < n_specs; i++)
1883 int fields_per_block = bytes_per_block / width_bytes[spec[i].size];
1884 int block_width = (spec[i].field_width + 1) * fields_per_block;
1885 if (width_per_block < block_width)
1886 width_per_block = block_width;
1888 for (i = 0; i < n_specs; i++)
1890 int fields_per_block = bytes_per_block / width_bytes[spec[i].size];
1891 int block_width = spec[i].field_width * fields_per_block;
1892 spec[i].pad_width = width_per_block - block_width;
1896 printf ("lcm=%d, width_per_block=%zu\n", l_c_m, width_per_block);
1897 for (i = 0; i < n_specs; i++)
1899 int fields_per_block = bytes_per_block / width_bytes[spec[i].size];
1900 assert (bytes_per_block % width_bytes[spec[i].size] == 0);
1901 assert (1 <= spec[i].pad_width / fields_per_block);
1902 printf ("%d: fmt=\"%s\" in_width=%d out_width=%d pad=%d\n",
1903 i, spec[i].fmt_string, width_bytes[spec[i].size],
1904 spec[i].field_width, spec[i].pad_width);
1908 ok &= (flag_dump_strings ? dump_strings () : dump ());
1912 if (have_read_stdin && fclose (stdin) == EOF)
1913 error (EXIT_FAILURE, errno, _("standard input"));
1915 exit (ok ? EXIT_SUCCESS : EXIT_FAILURE);