1 /* od -- dump files in octal and other formats
2 Copyright (C) 92, 1995-2008 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>
30 /* The official name of this program (e.g., no `g' prefix). */
31 #define PROGRAM_NAME "od"
33 #define AUTHORS proper_name ("Jim Meyering")
37 #ifdef HAVE_LONG_DOUBLE
38 typedef long double LONG_DOUBLE;
40 typedef double LONG_DOUBLE;
43 /* The default number of input bytes per output line. */
44 #define DEFAULT_BYTES_PER_BLOCK 16
46 /* The number of decimal digits of precision in a float. */
51 /* The number of decimal digits of precision in a double. */
56 #if HAVE_UNSIGNED_LONG_LONG_INT
57 typedef unsigned long long int unsigned_long_long_int;
59 /* This is just a place-holder to avoid a few `#if' directives.
60 In this case, the type isn't actually used. */
61 typedef unsigned long int unsigned_long_long_int;
72 /* FIXME: add INTMAX support, too */
90 /* The maximum number of bytes needed for a format string,
91 including the trailing null. */
95 MAX ((sizeof " %0" - 1 + INT_STRLEN_BOUND (int)
101 sizeof " %.Le" + 2 * INT_STRLEN_BOUND (int))
104 /* Each output format specification (from `-t spec' or from
105 old-style options) is represented by one of these structures. */
108 enum output_format fmt;
110 void (*print_function) (size_t, void const *, char const *);
111 char fmt_string[FMT_BYTES_ALLOCATED];
112 bool hexl_mode_trailer;
116 /* The name this program was run with. */
117 char const *program_name;
119 /* Convert the number of 8-bit bytes of a binary representation to
120 the number of characters (digits + sign if the type is signed)
121 required to represent the same quantity in the specified base/type.
122 For example, a 32-bit (4-byte) quantity may require a field width
123 as wide as the following for these types:
127 8 unsigned hexadecimal */
129 static unsigned int const bytes_to_oct_digits[] =
130 {0, 3, 6, 8, 11, 14, 16, 19, 22, 25, 27, 30, 32, 35, 38, 41, 43};
132 static unsigned int const bytes_to_signed_dec_digits[] =
133 {1, 4, 6, 8, 11, 13, 16, 18, 20, 23, 25, 28, 30, 33, 35, 37, 40};
135 static unsigned int const bytes_to_unsigned_dec_digits[] =
136 {0, 3, 5, 8, 10, 13, 15, 17, 20, 22, 25, 27, 29, 32, 34, 37, 39};
138 static unsigned int const bytes_to_hex_digits[] =
139 {0, 2, 4, 6, 8, 10, 12, 14, 16, 18, 20, 22, 24, 26, 28, 30, 32};
141 #define MAX_INTEGRAL_TYPE_SIZE sizeof (unsigned_long_long_int)
143 /* It'll be a while before we see integral types wider than 16 bytes,
144 but if/when it happens, this check will catch it. Without this check,
145 a wider type would provoke a buffer overrun. */
146 verify (MAX_INTEGRAL_TYPE_SIZE
147 < sizeof bytes_to_hex_digits / sizeof *bytes_to_hex_digits);
149 /* Make sure the other arrays have the same length. */
150 verify (sizeof bytes_to_oct_digits == sizeof bytes_to_signed_dec_digits);
151 verify (sizeof bytes_to_oct_digits == sizeof bytes_to_unsigned_dec_digits);
152 verify (sizeof bytes_to_oct_digits == sizeof bytes_to_hex_digits);
154 /* Convert enum size_spec to the size of the named type. */
155 static const int width_bytes[] =
162 sizeof (unsigned_long_long_int),
168 /* Ensure that for each member of `enum size_spec' there is an
169 initializer in the width_bytes array. */
170 verify (sizeof width_bytes / sizeof width_bytes[0] == N_SIZE_SPECS);
172 /* Names for some non-printing characters. */
173 static const char *const charname[33] =
175 "nul", "soh", "stx", "etx", "eot", "enq", "ack", "bel",
176 "bs", "ht", "nl", "vt", "ff", "cr", "so", "si",
177 "dle", "dc1", "dc2", "dc3", "dc4", "nak", "syn", "etb",
178 "can", "em", "sub", "esc", "fs", "gs", "rs", "us",
182 /* Address base (8, 10 or 16). */
183 static int address_base;
185 /* The number of octal digits required to represent the largest
187 #define MAX_ADDRESS_LENGTH \
188 ((sizeof (uintmax_t) * CHAR_BIT + CHAR_BIT - 1) / 3)
190 /* Width of a normal address. */
191 static int address_pad_len;
193 static size_t string_min;
194 static bool flag_dump_strings;
196 /* True if we should recognize the older non-option arguments
197 that specified at most one file and optional arguments specifying
198 offset and pseudo-start address. */
199 static bool traditional;
201 /* True if an old-style `pseudo-address' was specified. */
202 static bool flag_pseudo_start;
204 /* The difference between the old-style pseudo starting address and
205 the number of bytes to skip. */
206 static uintmax_t pseudo_offset;
208 /* Function that accepts an address and an optional following char,
209 and prints the address and char to stdout. */
210 static void (*format_address) (uintmax_t, char);
212 /* The number of input bytes to skip before formatting and writing. */
213 static uintmax_t n_bytes_to_skip = 0;
215 /* When false, MAX_BYTES_TO_FORMAT and END_OFFSET are ignored, and all
216 input is formatted. */
217 static bool limit_bytes_to_format = false;
219 /* The maximum number of bytes that will be formatted. */
220 static uintmax_t max_bytes_to_format;
222 /* The offset of the first byte after the last byte to be formatted. */
223 static uintmax_t end_offset;
225 /* When true and two or more consecutive blocks are equal, format
226 only the first block and output an asterisk alone on the following
227 line to indicate that identical blocks have been elided. */
228 static bool abbreviate_duplicate_blocks = true;
230 /* An array of specs describing how to format each input block. */
231 static struct tspec *spec;
233 /* The number of format specs. */
234 static size_t n_specs;
236 /* The allocated length of SPEC. */
237 static size_t n_specs_allocated;
239 /* The number of input bytes formatted per output line. It must be
240 a multiple of the least common multiple of the sizes associated with
241 the specified output types. It should be as large as possible, but
242 no larger than 16 -- unless specified with the -w option. */
243 static size_t bytes_per_block;
245 /* Human-readable representation of *file_list (for error messages).
246 It differs from file_list[-1] only when file_list[-1] is "-". */
247 static char const *input_filename;
249 /* A NULL-terminated list of the file-arguments from the command line. */
250 static char const *const *file_list;
252 /* Initializer for file_list if no file-arguments
253 were specified on the command line. */
254 static char const *const default_file_list[] = {"-", NULL};
256 /* The input stream associated with the current file. */
257 static FILE *in_stream;
259 /* If true, at least one of the files we read was standard input. */
260 static bool have_read_stdin;
262 /* Map the size in bytes to a type identifier. */
263 static enum size_spec integral_type_size[MAX_INTEGRAL_TYPE_SIZE + 1];
265 #define MAX_FP_TYPE_SIZE sizeof (LONG_DOUBLE)
266 static enum size_spec fp_type_size[MAX_FP_TYPE_SIZE + 1];
268 static char const short_options[] = "A:aBbcDdeFfHhIij:LlN:OoS:st:vw::Xx";
270 /* For long options that have no equivalent short option, use a
271 non-character as a pseudo short option, starting with CHAR_MAX + 1. */
274 TRADITIONAL_OPTION = CHAR_MAX + 1
277 static struct option const long_options[] =
279 {"skip-bytes", required_argument, NULL, 'j'},
280 {"address-radix", required_argument, NULL, 'A'},
281 {"read-bytes", required_argument, NULL, 'N'},
282 {"format", required_argument, NULL, 't'},
283 {"output-duplicates", no_argument, NULL, 'v'},
284 {"strings", optional_argument, NULL, 'S'},
285 {"traditional", no_argument, NULL, TRADITIONAL_OPTION},
286 {"width", optional_argument, NULL, 'w'},
288 {GETOPT_HELP_OPTION_DECL},
289 {GETOPT_VERSION_OPTION_DECL},
296 if (status != EXIT_SUCCESS)
297 fprintf (stderr, _("Try `%s --help' for more information.\n"),
302 Usage: %s [OPTION]... [FILE]...\n\
303 or: %s [-abcdfilosx]... [FILE] [[+]OFFSET[.][b]]\n\
304 or: %s --traditional [OPTION]... [FILE] [[+]OFFSET[.][b] [+][LABEL][.][b]]\n\
306 program_name, program_name, program_name);
308 Write an unambiguous representation, octal bytes by default,\n\
309 of FILE to standard output. With more than one FILE argument,\n\
310 concatenate them in the listed order to form the input.\n\
311 With no FILE, or when FILE is -, read standard input.\n\
315 All arguments to long options are mandatory for short options.\n\
318 -A, --address-radix=RADIX decide how file offsets are printed\n\
319 -j, --skip-bytes=BYTES skip BYTES input bytes first\n\
322 -N, --read-bytes=BYTES limit dump to BYTES input bytes\n\
323 -S, --strings[=BYTES] output strings of at least BYTES graphic chars\n\
324 -t, --format=TYPE select output format or formats\n\
325 -v, --output-duplicates do not use * to mark line suppression\n\
326 -w, --width[=BYTES] output BYTES bytes per output line\n\
327 --traditional accept arguments in traditional form\n\
329 fputs (HELP_OPTION_DESCRIPTION, stdout);
330 fputs (VERSION_OPTION_DESCRIPTION, stdout);
333 Traditional format specifications may be intermixed; they accumulate:\n\
334 -a same as -t a, select named characters, ignoring high-order bit\n\
335 -b same as -t o1, select octal bytes\n\
336 -c same as -t c, select ASCII characters or backslash escapes\n\
337 -d same as -t u2, select unsigned decimal 2-byte units\n\
340 -f same as -t fF, select floats\n\
341 -i same as -t dI, select decimal ints\n\
342 -l same as -t dL, select decimal longs\n\
343 -o same as -t o2, select octal 2-byte units\n\
344 -s same as -t d2, select decimal 2-byte units\n\
345 -x same as -t x2, select hexadecimal 2-byte units\n\
349 If first and second call formats both apply, the second format is assumed\n\
350 if the last operand begins with + or (if there are 2 operands) a digit.\n\
351 An OFFSET operand means -j OFFSET. LABEL is the pseudo-address\n\
352 at first byte printed, incremented when dump is progressing.\n\
353 For OFFSET and LABEL, a 0x or 0X prefix indicates hexadecimal;\n\
354 suffixes may be . for octal and b for multiply by 512.\n\
358 TYPE is made up of one or more of these specifications:\n\
360 a named character, ignoring high-order bit\n\
361 c ASCII character or backslash escape\n\
364 d[SIZE] signed decimal, SIZE bytes per integer\n\
365 f[SIZE] floating point, SIZE bytes per integer\n\
366 o[SIZE] octal, SIZE bytes per integer\n\
367 u[SIZE] unsigned decimal, SIZE bytes per integer\n\
368 x[SIZE] hexadecimal, SIZE bytes per integer\n\
372 SIZE is a number. For TYPE in doux, SIZE may also be C for\n\
373 sizeof(char), S for sizeof(short), I for sizeof(int) or L for\n\
374 sizeof(long). If TYPE is f, SIZE may also be F for sizeof(float), D\n\
375 for sizeof(double) or L for sizeof(long double).\n\
379 RADIX is d for decimal, o for octal, x for hexadecimal or n for none.\n\
380 BYTES is hexadecimal with 0x or 0X prefix, and may have a multiplier suffix:\n\
381 b 512, kB 1000, K 1024, MB 1000*1000, M 1024*1024,\n\
382 GB 1000*1000*1000, G 1024*1024*1024, and so on for T, P, E, Z, Y.\n\
383 Adding a z suffix to any type displays printable characters at the end of each\n\
387 --string without a number implies 3. --width without a number\n\
388 implies 32. By default, od uses -A o -t d2 -w16.\n\
390 emit_bug_reporting_address ();
395 /* Define the print functions. */
398 print_s_char (size_t n_bytes, void const *block, char const *fmt_string)
400 signed char const *p = block;
402 for (i = n_bytes / sizeof *p; i != 0; i--)
403 printf (fmt_string, *p++);
407 print_char (size_t n_bytes, void const *block, char const *fmt_string)
409 unsigned char const *p = block;
411 for (i = n_bytes / sizeof *p; i != 0; i--)
412 printf (fmt_string, *p++);
416 print_s_short (size_t n_bytes, void const *block, char const *fmt_string)
418 short int const *p = block;
420 for (i = n_bytes / sizeof *p; i != 0; i--)
421 printf (fmt_string, *p++);
425 print_short (size_t n_bytes, void const *block, char const *fmt_string)
427 unsigned short int const *p = block;
429 for (i = n_bytes / sizeof *p; i != 0; i--)
430 printf (fmt_string, *p++);
434 print_int (size_t n_bytes, void const *block, char const *fmt_string)
436 unsigned int const *p = block;
438 for (i = n_bytes / sizeof *p; i != 0; i--)
439 printf (fmt_string, *p++);
443 print_long (size_t n_bytes, void const *block, char const *fmt_string)
445 unsigned long int const *p = block;
447 for (i = n_bytes / sizeof *p; i != 0; i--)
448 printf (fmt_string, *p++);
452 print_long_long (size_t n_bytes, void const *block, char const *fmt_string)
454 unsigned_long_long_int const *p = block;
456 for (i = n_bytes / sizeof *p; i != 0; i--)
457 printf (fmt_string, *p++);
461 print_float (size_t n_bytes, void const *block, char const *fmt_string)
463 float const *p = block;
465 for (i = n_bytes / sizeof *p; i != 0; i--)
466 printf (fmt_string, *p++);
470 print_double (size_t n_bytes, void const *block, char const *fmt_string)
472 double const *p = block;
474 for (i = n_bytes / sizeof *p; i != 0; i--)
475 printf (fmt_string, *p++);
478 #ifdef HAVE_LONG_DOUBLE
480 print_long_double (size_t n_bytes, void const *block, char const *fmt_string)
482 long double const *p = block;
484 for (i = n_bytes / sizeof *p; i != 0; i--)
485 printf (fmt_string, *p++);
490 dump_hexl_mode_trailer (size_t n_bytes, const char *block)
493 fputs (" >", stdout);
494 for (i = n_bytes; i > 0; i--)
496 unsigned char c = *block++;
497 unsigned char c2 = (isprint (c) ? c : '.');
504 print_named_ascii (size_t n_bytes, void const *block,
505 const char *unused_fmt_string ATTRIBUTE_UNUSED)
507 unsigned char const *p = block;
509 for (i = n_bytes; i > 0; i--)
511 int masked_c = *p++ & 0x7f;
517 else if (masked_c <= 040)
518 s = charname[masked_c];
521 sprintf (buf, " %c", masked_c);
530 print_ascii (size_t n_bytes, void const *block,
531 const char *unused_fmt_string ATTRIBUTE_UNUSED)
533 unsigned char const *p = block;
535 for (i = n_bytes; i > 0; i--)
537 unsigned char c = *p++;
576 sprintf (buf, (isprint (c) ? " %c" : "%03o"), c);
584 /* Convert a null-terminated (possibly zero-length) string S to an
585 unsigned long integer value. If S points to a non-digit set *P to S,
586 *VAL to 0, and return true. Otherwise, accumulate the integer value of
587 the string of digits. If the string of digits represents a value
588 larger than ULONG_MAX, don't modify *VAL or *P and return false.
589 Otherwise, advance *P to the first non-digit after S, set *VAL to
590 the result of the conversion and return true. */
593 simple_strtoul (const char *s, const char **p, unsigned long int *val)
595 unsigned long int sum;
601 if (sum > (ULONG_MAX - c) / 10)
610 /* If S points to a single valid modern od format string, put
611 a description of that format in *TSPEC, make *NEXT point at the
612 character following the just-decoded format (if *NEXT is non-NULL),
613 and return true. If S is not valid, don't modify *NEXT or *TSPEC,
614 give a diagnostic, and return false. For example, if S were
615 "d4afL" *NEXT would be set to "afL" and *TSPEC would be
617 fmt = SIGNED_DECIMAL;
618 size = INT or LONG; (whichever integral_type_size[4] resolves to)
619 print_function = print_int; (assuming size == INT)
620 fmt_string = "%011d%c";
622 S_ORIG is solely for reporting errors. It should be the full format
627 decode_one_format (const char *s_orig, const char *s, const char **next,
630 enum size_spec size_spec;
631 unsigned long int size;
632 enum output_format fmt;
633 const char *pre_fmt_string;
634 void (*print_function) (size_t, void const *, char const *);
640 assert (tspec != NULL);
654 size = sizeof (char);
659 size = sizeof (short int);
669 size = sizeof (long int);
673 if (! simple_strtoul (s, &p, &size))
675 /* The integer at P in S would overflow an unsigned long int.
676 A digit string that long is sufficiently odd looking
677 that the following diagnostic is sufficient. */
678 error (0, 0, _("invalid type string %s"), quote (s_orig));
685 if (MAX_INTEGRAL_TYPE_SIZE < size
686 || integral_type_size[size] == NO_SIZE)
688 error (0, 0, _("invalid type string %s;\n\
689 this system doesn't provide a %lu-byte integral type"), quote (s_orig), size);
697 #define ISPEC_TO_FORMAT(Spec, Min_format, Long_format, Max_format) \
698 ((Spec) == LONG_LONG ? (Max_format) \
699 : ((Spec) == LONG ? (Long_format) \
702 size_spec = integral_type_size[size];
707 fmt = SIGNED_DECIMAL;
708 sprintf (tspec->fmt_string, " %%%d%s",
709 (field_width = bytes_to_signed_dec_digits[size]),
710 ISPEC_TO_FORMAT (size_spec, "d", "ld", PRIdMAX));
715 sprintf (tspec->fmt_string, " %%0%d%s",
716 (field_width = bytes_to_oct_digits[size]),
717 ISPEC_TO_FORMAT (size_spec, "o", "lo", PRIoMAX));
721 fmt = UNSIGNED_DECIMAL;
722 sprintf (tspec->fmt_string, " %%%d%s",
723 (field_width = bytes_to_unsigned_dec_digits[size]),
724 ISPEC_TO_FORMAT (size_spec, "u", "lu", PRIuMAX));
729 sprintf (tspec->fmt_string, " %%0%d%s",
730 (field_width = bytes_to_hex_digits[size]),
731 ISPEC_TO_FORMAT (size_spec, "x", "lx", PRIxMAX));
738 assert (strlen (tspec->fmt_string) < FMT_BYTES_ALLOCATED);
743 print_function = (fmt == SIGNED_DECIMAL
749 print_function = (fmt == SIGNED_DECIMAL
755 print_function = print_int;
759 print_function = print_long;
763 print_function = print_long_long;
772 fmt = FLOATING_POINT;
778 size = sizeof (float);
783 size = sizeof (double);
788 size = sizeof (LONG_DOUBLE);
792 if (! simple_strtoul (s, &p, &size))
794 /* The integer at P in S would overflow an unsigned long int.
795 A digit string that long is sufficiently odd looking
796 that the following diagnostic is sufficient. */
797 error (0, 0, _("invalid type string %s"), quote (s_orig));
801 size = sizeof (double);
804 if (size > MAX_FP_TYPE_SIZE
805 || fp_type_size[size] == NO_SIZE)
807 error (0, 0, _("invalid type string %s;\n\
808 this system doesn't provide a %lu-byte floating point type"),
809 quote (s_orig), size);
816 size_spec = fp_type_size[size];
821 print_function = print_float;
822 /* Don't use %#e; not all systems support it. */
823 pre_fmt_string = " %%%d.%de";
828 print_function = print_double;
829 pre_fmt_string = " %%%d.%de";
833 #ifdef HAVE_LONG_DOUBLE
834 case FLOAT_LONG_DOUBLE:
835 print_function = print_long_double;
836 pre_fmt_string = " %%%d.%dLe";
837 precision = LDBL_DIG;
845 field_width = precision + 8;
846 sprintf (tspec->fmt_string, pre_fmt_string, field_width, precision);
851 fmt = NAMED_CHARACTER;
853 print_function = print_named_ascii;
861 print_function = print_ascii;
866 error (0, 0, _("invalid character `%c' in type string %s"),
871 tspec->size = size_spec;
873 tspec->print_function = print_function;
875 tspec->field_width = field_width;
876 tspec->hexl_mode_trailer = (*s == 'z');
877 if (tspec->hexl_mode_trailer)
886 /* Given a list of one or more input filenames FILE_LIST, set the global
887 file pointer IN_STREAM and the global string INPUT_FILENAME to the
888 first one that can be successfully opened. Modify FILE_LIST to
889 reference the next filename in the list. A file name of "-" is
890 interpreted as standard input. If any file open fails, give an error
891 message and return false. */
894 open_next_file (void)
900 input_filename = *file_list;
901 if (input_filename == NULL)
905 if (STREQ (input_filename, "-"))
907 input_filename = _("standard input");
909 have_read_stdin = true;
910 if (O_BINARY && ! isatty (STDIN_FILENO))
911 freopen (NULL, "rb", stdin);
915 in_stream = fopen (input_filename, (O_BINARY ? "rb" : "r"));
916 if (in_stream == NULL)
918 error (0, errno, "%s", input_filename);
923 while (in_stream == NULL);
925 if (limit_bytes_to_format & !flag_dump_strings)
926 setvbuf (in_stream, NULL, _IONBF, 0);
931 /* Test whether there have been errors on in_stream, and close it if
932 it is not standard input. Return false if there has been an error
933 on in_stream or stdout; return true otherwise. This function will
934 report more than one error only if both a read and a write error
935 have occurred. IN_ERRNO, if nonzero, is the error number
936 corresponding to the most recent action for IN_STREAM. */
939 check_and_close (int in_errno)
943 if (in_stream != NULL)
945 if (ferror (in_stream))
947 error (0, in_errno, _("%s: read error"), input_filename);
948 if (! STREQ (file_list[-1], "-"))
952 else if (! STREQ (file_list[-1], "-") && fclose (in_stream) != 0)
954 error (0, errno, "%s", input_filename);
963 error (0, 0, _("write error"));
970 /* Decode the modern od format string S. Append the decoded
971 representation to the global array SPEC, reallocating SPEC if
972 necessary. Return true if S is valid. */
975 decode_format_string (const char *s)
977 const char *s_orig = s;
984 if (n_specs_allocated <= n_specs)
985 spec = X2NREALLOC (spec, &n_specs_allocated);
987 if (! decode_one_format (s_orig, s, &next, &spec[n_specs]))
998 /* Given a list of one or more input filenames FILE_LIST, set the global
999 file pointer IN_STREAM to position N_SKIP in the concatenation of
1000 those files. If any file operation fails or if there are fewer than
1001 N_SKIP bytes in the combined input, give an error message and return
1002 false. When possible, use seek rather than read operations to
1003 advance IN_STREAM. */
1006 skip (uintmax_t n_skip)
1014 while (in_stream != NULL) /* EOF. */
1016 struct stat file_stats;
1018 /* First try seeking. For large offsets, this extra work is
1019 worthwhile. If the offset is below some threshold it may be
1020 more efficient to move the pointer by reading. There are two
1021 issues when trying to seek:
1022 - the file must be seekable.
1023 - before seeking to the specified position, make sure
1024 that the new position is in the current file.
1025 Try to do that by getting file's size using fstat.
1026 But that will work only for regular files. */
1028 if (fstat (fileno (in_stream), &file_stats) == 0)
1030 /* The st_size field is valid only for regular files
1031 (and for symbolic links, which cannot occur here).
1032 If the number of bytes left to skip is larger than
1033 the size of the current file, we can decrement n_skip
1034 and go on to the next file. Skip this optimization also
1035 when st_size is 0, because some kernels report that
1036 nonempty files in /proc have st_size == 0. */
1037 if (S_ISREG (file_stats.st_mode) && 0 < file_stats.st_size)
1039 if ((uintmax_t) file_stats.st_size < n_skip)
1040 n_skip -= file_stats.st_size;
1043 if (fseeko (in_stream, n_skip, SEEK_CUR) != 0)
1052 /* If it's not a regular file with nonnegative size,
1053 position the file pointer by reading. */
1058 size_t n_bytes_read, n_bytes_to_read = BUFSIZ;
1062 if (n_skip < n_bytes_to_read)
1063 n_bytes_to_read = n_skip;
1064 n_bytes_read = fread (buf, 1, n_bytes_to_read, in_stream);
1065 n_skip -= n_bytes_read;
1066 if (n_bytes_read != n_bytes_to_read)
1080 else /* cannot fstat() file */
1082 error (0, errno, "%s", input_filename);
1086 ok &= check_and_close (in_errno);
1088 ok &= open_next_file ();
1092 error (EXIT_FAILURE, 0, _("cannot skip past end of combined input"));
1098 format_address_none (uintmax_t address ATTRIBUTE_UNUSED, char c ATTRIBUTE_UNUSED)
1103 format_address_std (uintmax_t address, char c)
1105 char buf[MAX_ADDRESS_LENGTH + 2];
1106 char *p = buf + sizeof buf;
1111 pbound = p - address_pad_len;
1113 /* Use a special case of the code for each base. This is measurably
1114 faster than generic code. */
1115 switch (address_base)
1119 *--p = '0' + (address & 7);
1120 while ((address >>= 3) != 0);
1125 *--p = '0' + (address % 10);
1126 while ((address /= 10) != 0);
1131 *--p = "0123456789abcdef"[address & 15];
1132 while ((address >>= 4) != 0);
1143 format_address_paren (uintmax_t address, char c)
1146 format_address_std (address, ')');
1152 format_address_label (uintmax_t address, char c)
1154 format_address_std (address, ' ');
1155 format_address_paren (address + pseudo_offset, c);
1158 /* Write N_BYTES bytes from CURR_BLOCK to standard output once for each
1159 of the N_SPEC format specs. CURRENT_OFFSET is the byte address of
1160 CURR_BLOCK in the concatenation of input files, and it is printed
1161 (optionally) only before the output line associated with the first
1162 format spec. When duplicate blocks are being abbreviated, the output
1163 for a sequence of identical input blocks is the output for the first
1164 block followed by an asterisk alone on a line. It is valid to compare
1165 the blocks PREV_BLOCK and CURR_BLOCK only when N_BYTES == BYTES_PER_BLOCK.
1166 That condition may be false only for the last input block -- and then
1167 only when it has not been padded to length BYTES_PER_BLOCK. */
1170 write_block (uintmax_t current_offset, size_t n_bytes,
1171 const char *prev_block, const char *curr_block)
1173 static bool first = true;
1174 static bool prev_pair_equal = false;
1176 #define EQUAL_BLOCKS(b1, b2) (memcmp (b1, b2, bytes_per_block) == 0)
1178 if (abbreviate_duplicate_blocks
1179 && !first && n_bytes == bytes_per_block
1180 && EQUAL_BLOCKS (prev_block, curr_block))
1182 if (prev_pair_equal)
1184 /* The two preceding blocks were equal, and the current
1185 block is the same as the last one, so print nothing. */
1190 prev_pair_equal = true;
1197 prev_pair_equal = false;
1198 for (i = 0; i < n_specs; i++)
1201 format_address (current_offset, '\0');
1203 printf ("%*s", address_pad_len, "");
1204 (*spec[i].print_function) (n_bytes, curr_block, spec[i].fmt_string);
1205 if (spec[i].hexl_mode_trailer)
1207 /* space-pad out to full line width, then dump the trailer */
1208 int datum_width = width_bytes[spec[i].size];
1209 int blank_fields = (bytes_per_block - n_bytes) / datum_width;
1210 int field_width = spec[i].field_width + 1;
1211 printf ("%*s", blank_fields * field_width, "");
1212 dump_hexl_mode_trailer (n_bytes, curr_block);
1220 /* Read a single byte into *C from the concatenation of the input files
1221 named in the global array FILE_LIST. On the first call to this
1222 function, the global variable IN_STREAM is expected to be an open
1223 stream associated with the input file INPUT_FILENAME. If IN_STREAM
1224 is at end-of-file, close it and update the global variables IN_STREAM
1225 and INPUT_FILENAME so they correspond to the next file in the list.
1226 Then try to read a byte from the newly opened file. Repeat if
1227 necessary until EOF is reached for the last file in FILE_LIST, then
1228 set *C to EOF and return. Subsequent calls do likewise. Return
1229 true if successful. */
1238 while (in_stream != NULL) /* EOF. */
1240 *c = fgetc (in_stream);
1245 ok &= check_and_close (errno);
1247 ok &= open_next_file ();
1253 /* Read N bytes into BLOCK from the concatenation of the input files
1254 named in the global array FILE_LIST. On the first call to this
1255 function, the global variable IN_STREAM is expected to be an open
1256 stream associated with the input file INPUT_FILENAME. If all N
1257 bytes cannot be read from IN_STREAM, close IN_STREAM and update
1258 the global variables IN_STREAM and INPUT_FILENAME. Then try to
1259 read the remaining bytes from the newly opened file. Repeat if
1260 necessary until EOF is reached for the last file in FILE_LIST.
1261 On subsequent calls, don't modify BLOCK and return true. Set
1262 *N_BYTES_IN_BUFFER to the number of bytes read. If an error occurs,
1263 it will be detected through ferror when the stream is about to be
1264 closed. If there is an error, give a message but continue reading
1265 as usual and return false. Otherwise return true. */
1268 read_block (size_t n, char *block, size_t *n_bytes_in_buffer)
1272 assert (0 < n && n <= bytes_per_block);
1274 *n_bytes_in_buffer = 0;
1279 while (in_stream != NULL) /* EOF. */
1284 n_needed = n - *n_bytes_in_buffer;
1285 n_read = fread (block + *n_bytes_in_buffer, 1, n_needed, in_stream);
1287 *n_bytes_in_buffer += n_read;
1289 if (n_read == n_needed)
1292 ok &= check_and_close (errno);
1294 ok &= open_next_file ();
1300 /* Return the least common multiple of the sizes associated
1301 with the format specs. */
1309 for (i = 0; i < n_specs; i++)
1310 l_c_m = lcm (l_c_m, width_bytes[spec[i].size]);
1314 /* If S is a valid traditional offset specification with an optional
1315 leading '+' return true and set *OFFSET to the offset it denotes. */
1318 parse_old_offset (const char *s, uintmax_t *offset)
1325 /* Skip over any leading '+'. */
1329 /* Determine the radix we'll use to interpret S. If there is a `.',
1330 it's decimal, otherwise, if the string begins with `0X'or `0x',
1331 it's hexadecimal, else octal. */
1332 if (strchr (s, '.') != NULL)
1336 if (s[0] == '0' && (s[1] == 'x' || s[1] == 'X'))
1342 return xstrtoumax (s, NULL, radix, offset, "Bb") == LONGINT_OK;
1345 /* Read a chunk of size BYTES_PER_BLOCK from the input files, write the
1346 formatted block to standard output, and repeat until the specified
1347 maximum number of bytes has been read or until all input has been
1348 processed. If the last block read is smaller than BYTES_PER_BLOCK
1349 and its size is not a multiple of the size associated with a format
1350 spec, extend the input block with zero bytes until its length is a
1351 multiple of all format spec sizes. Write the final block. Finally,
1352 write on a line by itself the offset of the byte after the last byte
1353 read. Accumulate return values from calls to read_block and
1354 check_and_close, and if any was false, return false.
1355 Otherwise, return true. */
1361 uintmax_t current_offset;
1364 size_t n_bytes_read;
1366 block[0] = xnmalloc (2, bytes_per_block);
1367 block[1] = block[0] + bytes_per_block;
1369 current_offset = n_bytes_to_skip;
1371 if (limit_bytes_to_format)
1376 if (current_offset >= end_offset)
1381 n_needed = MIN (end_offset - current_offset,
1382 (uintmax_t) bytes_per_block);
1383 ok &= read_block (n_needed, block[idx], &n_bytes_read);
1384 if (n_bytes_read < bytes_per_block)
1386 assert (n_bytes_read == bytes_per_block);
1387 write_block (current_offset, n_bytes_read,
1388 block[!idx], block[idx]);
1389 current_offset += n_bytes_read;
1397 ok &= read_block (bytes_per_block, block[idx], &n_bytes_read);
1398 if (n_bytes_read < bytes_per_block)
1400 assert (n_bytes_read == bytes_per_block);
1401 write_block (current_offset, n_bytes_read,
1402 block[!idx], block[idx]);
1403 current_offset += n_bytes_read;
1408 if (n_bytes_read > 0)
1411 size_t bytes_to_write;
1415 /* Make bytes_to_write the smallest multiple of l_c_m that
1416 is at least as large as n_bytes_read. */
1417 bytes_to_write = l_c_m * ((n_bytes_read + l_c_m - 1) / l_c_m);
1419 memset (block[idx] + n_bytes_read, 0, bytes_to_write - n_bytes_read);
1420 write_block (current_offset, bytes_to_write,
1421 block[!idx], block[idx]);
1422 current_offset += n_bytes_read;
1425 format_address (current_offset, '\n');
1427 if (limit_bytes_to_format && current_offset >= end_offset)
1428 ok &= check_and_close (0);
1435 /* STRINGS mode. Find each "string constant" in the input.
1436 A string constant is a run of at least `string_min' ASCII
1437 graphic (or formatting) characters terminated by a null.
1438 Based on a function written by Richard Stallman for a
1439 traditional version of od. Return true if successful. */
1444 size_t bufsize = MAX (100, string_min);
1445 char *buf = xmalloc (bufsize);
1446 uintmax_t address = n_bytes_to_skip;
1454 /* See if the next `string_min' chars are all printing chars. */
1457 if (limit_bytes_to_format
1458 && (end_offset < string_min || end_offset - string_min <= address))
1461 for (i = 0; i < string_min; i++)
1463 ok &= read_char (&c);
1471 /* Found a non-printing. Try again starting with next char. */
1476 /* We found a run of `string_min' printable characters.
1477 Now see if it is terminated with a null byte. */
1478 while (!limit_bytes_to_format || address < end_offset)
1482 buf = X2REALLOC (buf, &bufsize);
1484 ok &= read_char (&c);
1492 break; /* It is; print this string. */
1494 goto tryline; /* It isn't; give up on this string. */
1495 buf[i++] = c; /* String continues; store it all. */
1498 /* If we get here, the string is all printable and null-terminated,
1499 so print it. It is all in `buf' and `i' is its length. */
1501 format_address (address - i - 1, ' ');
1503 for (i = 0; (c = buf[i]); i++)
1508 fputs ("\\a", stdout);
1512 fputs ("\\b", stdout);
1516 fputs ("\\f", stdout);
1520 fputs ("\\n", stdout);
1524 fputs ("\\r", stdout);
1528 fputs ("\\t", stdout);
1532 fputs ("\\v", stdout);
1542 /* We reach this point only if we search through
1543 (max_bytes_to_format - string_min) bytes before reaching EOF. */
1547 ok &= check_and_close (0);
1552 main (int argc, char **argv)
1557 size_t desired_width IF_LINT (= 0);
1558 bool modern = false;
1559 bool width_specified = false;
1561 static char const multipliers[] = "bEGKkMmPTYZ0";
1563 /* The old-style `pseudo starting address' to be printed in parentheses
1564 after any true address. */
1565 uintmax_t pseudo_start IF_LINT (= 0);
1567 initialize_main (&argc, &argv);
1568 program_name = argv[0];
1569 setlocale (LC_ALL, "");
1570 bindtextdomain (PACKAGE, LOCALEDIR);
1571 textdomain (PACKAGE);
1573 atexit (close_stdout);
1575 for (i = 0; i <= MAX_INTEGRAL_TYPE_SIZE; i++)
1576 integral_type_size[i] = NO_SIZE;
1578 integral_type_size[sizeof (char)] = CHAR;
1579 integral_type_size[sizeof (short int)] = SHORT;
1580 integral_type_size[sizeof (int)] = INT;
1581 integral_type_size[sizeof (long int)] = LONG;
1582 #if HAVE_UNSIGNED_LONG_LONG_INT
1583 /* If `long int' and `long long int' have the same size, it's fine
1584 to overwrite the entry for `long' with this one. */
1585 integral_type_size[sizeof (unsigned_long_long_int)] = LONG_LONG;
1588 for (i = 0; i <= MAX_FP_TYPE_SIZE; i++)
1589 fp_type_size[i] = NO_SIZE;
1591 fp_type_size[sizeof (float)] = FLOAT_SINGLE;
1592 /* The array entry for `double' is filled in after that for LONG_DOUBLE
1593 so that if `long double' is the same type or if long double isn't
1594 supported FLOAT_LONG_DOUBLE will never be used. */
1595 fp_type_size[sizeof (LONG_DOUBLE)] = FLOAT_LONG_DOUBLE;
1596 fp_type_size[sizeof (double)] = FLOAT_DOUBLE;
1599 n_specs_allocated = 0;
1602 format_address = format_address_std;
1604 address_pad_len = 7;
1605 flag_dump_strings = false;
1610 enum strtol_error s_err;
1612 int c = getopt_long (argc, argv, short_options, long_options, &oi);
1623 format_address = format_address_std;
1625 address_pad_len = 7;
1628 format_address = format_address_std;
1630 address_pad_len = 7;
1633 format_address = format_address_std;
1635 address_pad_len = 6;
1638 format_address = format_address_none;
1639 address_pad_len = 0;
1642 error (EXIT_FAILURE, 0,
1643 _("invalid output address radix `%c'; \
1644 it must be one character from [doxn]"),
1652 s_err = xstrtoumax (optarg, NULL, 0, &n_bytes_to_skip, multipliers);
1653 if (s_err != LONGINT_OK)
1654 xstrtol_fatal (s_err, oi, c, long_options, optarg);
1659 limit_bytes_to_format = true;
1661 s_err = xstrtoumax (optarg, NULL, 0, &max_bytes_to_format,
1663 if (s_err != LONGINT_OK)
1664 xstrtol_fatal (s_err, oi, c, long_options, optarg);
1673 s_err = xstrtoumax (optarg, NULL, 0, &tmp, multipliers);
1674 if (s_err != LONGINT_OK)
1675 xstrtol_fatal (s_err, oi, c, long_options, optarg);
1677 /* The minimum string length may be no larger than SIZE_MAX,
1678 since we may allocate a buffer of this size. */
1680 error (EXIT_FAILURE, 0, _("%s is too large"), optarg);
1684 flag_dump_strings = true;
1689 ok &= decode_format_string (optarg);
1694 abbreviate_duplicate_blocks = false;
1697 case TRADITIONAL_OPTION:
1701 /* The next several cases map the traditional format
1702 specification options to the corresponding modern format
1703 specs. GNU od accepts any combination of old- and
1704 new-style options. Format specification options accumulate.
1705 The obsolescent and undocumented formats are compatible
1706 with FreeBSD 4.10 od. */
1708 #define CASE_OLD_ARG(old_char,new_string) \
1710 ok &= decode_format_string (new_string); \
1713 CASE_OLD_ARG ('a', "a");
1714 CASE_OLD_ARG ('b', "o1");
1715 CASE_OLD_ARG ('c', "c");
1716 CASE_OLD_ARG ('D', "u4"); /* obsolescent and undocumented */
1717 CASE_OLD_ARG ('d', "u2");
1718 case 'F': /* obsolescent and undocumented alias */
1719 CASE_OLD_ARG ('e', "fD"); /* obsolescent and undocumented */
1720 CASE_OLD_ARG ('f', "fF");
1721 case 'X': /* obsolescent and undocumented alias */
1722 CASE_OLD_ARG ('H', "x4"); /* obsolescent and undocumented */
1723 CASE_OLD_ARG ('i', "dI");
1724 case 'I': case 'L': /* obsolescent and undocumented aliases */
1725 CASE_OLD_ARG ('l', "dL");
1726 CASE_OLD_ARG ('O', "o4"); /* obsolesent and undocumented */
1727 case 'B': /* obsolescent and undocumented alias */
1728 CASE_OLD_ARG ('o', "o2");
1729 CASE_OLD_ARG ('s', "d2");
1730 case 'h': /* obsolescent and undocumented alias */
1731 CASE_OLD_ARG ('x', "x2");
1737 width_specified = true;
1745 s_err = xstrtoumax (optarg, NULL, 10, &w_tmp, "");
1746 if (s_err != LONGINT_OK)
1747 xstrtol_fatal (s_err, oi, c, long_options, optarg);
1748 if (SIZE_MAX < w_tmp)
1749 error (EXIT_FAILURE, 0, _("%s is too large"), optarg);
1750 desired_width = w_tmp;
1754 case_GETOPT_HELP_CHAR;
1756 case_GETOPT_VERSION_CHAR (PROGRAM_NAME, AUTHORS);
1759 usage (EXIT_FAILURE);
1765 exit (EXIT_FAILURE);
1767 if (flag_dump_strings && n_specs > 0)
1768 error (EXIT_FAILURE, 0,
1769 _("no type may be specified when dumping strings"));
1771 n_files = argc - optind;
1773 /* If the --traditional option is used, there may be from
1774 0 to 3 remaining command line arguments; handle each case
1776 od [file] [[+]offset[.][b] [[+]label[.][b]]]
1777 The offset and label have the same syntax.
1779 If --traditional is not given, and if no modern options are
1780 given, and if the offset begins with + or (if there are two
1781 operands) a digit, accept only this form, as per POSIX:
1782 od [file] [[+]offset[.][b]]
1785 if (!modern | traditional)
1793 if ((traditional || argv[optind][0] == '+')
1794 && parse_old_offset (argv[optind], &o1))
1796 n_bytes_to_skip = o1;
1803 if ((traditional || argv[optind + 1][0] == '+'
1804 || ISDIGIT (argv[optind + 1][0]))
1805 && parse_old_offset (argv[optind + 1], &o2))
1807 if (traditional && parse_old_offset (argv[optind], &o1))
1809 n_bytes_to_skip = o1;
1810 flag_pseudo_start = true;
1817 n_bytes_to_skip = o2;
1819 argv[optind + 1] = argv[optind];
1827 && parse_old_offset (argv[optind + 1], &o1)
1828 && parse_old_offset (argv[optind + 2], &o2))
1830 n_bytes_to_skip = o1;
1831 flag_pseudo_start = true;
1833 argv[optind + 2] = argv[optind];
1840 if (traditional && 1 < n_files)
1842 error (0, 0, _("extra operand %s"), quote (argv[optind + 1]));
1843 error (0, 0, "%s\n",
1844 _("Compatibility mode supports at most one file."));
1845 usage (EXIT_FAILURE);
1849 if (flag_pseudo_start)
1851 if (format_address == format_address_none)
1854 address_pad_len = 7;
1855 format_address = format_address_paren;
1858 format_address = format_address_label;
1861 if (limit_bytes_to_format)
1863 end_offset = n_bytes_to_skip + max_bytes_to_format;
1864 if (end_offset < n_bytes_to_skip)
1865 error (EXIT_FAILURE, 0, _("skip-bytes + read-bytes is too large"));
1869 decode_format_string ("oS");
1873 /* Set the global pointer FILE_LIST so that it
1874 references the first file-argument on the command-line. */
1876 file_list = (char const *const *) &argv[optind];
1880 /* No files were listed on the command line.
1881 Set the global pointer FILE_LIST so that it
1882 references the null-terminated list of one name: "-". */
1884 file_list = default_file_list;
1887 /* open the first input file */
1888 ok = open_next_file ();
1889 if (in_stream == NULL)
1892 /* skip over any unwanted header bytes */
1893 ok &= skip (n_bytes_to_skip);
1894 if (in_stream == NULL)
1897 pseudo_offset = (flag_pseudo_start ? pseudo_start - n_bytes_to_skip : 0);
1899 /* Compute output block length. */
1902 if (width_specified)
1904 if (desired_width != 0 && desired_width % l_c_m == 0)
1905 bytes_per_block = desired_width;
1908 error (0, 0, _("warning: invalid width %lu; using %d instead"),
1909 (unsigned long int) desired_width, l_c_m);
1910 bytes_per_block = l_c_m;
1915 if (l_c_m < DEFAULT_BYTES_PER_BLOCK)
1916 bytes_per_block = l_c_m * (DEFAULT_BYTES_PER_BLOCK / l_c_m);
1918 bytes_per_block = l_c_m;
1922 for (i = 0; i < n_specs; i++)
1924 printf (_("%d: fmt=\"%s\" width=%d\n"),
1925 i, spec[i].fmt_string, width_bytes[spec[i].size]);
1929 ok &= (flag_dump_strings ? dump_strings () : dump ());
1933 if (have_read_stdin && fclose (stdin) == EOF)
1934 error (EXIT_FAILURE, errno, _("standard input"));
1936 exit (ok ? EXIT_SUCCESS : EXIT_FAILURE);