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>
31 /* The official name of this program (e.g., no `g' prefix). */
32 #define PROGRAM_NAME "od"
34 #define AUTHORS proper_name ("Jim Meyering")
38 /* The default number of input bytes per output line. */
39 #define DEFAULT_BYTES_PER_BLOCK 16
41 /* The number of decimal digits of precision in a float. */
46 /* The number of decimal digits of precision in a double. */
51 #if HAVE_UNSIGNED_LONG_LONG_INT
52 typedef unsigned long long int unsigned_long_long_int;
54 /* This is just a place-holder to avoid a few `#if' directives.
55 In this case, the type isn't actually used. */
56 typedef unsigned long int unsigned_long_long_int;
67 /* FIXME: add INTMAX support, too */
85 /* The maximum number of bytes needed for a format string,
86 including the trailing null. */
90 MAX ((sizeof " %0" - 1 + INT_STRLEN_BOUND (int)
96 sizeof " %.Le" + 2 * INT_STRLEN_BOUND (int))
99 /* Each output format specification (from `-t spec' or from
100 old-style options) is represented by one of these structures. */
103 enum output_format fmt;
105 void (*print_function) (size_t, void const *, char const *);
106 char fmt_string[FMT_BYTES_ALLOCATED];
107 bool hexl_mode_trailer;
111 /* Convert the number of 8-bit bytes of a binary representation to
112 the number of characters (digits + sign if the type is signed)
113 required to represent the same quantity in the specified base/type.
114 For example, a 32-bit (4-byte) quantity may require a field width
115 as wide as the following for these types:
119 8 unsigned hexadecimal */
121 static unsigned int const bytes_to_oct_digits[] =
122 {0, 3, 6, 8, 11, 14, 16, 19, 22, 25, 27, 30, 32, 35, 38, 41, 43};
124 static unsigned int const bytes_to_signed_dec_digits[] =
125 {1, 4, 6, 8, 11, 13, 16, 18, 20, 23, 25, 28, 30, 33, 35, 37, 40};
127 static unsigned int const bytes_to_unsigned_dec_digits[] =
128 {0, 3, 5, 8, 10, 13, 15, 17, 20, 22, 25, 27, 29, 32, 34, 37, 39};
130 static unsigned int const bytes_to_hex_digits[] =
131 {0, 2, 4, 6, 8, 10, 12, 14, 16, 18, 20, 22, 24, 26, 28, 30, 32};
133 #define MAX_INTEGRAL_TYPE_SIZE sizeof (unsigned_long_long_int)
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
139 < sizeof bytes_to_hex_digits / sizeof *bytes_to_hex_digits);
141 /* Make sure the other arrays have the same length. */
142 verify (sizeof bytes_to_oct_digits == sizeof bytes_to_signed_dec_digits);
143 verify (sizeof bytes_to_oct_digits == sizeof bytes_to_unsigned_dec_digits);
144 verify (sizeof bytes_to_oct_digits == sizeof bytes_to_hex_digits);
146 /* Convert enum size_spec to the size of the named type. */
147 static const int width_bytes[] =
154 sizeof (unsigned_long_long_int),
160 /* Ensure that for each member of `enum size_spec' there is an
161 initializer in the width_bytes array. */
162 verify (sizeof width_bytes / sizeof width_bytes[0] == N_SIZE_SPECS);
164 /* Names for some non-printing characters. */
165 static const char *const charname[33] =
167 "nul", "soh", "stx", "etx", "eot", "enq", "ack", "bel",
168 "bs", "ht", "nl", "vt", "ff", "cr", "so", "si",
169 "dle", "dc1", "dc2", "dc3", "dc4", "nak", "syn", "etb",
170 "can", "em", "sub", "esc", "fs", "gs", "rs", "us",
174 /* Address base (8, 10 or 16). */
175 static int address_base;
177 /* The number of octal digits required to represent the largest
179 #define MAX_ADDRESS_LENGTH \
180 ((sizeof (uintmax_t) * CHAR_BIT + CHAR_BIT - 1) / 3)
182 /* Width of a normal address. */
183 static int address_pad_len;
185 static size_t string_min;
186 static bool flag_dump_strings;
188 /* True if we should recognize the older non-option arguments
189 that specified at most one file and optional arguments specifying
190 offset and pseudo-start address. */
191 static bool traditional;
193 /* True if an old-style `pseudo-address' was specified. */
194 static bool flag_pseudo_start;
196 /* The difference between the old-style pseudo starting address and
197 the number of bytes to skip. */
198 static uintmax_t pseudo_offset;
200 /* Function that accepts an address and an optional following char,
201 and prints the address and char to stdout. */
202 static void (*format_address) (uintmax_t, char);
204 /* The number of input bytes to skip before formatting and writing. */
205 static uintmax_t n_bytes_to_skip = 0;
207 /* When false, MAX_BYTES_TO_FORMAT and END_OFFSET are ignored, and all
208 input is formatted. */
209 static bool limit_bytes_to_format = false;
211 /* The maximum number of bytes that will be formatted. */
212 static uintmax_t max_bytes_to_format;
214 /* The offset of the first byte after the last byte to be formatted. */
215 static uintmax_t end_offset;
217 /* When true and two or more consecutive blocks are equal, format
218 only the first block and output an asterisk alone on the following
219 line to indicate that identical blocks have been elided. */
220 static bool abbreviate_duplicate_blocks = true;
222 /* An array of specs describing how to format each input block. */
223 static struct tspec *spec;
225 /* The number of format specs. */
226 static size_t n_specs;
228 /* The allocated length of SPEC. */
229 static size_t n_specs_allocated;
231 /* The number of input bytes formatted per output line. It must be
232 a multiple of the least common multiple of the sizes associated with
233 the specified output types. It should be as large as possible, but
234 no larger than 16 -- unless specified with the -w option. */
235 static size_t bytes_per_block;
237 /* Human-readable representation of *file_list (for error messages).
238 It differs from file_list[-1] only when file_list[-1] is "-". */
239 static char const *input_filename;
241 /* A NULL-terminated list of the file-arguments from the command line. */
242 static char const *const *file_list;
244 /* Initializer for file_list if no file-arguments
245 were specified on the command line. */
246 static char const *const default_file_list[] = {"-", NULL};
248 /* The input stream associated with the current file. */
249 static FILE *in_stream;
251 /* If true, at least one of the files we read was standard input. */
252 static bool have_read_stdin;
254 /* Map the size in bytes to a type identifier. */
255 static enum size_spec integral_type_size[MAX_INTEGRAL_TYPE_SIZE + 1];
257 #define MAX_FP_TYPE_SIZE sizeof (long double)
258 static enum size_spec fp_type_size[MAX_FP_TYPE_SIZE + 1];
260 static char const short_options[] = "A:aBbcDdeFfHhIij:LlN:OoS:st:vw::Xx";
262 /* For long options that have no equivalent short option, use a
263 non-character as a pseudo short option, starting with CHAR_MAX + 1. */
266 TRADITIONAL_OPTION = CHAR_MAX + 1
269 static struct option const long_options[] =
271 {"skip-bytes", required_argument, NULL, 'j'},
272 {"address-radix", required_argument, NULL, 'A'},
273 {"read-bytes", required_argument, NULL, 'N'},
274 {"format", required_argument, NULL, 't'},
275 {"output-duplicates", no_argument, NULL, 'v'},
276 {"strings", optional_argument, NULL, 'S'},
277 {"traditional", no_argument, NULL, TRADITIONAL_OPTION},
278 {"width", optional_argument, NULL, 'w'},
280 {GETOPT_HELP_OPTION_DECL},
281 {GETOPT_VERSION_OPTION_DECL},
288 if (status != EXIT_SUCCESS)
289 fprintf (stderr, _("Try `%s --help' for more information.\n"),
294 Usage: %s [OPTION]... [FILE]...\n\
295 or: %s [-abcdfilosx]... [FILE] [[+]OFFSET[.][b]]\n\
296 or: %s --traditional [OPTION]... [FILE] [[+]OFFSET[.][b] [+][LABEL][.][b]]\n\
298 program_name, program_name, program_name);
300 Write an unambiguous representation, octal bytes by default,\n\
301 of FILE to standard output. With more than one FILE argument,\n\
302 concatenate them in the listed order to form the input.\n\
303 With no FILE, or when FILE is -, read standard input.\n\
307 All arguments to long options are mandatory for short options.\n\
310 -A, --address-radix=RADIX decide how file offsets are printed\n\
311 -j, --skip-bytes=BYTES skip BYTES input bytes first\n\
314 -N, --read-bytes=BYTES limit dump to BYTES input bytes\n\
315 -S, --strings[=BYTES] output strings of at least BYTES graphic chars\n\
316 -t, --format=TYPE select output format or formats\n\
317 -v, --output-duplicates do not use * to mark line suppression\n\
318 -w, --width[=BYTES] output BYTES bytes per output line\n\
319 --traditional accept arguments in traditional form\n\
321 fputs (HELP_OPTION_DESCRIPTION, stdout);
322 fputs (VERSION_OPTION_DESCRIPTION, stdout);
325 Traditional format specifications may be intermixed; they accumulate:\n\
326 -a same as -t a, select named characters, ignoring high-order bit\n\
327 -b same as -t o1, select octal bytes\n\
328 -c same as -t c, select ASCII characters or backslash escapes\n\
329 -d same as -t u2, select unsigned decimal 2-byte units\n\
332 -f same as -t fF, select floats\n\
333 -i same as -t dI, select decimal ints\n\
334 -l same as -t dL, select decimal longs\n\
335 -o same as -t o2, select octal 2-byte units\n\
336 -s same as -t d2, select decimal 2-byte units\n\
337 -x same as -t x2, select hexadecimal 2-byte units\n\
341 If first and second call formats both apply, the second format is assumed\n\
342 if the last operand begins with + or (if there are 2 operands) a digit.\n\
343 An OFFSET operand means -j OFFSET. LABEL is the pseudo-address\n\
344 at first byte printed, incremented when dump is progressing.\n\
345 For OFFSET and LABEL, a 0x or 0X prefix indicates hexadecimal;\n\
346 suffixes may be . for octal and b for multiply by 512.\n\
350 TYPE is made up of one or more of these specifications:\n\
352 a named character, ignoring high-order bit\n\
353 c ASCII character or backslash escape\n\
356 d[SIZE] signed decimal, SIZE bytes per integer\n\
357 f[SIZE] floating point, SIZE bytes per integer\n\
358 o[SIZE] octal, SIZE bytes per integer\n\
359 u[SIZE] unsigned decimal, SIZE bytes per integer\n\
360 x[SIZE] hexadecimal, SIZE bytes per integer\n\
364 SIZE is a number. For TYPE in doux, SIZE may also be C for\n\
365 sizeof(char), S for sizeof(short), I for sizeof(int) or L for\n\
366 sizeof(long). If TYPE is f, SIZE may also be F for sizeof(float), D\n\
367 for sizeof(double) or L for sizeof(long double).\n\
371 RADIX is d for decimal, o for octal, x for hexadecimal or n for none.\n\
372 BYTES is hexadecimal with 0x or 0X prefix, and may have a multiplier suffix:\n\
373 b 512, kB 1000, K 1024, MB 1000*1000, M 1024*1024,\n\
374 GB 1000*1000*1000, G 1024*1024*1024, and so on for T, P, E, Z, Y.\n\
375 Adding a z suffix to any type displays printable characters at the end of each\n\
379 --string without a number implies 3. --width without a number\n\
380 implies 32. By default, od uses -A o -t oS -w16.\n\
382 emit_bug_reporting_address ();
387 /* Define the print functions. */
389 #define PRINT_TYPE(N, T) \
391 N (size_t n_bytes, void const *block, char const *fmt_string) \
393 T const *p = block; \
395 for (i = n_bytes / sizeof *p; i != 0; i--) \
396 xprintf (fmt_string, *p++); \
399 PRINT_TYPE (print_s_char, signed char)
400 PRINT_TYPE (print_char, unsigned char)
401 PRINT_TYPE (print_s_short, short int)
402 PRINT_TYPE (print_short, unsigned short int)
403 PRINT_TYPE (print_int, unsigned int)
404 PRINT_TYPE (print_long, unsigned long int)
405 PRINT_TYPE (print_long_long, unsigned_long_long_int)
406 PRINT_TYPE (print_float, float)
407 PRINT_TYPE (print_double, double)
408 PRINT_TYPE (print_long_double, long double)
413 dump_hexl_mode_trailer (size_t n_bytes, const char *block)
416 fputs (" >", stdout);
417 for (i = n_bytes; i > 0; i--)
419 unsigned char c = *block++;
420 unsigned char c2 = (isprint (c) ? c : '.');
427 print_named_ascii (size_t n_bytes, void const *block,
428 const char *unused_fmt_string ATTRIBUTE_UNUSED)
430 unsigned char const *p = block;
432 for (i = n_bytes; i > 0; i--)
434 int masked_c = *p++ & 0x7f;
440 else if (masked_c <= 040)
441 s = charname[masked_c];
444 sprintf (buf, " %c", masked_c);
453 print_ascii (size_t n_bytes, void const *block,
454 const char *unused_fmt_string ATTRIBUTE_UNUSED)
456 unsigned char const *p = block;
458 for (i = n_bytes; i > 0; i--)
460 unsigned char c = *p++;
499 sprintf (buf, (isprint (c) ? " %c" : "%03o"), c);
507 /* Convert a null-terminated (possibly zero-length) string S to an
508 unsigned long integer value. If S points to a non-digit set *P to S,
509 *VAL to 0, and return true. Otherwise, accumulate the integer value of
510 the string of digits. If the string of digits represents a value
511 larger than ULONG_MAX, don't modify *VAL or *P and return false.
512 Otherwise, advance *P to the first non-digit after S, set *VAL to
513 the result of the conversion and return true. */
516 simple_strtoul (const char *s, const char **p, unsigned long int *val)
518 unsigned long int sum;
524 if (sum > (ULONG_MAX - c) / 10)
533 /* If S points to a single valid modern od format string, put
534 a description of that format in *TSPEC, make *NEXT point at the
535 character following the just-decoded format (if *NEXT is non-NULL),
536 and return true. If S is not valid, don't modify *NEXT or *TSPEC,
537 give a diagnostic, and return false. For example, if S were
538 "d4afL" *NEXT would be set to "afL" and *TSPEC would be
540 fmt = SIGNED_DECIMAL;
541 size = INT or LONG; (whichever integral_type_size[4] resolves to)
542 print_function = print_int; (assuming size == INT)
543 fmt_string = "%011d%c";
545 S_ORIG is solely for reporting errors. It should be the full format
550 decode_one_format (const char *s_orig, const char *s, const char **next,
553 enum size_spec size_spec;
554 unsigned long int size;
555 enum output_format fmt;
556 const char *pre_fmt_string;
557 void (*print_function) (size_t, void const *, char const *);
563 assert (tspec != NULL);
577 size = sizeof (char);
582 size = sizeof (short int);
592 size = sizeof (long int);
596 if (! simple_strtoul (s, &p, &size))
598 /* The integer at P in S would overflow an unsigned long int.
599 A digit string that long is sufficiently odd looking
600 that the following diagnostic is sufficient. */
601 error (0, 0, _("invalid type string %s"), quote (s_orig));
608 if (MAX_INTEGRAL_TYPE_SIZE < size
609 || integral_type_size[size] == NO_SIZE)
611 error (0, 0, _("invalid type string %s;\n\
612 this system doesn't provide a %lu-byte integral type"), quote (s_orig), size);
620 #define ISPEC_TO_FORMAT(Spec, Min_format, Long_format, Max_format) \
621 ((Spec) == LONG_LONG ? (Max_format) \
622 : ((Spec) == LONG ? (Long_format) \
625 size_spec = integral_type_size[size];
630 fmt = SIGNED_DECIMAL;
631 sprintf (tspec->fmt_string, " %%%d%s",
632 (field_width = bytes_to_signed_dec_digits[size]),
633 ISPEC_TO_FORMAT (size_spec, "d", "ld", PRIdMAX));
638 sprintf (tspec->fmt_string, " %%0%d%s",
639 (field_width = bytes_to_oct_digits[size]),
640 ISPEC_TO_FORMAT (size_spec, "o", "lo", PRIoMAX));
644 fmt = UNSIGNED_DECIMAL;
645 sprintf (tspec->fmt_string, " %%%d%s",
646 (field_width = bytes_to_unsigned_dec_digits[size]),
647 ISPEC_TO_FORMAT (size_spec, "u", "lu", PRIuMAX));
652 sprintf (tspec->fmt_string, " %%0%d%s",
653 (field_width = bytes_to_hex_digits[size]),
654 ISPEC_TO_FORMAT (size_spec, "x", "lx", PRIxMAX));
661 assert (strlen (tspec->fmt_string) < FMT_BYTES_ALLOCATED);
666 print_function = (fmt == SIGNED_DECIMAL
672 print_function = (fmt == SIGNED_DECIMAL
678 print_function = print_int;
682 print_function = print_long;
686 print_function = print_long_long;
695 fmt = FLOATING_POINT;
701 size = sizeof (float);
706 size = sizeof (double);
711 size = sizeof (long double);
715 if (! simple_strtoul (s, &p, &size))
717 /* The integer at P in S would overflow an unsigned long int.
718 A digit string that long is sufficiently odd looking
719 that the following diagnostic is sufficient. */
720 error (0, 0, _("invalid type string %s"), quote (s_orig));
724 size = sizeof (double);
727 if (size > MAX_FP_TYPE_SIZE
728 || fp_type_size[size] == NO_SIZE)
730 error (0, 0, _("invalid type string %s;\n\
731 this system doesn't provide a %lu-byte floating point type"),
732 quote (s_orig), size);
739 size_spec = fp_type_size[size];
744 print_function = print_float;
745 /* Don't use %#e; not all systems support it. */
746 pre_fmt_string = " %%%d.%de";
751 print_function = print_double;
752 pre_fmt_string = " %%%d.%de";
756 case FLOAT_LONG_DOUBLE:
757 print_function = print_long_double;
758 pre_fmt_string = " %%%d.%dLe";
759 precision = LDBL_DIG;
766 field_width = precision + 8;
767 sprintf (tspec->fmt_string, pre_fmt_string, field_width, precision);
772 fmt = NAMED_CHARACTER;
774 print_function = print_named_ascii;
782 print_function = print_ascii;
787 error (0, 0, _("invalid character `%c' in type string %s"),
792 tspec->size = size_spec;
794 tspec->print_function = print_function;
796 tspec->field_width = field_width;
797 tspec->hexl_mode_trailer = (*s == 'z');
798 if (tspec->hexl_mode_trailer)
807 /* Given a list of one or more input filenames FILE_LIST, set the global
808 file pointer IN_STREAM and the global string INPUT_FILENAME to the
809 first one that can be successfully opened. Modify FILE_LIST to
810 reference the next filename in the list. A file name of "-" is
811 interpreted as standard input. If any file open fails, give an error
812 message and return false. */
815 open_next_file (void)
821 input_filename = *file_list;
822 if (input_filename == NULL)
826 if (STREQ (input_filename, "-"))
828 input_filename = _("standard input");
830 have_read_stdin = true;
831 if (O_BINARY && ! isatty (STDIN_FILENO))
832 freopen (NULL, "rb", stdin);
836 in_stream = fopen (input_filename, (O_BINARY ? "rb" : "r"));
837 if (in_stream == NULL)
839 error (0, errno, "%s", input_filename);
844 while (in_stream == NULL);
846 if (limit_bytes_to_format & !flag_dump_strings)
847 setvbuf (in_stream, NULL, _IONBF, 0);
852 /* Test whether there have been errors on in_stream, and close it if
853 it is not standard input. Return false if there has been an error
854 on in_stream or stdout; return true otherwise. This function will
855 report more than one error only if both a read and a write error
856 have occurred. IN_ERRNO, if nonzero, is the error number
857 corresponding to the most recent action for IN_STREAM. */
860 check_and_close (int in_errno)
864 if (in_stream != NULL)
866 if (ferror (in_stream))
868 error (0, in_errno, _("%s: read error"), input_filename);
869 if (! STREQ (file_list[-1], "-"))
873 else if (! STREQ (file_list[-1], "-") && fclose (in_stream) != 0)
875 error (0, errno, "%s", input_filename);
884 error (0, 0, _("write error"));
891 /* Decode the modern od format string S. Append the decoded
892 representation to the global array SPEC, reallocating SPEC if
893 necessary. Return true if S is valid. */
896 decode_format_string (const char *s)
898 const char *s_orig = s;
905 if (n_specs_allocated <= n_specs)
906 spec = X2NREALLOC (spec, &n_specs_allocated);
908 if (! decode_one_format (s_orig, s, &next, &spec[n_specs]))
919 /* Given a list of one or more input filenames FILE_LIST, set the global
920 file pointer IN_STREAM to position N_SKIP in the concatenation of
921 those files. If any file operation fails or if there are fewer than
922 N_SKIP bytes in the combined input, give an error message and return
923 false. When possible, use seek rather than read operations to
924 advance IN_STREAM. */
927 skip (uintmax_t n_skip)
935 while (in_stream != NULL) /* EOF. */
937 struct stat file_stats;
939 /* First try seeking. For large offsets, this extra work is
940 worthwhile. If the offset is below some threshold it may be
941 more efficient to move the pointer by reading. There are two
942 issues when trying to seek:
943 - the file must be seekable.
944 - before seeking to the specified position, make sure
945 that the new position is in the current file.
946 Try to do that by getting file's size using fstat.
947 But that will work only for regular files. */
949 if (fstat (fileno (in_stream), &file_stats) == 0)
951 /* The st_size field is valid only for regular files
952 (and for symbolic links, which cannot occur here).
953 If the number of bytes left to skip is larger than
954 the size of the current file, we can decrement n_skip
955 and go on to the next file. Skip this optimization also
956 when st_size is 0, because some kernels report that
957 nonempty files in /proc have st_size == 0. */
958 if (S_ISREG (file_stats.st_mode) && 0 < file_stats.st_size)
960 if ((uintmax_t) file_stats.st_size < n_skip)
961 n_skip -= file_stats.st_size;
964 if (fseeko (in_stream, n_skip, SEEK_CUR) != 0)
973 /* If it's not a regular file with nonnegative size,
974 position the file pointer by reading. */
979 size_t n_bytes_read, n_bytes_to_read = BUFSIZ;
983 if (n_skip < n_bytes_to_read)
984 n_bytes_to_read = n_skip;
985 n_bytes_read = fread (buf, 1, n_bytes_to_read, in_stream);
986 n_skip -= n_bytes_read;
987 if (n_bytes_read != n_bytes_to_read)
1001 else /* cannot fstat() file */
1003 error (0, errno, "%s", input_filename);
1007 ok &= check_and_close (in_errno);
1009 ok &= open_next_file ();
1013 error (EXIT_FAILURE, 0, _("cannot skip past end of combined input"));
1019 format_address_none (uintmax_t address ATTRIBUTE_UNUSED, char c ATTRIBUTE_UNUSED)
1024 format_address_std (uintmax_t address, char c)
1026 char buf[MAX_ADDRESS_LENGTH + 2];
1027 char *p = buf + sizeof buf;
1032 pbound = p - address_pad_len;
1034 /* Use a special case of the code for each base. This is measurably
1035 faster than generic code. */
1036 switch (address_base)
1040 *--p = '0' + (address & 7);
1041 while ((address >>= 3) != 0);
1046 *--p = '0' + (address % 10);
1047 while ((address /= 10) != 0);
1052 *--p = "0123456789abcdef"[address & 15];
1053 while ((address >>= 4) != 0);
1064 format_address_paren (uintmax_t address, char c)
1067 format_address_std (address, ')');
1073 format_address_label (uintmax_t address, char c)
1075 format_address_std (address, ' ');
1076 format_address_paren (address + pseudo_offset, c);
1079 /* Write N_BYTES bytes from CURR_BLOCK to standard output once for each
1080 of the N_SPEC format specs. CURRENT_OFFSET is the byte address of
1081 CURR_BLOCK in the concatenation of input files, and it is printed
1082 (optionally) only before the output line associated with the first
1083 format spec. When duplicate blocks are being abbreviated, the output
1084 for a sequence of identical input blocks is the output for the first
1085 block followed by an asterisk alone on a line. It is valid to compare
1086 the blocks PREV_BLOCK and CURR_BLOCK only when N_BYTES == BYTES_PER_BLOCK.
1087 That condition may be false only for the last input block -- and then
1088 only when it has not been padded to length BYTES_PER_BLOCK. */
1091 write_block (uintmax_t current_offset, size_t n_bytes,
1092 const char *prev_block, const char *curr_block)
1094 static bool first = true;
1095 static bool prev_pair_equal = false;
1097 #define EQUAL_BLOCKS(b1, b2) (memcmp (b1, b2, bytes_per_block) == 0)
1099 if (abbreviate_duplicate_blocks
1100 && !first && n_bytes == bytes_per_block
1101 && EQUAL_BLOCKS (prev_block, curr_block))
1103 if (prev_pair_equal)
1105 /* The two preceding blocks were equal, and the current
1106 block is the same as the last one, so print nothing. */
1111 prev_pair_equal = true;
1118 prev_pair_equal = false;
1119 for (i = 0; i < n_specs; i++)
1122 format_address (current_offset, '\0');
1124 printf ("%*s", address_pad_len, "");
1125 (*spec[i].print_function) (n_bytes, curr_block, spec[i].fmt_string);
1126 if (spec[i].hexl_mode_trailer)
1128 /* space-pad out to full line width, then dump the trailer */
1129 int datum_width = width_bytes[spec[i].size];
1130 int blank_fields = (bytes_per_block - n_bytes) / datum_width;
1131 int field_width = spec[i].field_width + 1;
1132 printf ("%*s", blank_fields * field_width, "");
1133 dump_hexl_mode_trailer (n_bytes, curr_block);
1141 /* Read a single byte into *C from the concatenation of the input files
1142 named in the global array FILE_LIST. On the first call to this
1143 function, the global variable IN_STREAM is expected to be an open
1144 stream associated with the input file INPUT_FILENAME. If IN_STREAM
1145 is at end-of-file, close it and update the global variables IN_STREAM
1146 and INPUT_FILENAME so they correspond to the next file in the list.
1147 Then try to read a byte from the newly opened file. Repeat if
1148 necessary until EOF is reached for the last file in FILE_LIST, then
1149 set *C to EOF and return. Subsequent calls do likewise. Return
1150 true if successful. */
1159 while (in_stream != NULL) /* EOF. */
1161 *c = fgetc (in_stream);
1166 ok &= check_and_close (errno);
1168 ok &= open_next_file ();
1174 /* Read N bytes into BLOCK from the concatenation of the input files
1175 named in the global array FILE_LIST. On the first call to this
1176 function, the global variable IN_STREAM is expected to be an open
1177 stream associated with the input file INPUT_FILENAME. If all N
1178 bytes cannot be read from IN_STREAM, close IN_STREAM and update
1179 the global variables IN_STREAM and INPUT_FILENAME. Then try to
1180 read the remaining bytes from the newly opened file. Repeat if
1181 necessary until EOF is reached for the last file in FILE_LIST.
1182 On subsequent calls, don't modify BLOCK and return true. Set
1183 *N_BYTES_IN_BUFFER to the number of bytes read. If an error occurs,
1184 it will be detected through ferror when the stream is about to be
1185 closed. If there is an error, give a message but continue reading
1186 as usual and return false. Otherwise return true. */
1189 read_block (size_t n, char *block, size_t *n_bytes_in_buffer)
1193 assert (0 < n && n <= bytes_per_block);
1195 *n_bytes_in_buffer = 0;
1200 while (in_stream != NULL) /* EOF. */
1205 n_needed = n - *n_bytes_in_buffer;
1206 n_read = fread (block + *n_bytes_in_buffer, 1, n_needed, in_stream);
1208 *n_bytes_in_buffer += n_read;
1210 if (n_read == n_needed)
1213 ok &= check_and_close (errno);
1215 ok &= open_next_file ();
1221 /* Return the least common multiple of the sizes associated
1222 with the format specs. */
1230 for (i = 0; i < n_specs; i++)
1231 l_c_m = lcm (l_c_m, width_bytes[spec[i].size]);
1235 /* If S is a valid traditional offset specification with an optional
1236 leading '+' return true and set *OFFSET to the offset it denotes. */
1239 parse_old_offset (const char *s, uintmax_t *offset)
1246 /* Skip over any leading '+'. */
1250 /* Determine the radix we'll use to interpret S. If there is a `.',
1251 it's decimal, otherwise, if the string begins with `0X'or `0x',
1252 it's hexadecimal, else octal. */
1253 if (strchr (s, '.') != NULL)
1257 if (s[0] == '0' && (s[1] == 'x' || s[1] == 'X'))
1263 return xstrtoumax (s, NULL, radix, offset, "Bb") == LONGINT_OK;
1266 /* Read a chunk of size BYTES_PER_BLOCK from the input files, write the
1267 formatted block to standard output, and repeat until the specified
1268 maximum number of bytes has been read or until all input has been
1269 processed. If the last block read is smaller than BYTES_PER_BLOCK
1270 and its size is not a multiple of the size associated with a format
1271 spec, extend the input block with zero bytes until its length is a
1272 multiple of all format spec sizes. Write the final block. Finally,
1273 write on a line by itself the offset of the byte after the last byte
1274 read. Accumulate return values from calls to read_block and
1275 check_and_close, and if any was false, return false.
1276 Otherwise, return true. */
1282 uintmax_t current_offset;
1285 size_t n_bytes_read;
1287 block[0] = xnmalloc (2, bytes_per_block);
1288 block[1] = block[0] + bytes_per_block;
1290 current_offset = n_bytes_to_skip;
1292 if (limit_bytes_to_format)
1297 if (current_offset >= end_offset)
1302 n_needed = MIN (end_offset - current_offset,
1303 (uintmax_t) bytes_per_block);
1304 ok &= read_block (n_needed, block[idx], &n_bytes_read);
1305 if (n_bytes_read < bytes_per_block)
1307 assert (n_bytes_read == bytes_per_block);
1308 write_block (current_offset, n_bytes_read,
1309 block[!idx], block[idx]);
1310 current_offset += n_bytes_read;
1318 ok &= read_block (bytes_per_block, block[idx], &n_bytes_read);
1319 if (n_bytes_read < bytes_per_block)
1321 assert (n_bytes_read == bytes_per_block);
1322 write_block (current_offset, n_bytes_read,
1323 block[!idx], block[idx]);
1324 current_offset += n_bytes_read;
1329 if (n_bytes_read > 0)
1332 size_t bytes_to_write;
1336 /* Make bytes_to_write the smallest multiple of l_c_m that
1337 is at least as large as n_bytes_read. */
1338 bytes_to_write = l_c_m * ((n_bytes_read + l_c_m - 1) / l_c_m);
1340 memset (block[idx] + n_bytes_read, 0, bytes_to_write - n_bytes_read);
1341 write_block (current_offset, bytes_to_write,
1342 block[!idx], block[idx]);
1343 current_offset += n_bytes_read;
1346 format_address (current_offset, '\n');
1348 if (limit_bytes_to_format && current_offset >= end_offset)
1349 ok &= check_and_close (0);
1356 /* STRINGS mode. Find each "string constant" in the input.
1357 A string constant is a run of at least `string_min' ASCII
1358 graphic (or formatting) characters terminated by a null.
1359 Based on a function written by Richard Stallman for a
1360 traditional version of od. Return true if successful. */
1365 size_t bufsize = MAX (100, string_min);
1366 char *buf = xmalloc (bufsize);
1367 uintmax_t address = n_bytes_to_skip;
1375 /* See if the next `string_min' chars are all printing chars. */
1378 if (limit_bytes_to_format
1379 && (end_offset < string_min || end_offset - string_min <= address))
1382 for (i = 0; i < string_min; i++)
1384 ok &= read_char (&c);
1392 /* Found a non-printing. Try again starting with next char. */
1397 /* We found a run of `string_min' printable characters.
1398 Now see if it is terminated with a null byte. */
1399 while (!limit_bytes_to_format || address < end_offset)
1403 buf = X2REALLOC (buf, &bufsize);
1405 ok &= read_char (&c);
1413 break; /* It is; print this string. */
1415 goto tryline; /* It isn't; give up on this string. */
1416 buf[i++] = c; /* String continues; store it all. */
1419 /* If we get here, the string is all printable and null-terminated,
1420 so print it. It is all in `buf' and `i' is its length. */
1422 format_address (address - i - 1, ' ');
1424 for (i = 0; (c = buf[i]); i++)
1429 fputs ("\\a", stdout);
1433 fputs ("\\b", stdout);
1437 fputs ("\\f", stdout);
1441 fputs ("\\n", stdout);
1445 fputs ("\\r", stdout);
1449 fputs ("\\t", stdout);
1453 fputs ("\\v", stdout);
1463 /* We reach this point only if we search through
1464 (max_bytes_to_format - string_min) bytes before reaching EOF. */
1468 ok &= check_and_close (0);
1473 main (int argc, char **argv)
1478 size_t desired_width IF_LINT (= 0);
1479 bool modern = false;
1480 bool width_specified = false;
1482 static char const multipliers[] = "bEGKkMmPTYZ0";
1484 /* The old-style `pseudo starting address' to be printed in parentheses
1485 after any true address. */
1486 uintmax_t pseudo_start IF_LINT (= 0);
1488 initialize_main (&argc, &argv);
1489 set_program_name (argv[0]);
1490 setlocale (LC_ALL, "");
1491 bindtextdomain (PACKAGE, LOCALEDIR);
1492 textdomain (PACKAGE);
1494 atexit (close_stdout);
1496 for (i = 0; i <= MAX_INTEGRAL_TYPE_SIZE; i++)
1497 integral_type_size[i] = NO_SIZE;
1499 integral_type_size[sizeof (char)] = CHAR;
1500 integral_type_size[sizeof (short int)] = SHORT;
1501 integral_type_size[sizeof (int)] = INT;
1502 integral_type_size[sizeof (long int)] = LONG;
1503 #if HAVE_UNSIGNED_LONG_LONG_INT
1504 /* If `long int' and `long long int' have the same size, it's fine
1505 to overwrite the entry for `long' with this one. */
1506 integral_type_size[sizeof (unsigned_long_long_int)] = LONG_LONG;
1509 for (i = 0; i <= MAX_FP_TYPE_SIZE; i++)
1510 fp_type_size[i] = NO_SIZE;
1512 fp_type_size[sizeof (float)] = FLOAT_SINGLE;
1513 /* The array entry for `double' is filled in after that for `long double'
1514 so that if they are the same size, we avoid any overhead of
1515 long double computation in libc. */
1516 fp_type_size[sizeof (long double)] = FLOAT_LONG_DOUBLE;
1517 fp_type_size[sizeof (double)] = FLOAT_DOUBLE;
1520 n_specs_allocated = 0;
1523 format_address = format_address_std;
1525 address_pad_len = 7;
1526 flag_dump_strings = false;
1531 enum strtol_error s_err;
1533 int c = getopt_long (argc, argv, short_options, long_options, &oi);
1544 format_address = format_address_std;
1546 address_pad_len = 7;
1549 format_address = format_address_std;
1551 address_pad_len = 7;
1554 format_address = format_address_std;
1556 address_pad_len = 6;
1559 format_address = format_address_none;
1560 address_pad_len = 0;
1563 error (EXIT_FAILURE, 0,
1564 _("invalid output address radix `%c'; \
1565 it must be one character from [doxn]"),
1573 s_err = xstrtoumax (optarg, NULL, 0, &n_bytes_to_skip, multipliers);
1574 if (s_err != LONGINT_OK)
1575 xstrtol_fatal (s_err, oi, c, long_options, optarg);
1580 limit_bytes_to_format = true;
1582 s_err = xstrtoumax (optarg, NULL, 0, &max_bytes_to_format,
1584 if (s_err != LONGINT_OK)
1585 xstrtol_fatal (s_err, oi, c, long_options, optarg);
1594 s_err = xstrtoumax (optarg, NULL, 0, &tmp, multipliers);
1595 if (s_err != LONGINT_OK)
1596 xstrtol_fatal (s_err, oi, c, long_options, optarg);
1598 /* The minimum string length may be no larger than SIZE_MAX,
1599 since we may allocate a buffer of this size. */
1601 error (EXIT_FAILURE, 0, _("%s is too large"), optarg);
1605 flag_dump_strings = true;
1610 ok &= decode_format_string (optarg);
1615 abbreviate_duplicate_blocks = false;
1618 case TRADITIONAL_OPTION:
1622 /* The next several cases map the traditional format
1623 specification options to the corresponding modern format
1624 specs. GNU od accepts any combination of old- and
1625 new-style options. Format specification options accumulate.
1626 The obsolescent and undocumented formats are compatible
1627 with FreeBSD 4.10 od. */
1629 #define CASE_OLD_ARG(old_char,new_string) \
1631 ok &= decode_format_string (new_string); \
1634 CASE_OLD_ARG ('a', "a");
1635 CASE_OLD_ARG ('b', "o1");
1636 CASE_OLD_ARG ('c', "c");
1637 CASE_OLD_ARG ('D', "u4"); /* obsolescent and undocumented */
1638 CASE_OLD_ARG ('d', "u2");
1639 case 'F': /* obsolescent and undocumented alias */
1640 CASE_OLD_ARG ('e', "fD"); /* obsolescent and undocumented */
1641 CASE_OLD_ARG ('f', "fF");
1642 case 'X': /* obsolescent and undocumented alias */
1643 CASE_OLD_ARG ('H', "x4"); /* obsolescent and undocumented */
1644 CASE_OLD_ARG ('i', "dI");
1645 case 'I': case 'L': /* obsolescent and undocumented aliases */
1646 CASE_OLD_ARG ('l', "dL");
1647 CASE_OLD_ARG ('O', "o4"); /* obsolesent and undocumented */
1648 case 'B': /* obsolescent and undocumented alias */
1649 CASE_OLD_ARG ('o', "o2");
1650 CASE_OLD_ARG ('s', "d2");
1651 case 'h': /* obsolescent and undocumented alias */
1652 CASE_OLD_ARG ('x', "x2");
1658 width_specified = true;
1666 s_err = xstrtoumax (optarg, NULL, 10, &w_tmp, "");
1667 if (s_err != LONGINT_OK)
1668 xstrtol_fatal (s_err, oi, c, long_options, optarg);
1669 if (SIZE_MAX < w_tmp)
1670 error (EXIT_FAILURE, 0, _("%s is too large"), optarg);
1671 desired_width = w_tmp;
1675 case_GETOPT_HELP_CHAR;
1677 case_GETOPT_VERSION_CHAR (PROGRAM_NAME, AUTHORS);
1680 usage (EXIT_FAILURE);
1686 exit (EXIT_FAILURE);
1688 if (flag_dump_strings && n_specs > 0)
1689 error (EXIT_FAILURE, 0,
1690 _("no type may be specified when dumping strings"));
1692 n_files = argc - optind;
1694 /* If the --traditional option is used, there may be from
1695 0 to 3 remaining command line arguments; handle each case
1697 od [file] [[+]offset[.][b] [[+]label[.][b]]]
1698 The offset and label have the same syntax.
1700 If --traditional is not given, and if no modern options are
1701 given, and if the offset begins with + or (if there are two
1702 operands) a digit, accept only this form, as per POSIX:
1703 od [file] [[+]offset[.][b]]
1706 if (!modern | traditional)
1714 if ((traditional || argv[optind][0] == '+')
1715 && parse_old_offset (argv[optind], &o1))
1717 n_bytes_to_skip = o1;
1724 if ((traditional || argv[optind + 1][0] == '+'
1725 || ISDIGIT (argv[optind + 1][0]))
1726 && parse_old_offset (argv[optind + 1], &o2))
1728 if (traditional && parse_old_offset (argv[optind], &o1))
1730 n_bytes_to_skip = o1;
1731 flag_pseudo_start = true;
1738 n_bytes_to_skip = o2;
1740 argv[optind + 1] = argv[optind];
1748 && parse_old_offset (argv[optind + 1], &o1)
1749 && parse_old_offset (argv[optind + 2], &o2))
1751 n_bytes_to_skip = o1;
1752 flag_pseudo_start = true;
1754 argv[optind + 2] = argv[optind];
1761 if (traditional && 1 < n_files)
1763 error (0, 0, _("extra operand %s"), quote (argv[optind + 1]));
1764 error (0, 0, "%s\n",
1765 _("compatibility mode supports at most one file"));
1766 usage (EXIT_FAILURE);
1770 if (flag_pseudo_start)
1772 if (format_address == format_address_none)
1775 address_pad_len = 7;
1776 format_address = format_address_paren;
1779 format_address = format_address_label;
1782 if (limit_bytes_to_format)
1784 end_offset = n_bytes_to_skip + max_bytes_to_format;
1785 if (end_offset < n_bytes_to_skip)
1786 error (EXIT_FAILURE, 0, _("skip-bytes + read-bytes is too large"));
1790 decode_format_string ("oS");
1794 /* Set the global pointer FILE_LIST so that it
1795 references the first file-argument on the command-line. */
1797 file_list = (char const *const *) &argv[optind];
1801 /* No files were listed on the command line.
1802 Set the global pointer FILE_LIST so that it
1803 references the null-terminated list of one name: "-". */
1805 file_list = default_file_list;
1808 /* open the first input file */
1809 ok = open_next_file ();
1810 if (in_stream == NULL)
1813 /* skip over any unwanted header bytes */
1814 ok &= skip (n_bytes_to_skip);
1815 if (in_stream == NULL)
1818 pseudo_offset = (flag_pseudo_start ? pseudo_start - n_bytes_to_skip : 0);
1820 /* Compute output block length. */
1823 if (width_specified)
1825 if (desired_width != 0 && desired_width % l_c_m == 0)
1826 bytes_per_block = desired_width;
1829 error (0, 0, _("warning: invalid width %lu; using %d instead"),
1830 (unsigned long int) desired_width, l_c_m);
1831 bytes_per_block = l_c_m;
1836 if (l_c_m < DEFAULT_BYTES_PER_BLOCK)
1837 bytes_per_block = l_c_m * (DEFAULT_BYTES_PER_BLOCK / l_c_m);
1839 bytes_per_block = l_c_m;
1843 for (i = 0; i < n_specs; i++)
1845 printf (_("%d: fmt=\"%s\" width=%d\n"),
1846 i, spec[i].fmt_string, width_bytes[spec[i].size]);
1850 ok &= (flag_dump_strings ? dump_strings () : dump ());
1854 if (have_read_stdin && fclose (stdin) == EOF)
1855 error (EXIT_FAILURE, errno, _("standard input"));
1857 exit (ok ? EXIT_SUCCESS : EXIT_FAILURE);