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 /* Convert the number of 8-bit bytes of a binary representation to
117 the number of characters (digits + sign if the type is signed)
118 required to represent the same quantity in the specified base/type.
119 For example, a 32-bit (4-byte) quantity may require a field width
120 as wide as the following for these types:
124 8 unsigned hexadecimal */
126 static unsigned int const bytes_to_oct_digits[] =
127 {0, 3, 6, 8, 11, 14, 16, 19, 22, 25, 27, 30, 32, 35, 38, 41, 43};
129 static unsigned int const bytes_to_signed_dec_digits[] =
130 {1, 4, 6, 8, 11, 13, 16, 18, 20, 23, 25, 28, 30, 33, 35, 37, 40};
132 static unsigned int const bytes_to_unsigned_dec_digits[] =
133 {0, 3, 5, 8, 10, 13, 15, 17, 20, 22, 25, 27, 29, 32, 34, 37, 39};
135 static unsigned int const bytes_to_hex_digits[] =
136 {0, 2, 4, 6, 8, 10, 12, 14, 16, 18, 20, 22, 24, 26, 28, 30, 32};
138 #define MAX_INTEGRAL_TYPE_SIZE sizeof (unsigned_long_long_int)
140 /* It'll be a while before we see integral types wider than 16 bytes,
141 but if/when it happens, this check will catch it. Without this check,
142 a wider type would provoke a buffer overrun. */
143 verify (MAX_INTEGRAL_TYPE_SIZE
144 < sizeof bytes_to_hex_digits / sizeof *bytes_to_hex_digits);
146 /* Make sure the other arrays have the same length. */
147 verify (sizeof bytes_to_oct_digits == sizeof bytes_to_signed_dec_digits);
148 verify (sizeof bytes_to_oct_digits == sizeof bytes_to_unsigned_dec_digits);
149 verify (sizeof bytes_to_oct_digits == sizeof bytes_to_hex_digits);
151 /* Convert enum size_spec to the size of the named type. */
152 static const int width_bytes[] =
159 sizeof (unsigned_long_long_int),
165 /* Ensure that for each member of `enum size_spec' there is an
166 initializer in the width_bytes array. */
167 verify (sizeof width_bytes / sizeof width_bytes[0] == N_SIZE_SPECS);
169 /* Names for some non-printing characters. */
170 static const char *const charname[33] =
172 "nul", "soh", "stx", "etx", "eot", "enq", "ack", "bel",
173 "bs", "ht", "nl", "vt", "ff", "cr", "so", "si",
174 "dle", "dc1", "dc2", "dc3", "dc4", "nak", "syn", "etb",
175 "can", "em", "sub", "esc", "fs", "gs", "rs", "us",
179 /* Address base (8, 10 or 16). */
180 static int address_base;
182 /* The number of octal digits required to represent the largest
184 #define MAX_ADDRESS_LENGTH \
185 ((sizeof (uintmax_t) * CHAR_BIT + CHAR_BIT - 1) / 3)
187 /* Width of a normal address. */
188 static int address_pad_len;
190 static size_t string_min;
191 static bool flag_dump_strings;
193 /* True if we should recognize the older non-option arguments
194 that specified at most one file and optional arguments specifying
195 offset and pseudo-start address. */
196 static bool traditional;
198 /* True if an old-style `pseudo-address' was specified. */
199 static bool flag_pseudo_start;
201 /* The difference between the old-style pseudo starting address and
202 the number of bytes to skip. */
203 static uintmax_t pseudo_offset;
205 /* Function that accepts an address and an optional following char,
206 and prints the address and char to stdout. */
207 static void (*format_address) (uintmax_t, char);
209 /* The number of input bytes to skip before formatting and writing. */
210 static uintmax_t n_bytes_to_skip = 0;
212 /* When false, MAX_BYTES_TO_FORMAT and END_OFFSET are ignored, and all
213 input is formatted. */
214 static bool limit_bytes_to_format = false;
216 /* The maximum number of bytes that will be formatted. */
217 static uintmax_t max_bytes_to_format;
219 /* The offset of the first byte after the last byte to be formatted. */
220 static uintmax_t end_offset;
222 /* When true and two or more consecutive blocks are equal, format
223 only the first block and output an asterisk alone on the following
224 line to indicate that identical blocks have been elided. */
225 static bool abbreviate_duplicate_blocks = true;
227 /* An array of specs describing how to format each input block. */
228 static struct tspec *spec;
230 /* The number of format specs. */
231 static size_t n_specs;
233 /* The allocated length of SPEC. */
234 static size_t n_specs_allocated;
236 /* The number of input bytes formatted per output line. It must be
237 a multiple of the least common multiple of the sizes associated with
238 the specified output types. It should be as large as possible, but
239 no larger than 16 -- unless specified with the -w option. */
240 static size_t bytes_per_block;
242 /* Human-readable representation of *file_list (for error messages).
243 It differs from file_list[-1] only when file_list[-1] is "-". */
244 static char const *input_filename;
246 /* A NULL-terminated list of the file-arguments from the command line. */
247 static char const *const *file_list;
249 /* Initializer for file_list if no file-arguments
250 were specified on the command line. */
251 static char const *const default_file_list[] = {"-", NULL};
253 /* The input stream associated with the current file. */
254 static FILE *in_stream;
256 /* If true, at least one of the files we read was standard input. */
257 static bool have_read_stdin;
259 /* Map the size in bytes to a type identifier. */
260 static enum size_spec integral_type_size[MAX_INTEGRAL_TYPE_SIZE + 1];
262 #define MAX_FP_TYPE_SIZE sizeof (LONG_DOUBLE)
263 static enum size_spec fp_type_size[MAX_FP_TYPE_SIZE + 1];
265 static char const short_options[] = "A:aBbcDdeFfHhIij:LlN:OoS:st:vw::Xx";
267 /* For long options that have no equivalent short option, use a
268 non-character as a pseudo short option, starting with CHAR_MAX + 1. */
271 TRADITIONAL_OPTION = CHAR_MAX + 1
274 static struct option const long_options[] =
276 {"skip-bytes", required_argument, NULL, 'j'},
277 {"address-radix", required_argument, NULL, 'A'},
278 {"read-bytes", required_argument, NULL, 'N'},
279 {"format", required_argument, NULL, 't'},
280 {"output-duplicates", no_argument, NULL, 'v'},
281 {"strings", optional_argument, NULL, 'S'},
282 {"traditional", no_argument, NULL, TRADITIONAL_OPTION},
283 {"width", optional_argument, NULL, 'w'},
285 {GETOPT_HELP_OPTION_DECL},
286 {GETOPT_VERSION_OPTION_DECL},
293 if (status != EXIT_SUCCESS)
294 fprintf (stderr, _("Try `%s --help' for more information.\n"),
299 Usage: %s [OPTION]... [FILE]...\n\
300 or: %s [-abcdfilosx]... [FILE] [[+]OFFSET[.][b]]\n\
301 or: %s --traditional [OPTION]... [FILE] [[+]OFFSET[.][b] [+][LABEL][.][b]]\n\
303 program_name, program_name, program_name);
305 Write an unambiguous representation, octal bytes by default,\n\
306 of FILE to standard output. With more than one FILE argument,\n\
307 concatenate them in the listed order to form the input.\n\
308 With no FILE, or when FILE is -, read standard input.\n\
312 All arguments to long options are mandatory for short options.\n\
315 -A, --address-radix=RADIX decide how file offsets are printed\n\
316 -j, --skip-bytes=BYTES skip BYTES input bytes first\n\
319 -N, --read-bytes=BYTES limit dump to BYTES input bytes\n\
320 -S, --strings[=BYTES] output strings of at least BYTES graphic chars\n\
321 -t, --format=TYPE select output format or formats\n\
322 -v, --output-duplicates do not use * to mark line suppression\n\
323 -w, --width[=BYTES] output BYTES bytes per output line\n\
324 --traditional accept arguments in traditional form\n\
326 fputs (HELP_OPTION_DESCRIPTION, stdout);
327 fputs (VERSION_OPTION_DESCRIPTION, stdout);
330 Traditional format specifications may be intermixed; they accumulate:\n\
331 -a same as -t a, select named characters, ignoring high-order bit\n\
332 -b same as -t o1, select octal bytes\n\
333 -c same as -t c, select ASCII characters or backslash escapes\n\
334 -d same as -t u2, select unsigned decimal 2-byte units\n\
337 -f same as -t fF, select floats\n\
338 -i same as -t dI, select decimal ints\n\
339 -l same as -t dL, select decimal longs\n\
340 -o same as -t o2, select octal 2-byte units\n\
341 -s same as -t d2, select decimal 2-byte units\n\
342 -x same as -t x2, select hexadecimal 2-byte units\n\
346 If first and second call formats both apply, the second format is assumed\n\
347 if the last operand begins with + or (if there are 2 operands) a digit.\n\
348 An OFFSET operand means -j OFFSET. LABEL is the pseudo-address\n\
349 at first byte printed, incremented when dump is progressing.\n\
350 For OFFSET and LABEL, a 0x or 0X prefix indicates hexadecimal;\n\
351 suffixes may be . for octal and b for multiply by 512.\n\
355 TYPE is made up of one or more of these specifications:\n\
357 a named character, ignoring high-order bit\n\
358 c ASCII character or backslash escape\n\
361 d[SIZE] signed decimal, SIZE bytes per integer\n\
362 f[SIZE] floating point, SIZE bytes per integer\n\
363 o[SIZE] octal, SIZE bytes per integer\n\
364 u[SIZE] unsigned decimal, SIZE bytes per integer\n\
365 x[SIZE] hexadecimal, SIZE bytes per integer\n\
369 SIZE is a number. For TYPE in doux, SIZE may also be C for\n\
370 sizeof(char), S for sizeof(short), I for sizeof(int) or L for\n\
371 sizeof(long). If TYPE is f, SIZE may also be F for sizeof(float), D\n\
372 for sizeof(double) or L for sizeof(long double).\n\
376 RADIX is d for decimal, o for octal, x for hexadecimal or n for none.\n\
377 BYTES is hexadecimal with 0x or 0X prefix, and may have a multiplier suffix:\n\
378 b 512, kB 1000, K 1024, MB 1000*1000, M 1024*1024,\n\
379 GB 1000*1000*1000, G 1024*1024*1024, and so on for T, P, E, Z, Y.\n\
380 Adding a z suffix to any type displays printable characters at the end of each\n\
384 --string without a number implies 3. --width without a number\n\
385 implies 32. By default, od uses -A o -t d2 -w16.\n\
387 emit_bug_reporting_address ();
392 /* Define the print functions. */
395 print_s_char (size_t n_bytes, void const *block, char const *fmt_string)
397 signed char const *p = block;
399 for (i = n_bytes / sizeof *p; i != 0; i--)
400 printf (fmt_string, *p++);
404 print_char (size_t n_bytes, void const *block, char const *fmt_string)
406 unsigned char const *p = block;
408 for (i = n_bytes / sizeof *p; i != 0; i--)
409 printf (fmt_string, *p++);
413 print_s_short (size_t n_bytes, void const *block, char const *fmt_string)
415 short int const *p = block;
417 for (i = n_bytes / sizeof *p; i != 0; i--)
418 printf (fmt_string, *p++);
422 print_short (size_t n_bytes, void const *block, char const *fmt_string)
424 unsigned short int const *p = block;
426 for (i = n_bytes / sizeof *p; i != 0; i--)
427 printf (fmt_string, *p++);
431 print_int (size_t n_bytes, void const *block, char const *fmt_string)
433 unsigned int const *p = block;
435 for (i = n_bytes / sizeof *p; i != 0; i--)
436 printf (fmt_string, *p++);
440 print_long (size_t n_bytes, void const *block, char const *fmt_string)
442 unsigned long int const *p = block;
444 for (i = n_bytes / sizeof *p; i != 0; i--)
445 printf (fmt_string, *p++);
449 print_long_long (size_t n_bytes, void const *block, char const *fmt_string)
451 unsigned_long_long_int const *p = block;
453 for (i = n_bytes / sizeof *p; i != 0; i--)
454 printf (fmt_string, *p++);
458 print_float (size_t n_bytes, void const *block, char const *fmt_string)
460 float const *p = block;
462 for (i = n_bytes / sizeof *p; i != 0; i--)
463 printf (fmt_string, *p++);
467 print_double (size_t n_bytes, void const *block, char const *fmt_string)
469 double const *p = block;
471 for (i = n_bytes / sizeof *p; i != 0; i--)
472 printf (fmt_string, *p++);
475 #ifdef HAVE_LONG_DOUBLE
477 print_long_double (size_t n_bytes, void const *block, char const *fmt_string)
479 long double const *p = block;
481 for (i = n_bytes / sizeof *p; i != 0; i--)
482 printf (fmt_string, *p++);
487 dump_hexl_mode_trailer (size_t n_bytes, const char *block)
490 fputs (" >", stdout);
491 for (i = n_bytes; i > 0; i--)
493 unsigned char c = *block++;
494 unsigned char c2 = (isprint (c) ? c : '.');
501 print_named_ascii (size_t n_bytes, void const *block,
502 const char *unused_fmt_string ATTRIBUTE_UNUSED)
504 unsigned char const *p = block;
506 for (i = n_bytes; i > 0; i--)
508 int masked_c = *p++ & 0x7f;
514 else if (masked_c <= 040)
515 s = charname[masked_c];
518 sprintf (buf, " %c", masked_c);
527 print_ascii (size_t n_bytes, void const *block,
528 const char *unused_fmt_string ATTRIBUTE_UNUSED)
530 unsigned char const *p = block;
532 for (i = n_bytes; i > 0; i--)
534 unsigned char c = *p++;
573 sprintf (buf, (isprint (c) ? " %c" : "%03o"), c);
581 /* Convert a null-terminated (possibly zero-length) string S to an
582 unsigned long integer value. If S points to a non-digit set *P to S,
583 *VAL to 0, and return true. Otherwise, accumulate the integer value of
584 the string of digits. If the string of digits represents a value
585 larger than ULONG_MAX, don't modify *VAL or *P and return false.
586 Otherwise, advance *P to the first non-digit after S, set *VAL to
587 the result of the conversion and return true. */
590 simple_strtoul (const char *s, const char **p, unsigned long int *val)
592 unsigned long int sum;
598 if (sum > (ULONG_MAX - c) / 10)
607 /* If S points to a single valid modern od format string, put
608 a description of that format in *TSPEC, make *NEXT point at the
609 character following the just-decoded format (if *NEXT is non-NULL),
610 and return true. If S is not valid, don't modify *NEXT or *TSPEC,
611 give a diagnostic, and return false. For example, if S were
612 "d4afL" *NEXT would be set to "afL" and *TSPEC would be
614 fmt = SIGNED_DECIMAL;
615 size = INT or LONG; (whichever integral_type_size[4] resolves to)
616 print_function = print_int; (assuming size == INT)
617 fmt_string = "%011d%c";
619 S_ORIG is solely for reporting errors. It should be the full format
624 decode_one_format (const char *s_orig, const char *s, const char **next,
627 enum size_spec size_spec;
628 unsigned long int size;
629 enum output_format fmt;
630 const char *pre_fmt_string;
631 void (*print_function) (size_t, void const *, char const *);
637 assert (tspec != NULL);
651 size = sizeof (char);
656 size = sizeof (short int);
666 size = sizeof (long int);
670 if (! simple_strtoul (s, &p, &size))
672 /* The integer at P in S would overflow an unsigned long int.
673 A digit string that long is sufficiently odd looking
674 that the following diagnostic is sufficient. */
675 error (0, 0, _("invalid type string %s"), quote (s_orig));
682 if (MAX_INTEGRAL_TYPE_SIZE < size
683 || integral_type_size[size] == NO_SIZE)
685 error (0, 0, _("invalid type string %s;\n\
686 this system doesn't provide a %lu-byte integral type"), quote (s_orig), size);
694 #define ISPEC_TO_FORMAT(Spec, Min_format, Long_format, Max_format) \
695 ((Spec) == LONG_LONG ? (Max_format) \
696 : ((Spec) == LONG ? (Long_format) \
699 size_spec = integral_type_size[size];
704 fmt = SIGNED_DECIMAL;
705 sprintf (tspec->fmt_string, " %%%d%s",
706 (field_width = bytes_to_signed_dec_digits[size]),
707 ISPEC_TO_FORMAT (size_spec, "d", "ld", PRIdMAX));
712 sprintf (tspec->fmt_string, " %%0%d%s",
713 (field_width = bytes_to_oct_digits[size]),
714 ISPEC_TO_FORMAT (size_spec, "o", "lo", PRIoMAX));
718 fmt = UNSIGNED_DECIMAL;
719 sprintf (tspec->fmt_string, " %%%d%s",
720 (field_width = bytes_to_unsigned_dec_digits[size]),
721 ISPEC_TO_FORMAT (size_spec, "u", "lu", PRIuMAX));
726 sprintf (tspec->fmt_string, " %%0%d%s",
727 (field_width = bytes_to_hex_digits[size]),
728 ISPEC_TO_FORMAT (size_spec, "x", "lx", PRIxMAX));
735 assert (strlen (tspec->fmt_string) < FMT_BYTES_ALLOCATED);
740 print_function = (fmt == SIGNED_DECIMAL
746 print_function = (fmt == SIGNED_DECIMAL
752 print_function = print_int;
756 print_function = print_long;
760 print_function = print_long_long;
769 fmt = FLOATING_POINT;
775 size = sizeof (float);
780 size = sizeof (double);
785 size = sizeof (LONG_DOUBLE);
789 if (! simple_strtoul (s, &p, &size))
791 /* The integer at P in S would overflow an unsigned long int.
792 A digit string that long is sufficiently odd looking
793 that the following diagnostic is sufficient. */
794 error (0, 0, _("invalid type string %s"), quote (s_orig));
798 size = sizeof (double);
801 if (size > MAX_FP_TYPE_SIZE
802 || fp_type_size[size] == NO_SIZE)
804 error (0, 0, _("invalid type string %s;\n\
805 this system doesn't provide a %lu-byte floating point type"),
806 quote (s_orig), size);
813 size_spec = fp_type_size[size];
818 print_function = print_float;
819 /* Don't use %#e; not all systems support it. */
820 pre_fmt_string = " %%%d.%de";
825 print_function = print_double;
826 pre_fmt_string = " %%%d.%de";
830 #ifdef HAVE_LONG_DOUBLE
831 case FLOAT_LONG_DOUBLE:
832 print_function = print_long_double;
833 pre_fmt_string = " %%%d.%dLe";
834 precision = LDBL_DIG;
842 field_width = precision + 8;
843 sprintf (tspec->fmt_string, pre_fmt_string, field_width, precision);
848 fmt = NAMED_CHARACTER;
850 print_function = print_named_ascii;
858 print_function = print_ascii;
863 error (0, 0, _("invalid character `%c' in type string %s"),
868 tspec->size = size_spec;
870 tspec->print_function = print_function;
872 tspec->field_width = field_width;
873 tspec->hexl_mode_trailer = (*s == 'z');
874 if (tspec->hexl_mode_trailer)
883 /* Given a list of one or more input filenames FILE_LIST, set the global
884 file pointer IN_STREAM and the global string INPUT_FILENAME to the
885 first one that can be successfully opened. Modify FILE_LIST to
886 reference the next filename in the list. A file name of "-" is
887 interpreted as standard input. If any file open fails, give an error
888 message and return false. */
891 open_next_file (void)
897 input_filename = *file_list;
898 if (input_filename == NULL)
902 if (STREQ (input_filename, "-"))
904 input_filename = _("standard input");
906 have_read_stdin = true;
907 if (O_BINARY && ! isatty (STDIN_FILENO))
908 freopen (NULL, "rb", stdin);
912 in_stream = fopen (input_filename, (O_BINARY ? "rb" : "r"));
913 if (in_stream == NULL)
915 error (0, errno, "%s", input_filename);
920 while (in_stream == NULL);
922 if (limit_bytes_to_format & !flag_dump_strings)
923 setvbuf (in_stream, NULL, _IONBF, 0);
928 /* Test whether there have been errors on in_stream, and close it if
929 it is not standard input. Return false if there has been an error
930 on in_stream or stdout; return true otherwise. This function will
931 report more than one error only if both a read and a write error
932 have occurred. IN_ERRNO, if nonzero, is the error number
933 corresponding to the most recent action for IN_STREAM. */
936 check_and_close (int in_errno)
940 if (in_stream != NULL)
942 if (ferror (in_stream))
944 error (0, in_errno, _("%s: read error"), input_filename);
945 if (! STREQ (file_list[-1], "-"))
949 else if (! STREQ (file_list[-1], "-") && fclose (in_stream) != 0)
951 error (0, errno, "%s", input_filename);
960 error (0, 0, _("write error"));
967 /* Decode the modern od format string S. Append the decoded
968 representation to the global array SPEC, reallocating SPEC if
969 necessary. Return true if S is valid. */
972 decode_format_string (const char *s)
974 const char *s_orig = s;
981 if (n_specs_allocated <= n_specs)
982 spec = X2NREALLOC (spec, &n_specs_allocated);
984 if (! decode_one_format (s_orig, s, &next, &spec[n_specs]))
995 /* Given a list of one or more input filenames FILE_LIST, set the global
996 file pointer IN_STREAM to position N_SKIP in the concatenation of
997 those files. If any file operation fails or if there are fewer than
998 N_SKIP bytes in the combined input, give an error message and return
999 false. When possible, use seek rather than read operations to
1000 advance IN_STREAM. */
1003 skip (uintmax_t n_skip)
1011 while (in_stream != NULL) /* EOF. */
1013 struct stat file_stats;
1015 /* First try seeking. For large offsets, this extra work is
1016 worthwhile. If the offset is below some threshold it may be
1017 more efficient to move the pointer by reading. There are two
1018 issues when trying to seek:
1019 - the file must be seekable.
1020 - before seeking to the specified position, make sure
1021 that the new position is in the current file.
1022 Try to do that by getting file's size using fstat.
1023 But that will work only for regular files. */
1025 if (fstat (fileno (in_stream), &file_stats) == 0)
1027 /* The st_size field is valid only for regular files
1028 (and for symbolic links, which cannot occur here).
1029 If the number of bytes left to skip is larger than
1030 the size of the current file, we can decrement n_skip
1031 and go on to the next file. Skip this optimization also
1032 when st_size is 0, because some kernels report that
1033 nonempty files in /proc have st_size == 0. */
1034 if (S_ISREG (file_stats.st_mode) && 0 < file_stats.st_size)
1036 if ((uintmax_t) file_stats.st_size < n_skip)
1037 n_skip -= file_stats.st_size;
1040 if (fseeko (in_stream, n_skip, SEEK_CUR) != 0)
1049 /* If it's not a regular file with nonnegative size,
1050 position the file pointer by reading. */
1055 size_t n_bytes_read, n_bytes_to_read = BUFSIZ;
1059 if (n_skip < n_bytes_to_read)
1060 n_bytes_to_read = n_skip;
1061 n_bytes_read = fread (buf, 1, n_bytes_to_read, in_stream);
1062 n_skip -= n_bytes_read;
1063 if (n_bytes_read != n_bytes_to_read)
1077 else /* cannot fstat() file */
1079 error (0, errno, "%s", input_filename);
1083 ok &= check_and_close (in_errno);
1085 ok &= open_next_file ();
1089 error (EXIT_FAILURE, 0, _("cannot skip past end of combined input"));
1095 format_address_none (uintmax_t address ATTRIBUTE_UNUSED, char c ATTRIBUTE_UNUSED)
1100 format_address_std (uintmax_t address, char c)
1102 char buf[MAX_ADDRESS_LENGTH + 2];
1103 char *p = buf + sizeof buf;
1108 pbound = p - address_pad_len;
1110 /* Use a special case of the code for each base. This is measurably
1111 faster than generic code. */
1112 switch (address_base)
1116 *--p = '0' + (address & 7);
1117 while ((address >>= 3) != 0);
1122 *--p = '0' + (address % 10);
1123 while ((address /= 10) != 0);
1128 *--p = "0123456789abcdef"[address & 15];
1129 while ((address >>= 4) != 0);
1140 format_address_paren (uintmax_t address, char c)
1143 format_address_std (address, ')');
1149 format_address_label (uintmax_t address, char c)
1151 format_address_std (address, ' ');
1152 format_address_paren (address + pseudo_offset, c);
1155 /* Write N_BYTES bytes from CURR_BLOCK to standard output once for each
1156 of the N_SPEC format specs. CURRENT_OFFSET is the byte address of
1157 CURR_BLOCK in the concatenation of input files, and it is printed
1158 (optionally) only before the output line associated with the first
1159 format spec. When duplicate blocks are being abbreviated, the output
1160 for a sequence of identical input blocks is the output for the first
1161 block followed by an asterisk alone on a line. It is valid to compare
1162 the blocks PREV_BLOCK and CURR_BLOCK only when N_BYTES == BYTES_PER_BLOCK.
1163 That condition may be false only for the last input block -- and then
1164 only when it has not been padded to length BYTES_PER_BLOCK. */
1167 write_block (uintmax_t current_offset, size_t n_bytes,
1168 const char *prev_block, const char *curr_block)
1170 static bool first = true;
1171 static bool prev_pair_equal = false;
1173 #define EQUAL_BLOCKS(b1, b2) (memcmp (b1, b2, bytes_per_block) == 0)
1175 if (abbreviate_duplicate_blocks
1176 && !first && n_bytes == bytes_per_block
1177 && EQUAL_BLOCKS (prev_block, curr_block))
1179 if (prev_pair_equal)
1181 /* The two preceding blocks were equal, and the current
1182 block is the same as the last one, so print nothing. */
1187 prev_pair_equal = true;
1194 prev_pair_equal = false;
1195 for (i = 0; i < n_specs; i++)
1198 format_address (current_offset, '\0');
1200 printf ("%*s", address_pad_len, "");
1201 (*spec[i].print_function) (n_bytes, curr_block, spec[i].fmt_string);
1202 if (spec[i].hexl_mode_trailer)
1204 /* space-pad out to full line width, then dump the trailer */
1205 int datum_width = width_bytes[spec[i].size];
1206 int blank_fields = (bytes_per_block - n_bytes) / datum_width;
1207 int field_width = spec[i].field_width + 1;
1208 printf ("%*s", blank_fields * field_width, "");
1209 dump_hexl_mode_trailer (n_bytes, curr_block);
1217 /* Read a single byte into *C from the concatenation of the input files
1218 named in the global array FILE_LIST. On the first call to this
1219 function, the global variable IN_STREAM is expected to be an open
1220 stream associated with the input file INPUT_FILENAME. If IN_STREAM
1221 is at end-of-file, close it and update the global variables IN_STREAM
1222 and INPUT_FILENAME so they correspond to the next file in the list.
1223 Then try to read a byte from the newly opened file. Repeat if
1224 necessary until EOF is reached for the last file in FILE_LIST, then
1225 set *C to EOF and return. Subsequent calls do likewise. Return
1226 true if successful. */
1235 while (in_stream != NULL) /* EOF. */
1237 *c = fgetc (in_stream);
1242 ok &= check_and_close (errno);
1244 ok &= open_next_file ();
1250 /* Read N bytes into BLOCK from the concatenation of the input files
1251 named in the global array FILE_LIST. On the first call to this
1252 function, the global variable IN_STREAM is expected to be an open
1253 stream associated with the input file INPUT_FILENAME. If all N
1254 bytes cannot be read from IN_STREAM, close IN_STREAM and update
1255 the global variables IN_STREAM and INPUT_FILENAME. Then try to
1256 read the remaining bytes from the newly opened file. Repeat if
1257 necessary until EOF is reached for the last file in FILE_LIST.
1258 On subsequent calls, don't modify BLOCK and return true. Set
1259 *N_BYTES_IN_BUFFER to the number of bytes read. If an error occurs,
1260 it will be detected through ferror when the stream is about to be
1261 closed. If there is an error, give a message but continue reading
1262 as usual and return false. Otherwise return true. */
1265 read_block (size_t n, char *block, size_t *n_bytes_in_buffer)
1269 assert (0 < n && n <= bytes_per_block);
1271 *n_bytes_in_buffer = 0;
1276 while (in_stream != NULL) /* EOF. */
1281 n_needed = n - *n_bytes_in_buffer;
1282 n_read = fread (block + *n_bytes_in_buffer, 1, n_needed, in_stream);
1284 *n_bytes_in_buffer += n_read;
1286 if (n_read == n_needed)
1289 ok &= check_and_close (errno);
1291 ok &= open_next_file ();
1297 /* Return the least common multiple of the sizes associated
1298 with the format specs. */
1306 for (i = 0; i < n_specs; i++)
1307 l_c_m = lcm (l_c_m, width_bytes[spec[i].size]);
1311 /* If S is a valid traditional offset specification with an optional
1312 leading '+' return true and set *OFFSET to the offset it denotes. */
1315 parse_old_offset (const char *s, uintmax_t *offset)
1322 /* Skip over any leading '+'. */
1326 /* Determine the radix we'll use to interpret S. If there is a `.',
1327 it's decimal, otherwise, if the string begins with `0X'or `0x',
1328 it's hexadecimal, else octal. */
1329 if (strchr (s, '.') != NULL)
1333 if (s[0] == '0' && (s[1] == 'x' || s[1] == 'X'))
1339 return xstrtoumax (s, NULL, radix, offset, "Bb") == LONGINT_OK;
1342 /* Read a chunk of size BYTES_PER_BLOCK from the input files, write the
1343 formatted block to standard output, and repeat until the specified
1344 maximum number of bytes has been read or until all input has been
1345 processed. If the last block read is smaller than BYTES_PER_BLOCK
1346 and its size is not a multiple of the size associated with a format
1347 spec, extend the input block with zero bytes until its length is a
1348 multiple of all format spec sizes. Write the final block. Finally,
1349 write on a line by itself the offset of the byte after the last byte
1350 read. Accumulate return values from calls to read_block and
1351 check_and_close, and if any was false, return false.
1352 Otherwise, return true. */
1358 uintmax_t current_offset;
1361 size_t n_bytes_read;
1363 block[0] = xnmalloc (2, bytes_per_block);
1364 block[1] = block[0] + bytes_per_block;
1366 current_offset = n_bytes_to_skip;
1368 if (limit_bytes_to_format)
1373 if (current_offset >= end_offset)
1378 n_needed = MIN (end_offset - current_offset,
1379 (uintmax_t) bytes_per_block);
1380 ok &= read_block (n_needed, block[idx], &n_bytes_read);
1381 if (n_bytes_read < bytes_per_block)
1383 assert (n_bytes_read == bytes_per_block);
1384 write_block (current_offset, n_bytes_read,
1385 block[!idx], block[idx]);
1386 current_offset += n_bytes_read;
1394 ok &= read_block (bytes_per_block, block[idx], &n_bytes_read);
1395 if (n_bytes_read < bytes_per_block)
1397 assert (n_bytes_read == bytes_per_block);
1398 write_block (current_offset, n_bytes_read,
1399 block[!idx], block[idx]);
1400 current_offset += n_bytes_read;
1405 if (n_bytes_read > 0)
1408 size_t bytes_to_write;
1412 /* Make bytes_to_write the smallest multiple of l_c_m that
1413 is at least as large as n_bytes_read. */
1414 bytes_to_write = l_c_m * ((n_bytes_read + l_c_m - 1) / l_c_m);
1416 memset (block[idx] + n_bytes_read, 0, bytes_to_write - n_bytes_read);
1417 write_block (current_offset, bytes_to_write,
1418 block[!idx], block[idx]);
1419 current_offset += n_bytes_read;
1422 format_address (current_offset, '\n');
1424 if (limit_bytes_to_format && current_offset >= end_offset)
1425 ok &= check_and_close (0);
1432 /* STRINGS mode. Find each "string constant" in the input.
1433 A string constant is a run of at least `string_min' ASCII
1434 graphic (or formatting) characters terminated by a null.
1435 Based on a function written by Richard Stallman for a
1436 traditional version of od. Return true if successful. */
1441 size_t bufsize = MAX (100, string_min);
1442 char *buf = xmalloc (bufsize);
1443 uintmax_t address = n_bytes_to_skip;
1451 /* See if the next `string_min' chars are all printing chars. */
1454 if (limit_bytes_to_format
1455 && (end_offset < string_min || end_offset - string_min <= address))
1458 for (i = 0; i < string_min; i++)
1460 ok &= read_char (&c);
1468 /* Found a non-printing. Try again starting with next char. */
1473 /* We found a run of `string_min' printable characters.
1474 Now see if it is terminated with a null byte. */
1475 while (!limit_bytes_to_format || address < end_offset)
1479 buf = X2REALLOC (buf, &bufsize);
1481 ok &= read_char (&c);
1489 break; /* It is; print this string. */
1491 goto tryline; /* It isn't; give up on this string. */
1492 buf[i++] = c; /* String continues; store it all. */
1495 /* If we get here, the string is all printable and null-terminated,
1496 so print it. It is all in `buf' and `i' is its length. */
1498 format_address (address - i - 1, ' ');
1500 for (i = 0; (c = buf[i]); i++)
1505 fputs ("\\a", stdout);
1509 fputs ("\\b", stdout);
1513 fputs ("\\f", stdout);
1517 fputs ("\\n", stdout);
1521 fputs ("\\r", stdout);
1525 fputs ("\\t", stdout);
1529 fputs ("\\v", stdout);
1539 /* We reach this point only if we search through
1540 (max_bytes_to_format - string_min) bytes before reaching EOF. */
1544 ok &= check_and_close (0);
1549 main (int argc, char **argv)
1554 size_t desired_width IF_LINT (= 0);
1555 bool modern = false;
1556 bool width_specified = false;
1558 static char const multipliers[] = "bEGKkMmPTYZ0";
1560 /* The old-style `pseudo starting address' to be printed in parentheses
1561 after any true address. */
1562 uintmax_t pseudo_start IF_LINT (= 0);
1564 initialize_main (&argc, &argv);
1565 set_program_name (argv[0]);
1566 setlocale (LC_ALL, "");
1567 bindtextdomain (PACKAGE, LOCALEDIR);
1568 textdomain (PACKAGE);
1570 atexit (close_stdout);
1572 for (i = 0; i <= MAX_INTEGRAL_TYPE_SIZE; i++)
1573 integral_type_size[i] = NO_SIZE;
1575 integral_type_size[sizeof (char)] = CHAR;
1576 integral_type_size[sizeof (short int)] = SHORT;
1577 integral_type_size[sizeof (int)] = INT;
1578 integral_type_size[sizeof (long int)] = LONG;
1579 #if HAVE_UNSIGNED_LONG_LONG_INT
1580 /* If `long int' and `long long int' have the same size, it's fine
1581 to overwrite the entry for `long' with this one. */
1582 integral_type_size[sizeof (unsigned_long_long_int)] = LONG_LONG;
1585 for (i = 0; i <= MAX_FP_TYPE_SIZE; i++)
1586 fp_type_size[i] = NO_SIZE;
1588 fp_type_size[sizeof (float)] = FLOAT_SINGLE;
1589 /* The array entry for `double' is filled in after that for LONG_DOUBLE
1590 so that if `long double' is the same type or if long double isn't
1591 supported FLOAT_LONG_DOUBLE will never be used. */
1592 fp_type_size[sizeof (LONG_DOUBLE)] = FLOAT_LONG_DOUBLE;
1593 fp_type_size[sizeof (double)] = FLOAT_DOUBLE;
1596 n_specs_allocated = 0;
1599 format_address = format_address_std;
1601 address_pad_len = 7;
1602 flag_dump_strings = false;
1607 enum strtol_error s_err;
1609 int c = getopt_long (argc, argv, short_options, long_options, &oi);
1620 format_address = format_address_std;
1622 address_pad_len = 7;
1625 format_address = format_address_std;
1627 address_pad_len = 7;
1630 format_address = format_address_std;
1632 address_pad_len = 6;
1635 format_address = format_address_none;
1636 address_pad_len = 0;
1639 error (EXIT_FAILURE, 0,
1640 _("invalid output address radix `%c'; \
1641 it must be one character from [doxn]"),
1649 s_err = xstrtoumax (optarg, NULL, 0, &n_bytes_to_skip, multipliers);
1650 if (s_err != LONGINT_OK)
1651 xstrtol_fatal (s_err, oi, c, long_options, optarg);
1656 limit_bytes_to_format = true;
1658 s_err = xstrtoumax (optarg, NULL, 0, &max_bytes_to_format,
1660 if (s_err != LONGINT_OK)
1661 xstrtol_fatal (s_err, oi, c, long_options, optarg);
1670 s_err = xstrtoumax (optarg, NULL, 0, &tmp, multipliers);
1671 if (s_err != LONGINT_OK)
1672 xstrtol_fatal (s_err, oi, c, long_options, optarg);
1674 /* The minimum string length may be no larger than SIZE_MAX,
1675 since we may allocate a buffer of this size. */
1677 error (EXIT_FAILURE, 0, _("%s is too large"), optarg);
1681 flag_dump_strings = true;
1686 ok &= decode_format_string (optarg);
1691 abbreviate_duplicate_blocks = false;
1694 case TRADITIONAL_OPTION:
1698 /* The next several cases map the traditional format
1699 specification options to the corresponding modern format
1700 specs. GNU od accepts any combination of old- and
1701 new-style options. Format specification options accumulate.
1702 The obsolescent and undocumented formats are compatible
1703 with FreeBSD 4.10 od. */
1705 #define CASE_OLD_ARG(old_char,new_string) \
1707 ok &= decode_format_string (new_string); \
1710 CASE_OLD_ARG ('a', "a");
1711 CASE_OLD_ARG ('b', "o1");
1712 CASE_OLD_ARG ('c', "c");
1713 CASE_OLD_ARG ('D', "u4"); /* obsolescent and undocumented */
1714 CASE_OLD_ARG ('d', "u2");
1715 case 'F': /* obsolescent and undocumented alias */
1716 CASE_OLD_ARG ('e', "fD"); /* obsolescent and undocumented */
1717 CASE_OLD_ARG ('f', "fF");
1718 case 'X': /* obsolescent and undocumented alias */
1719 CASE_OLD_ARG ('H', "x4"); /* obsolescent and undocumented */
1720 CASE_OLD_ARG ('i', "dI");
1721 case 'I': case 'L': /* obsolescent and undocumented aliases */
1722 CASE_OLD_ARG ('l', "dL");
1723 CASE_OLD_ARG ('O', "o4"); /* obsolesent and undocumented */
1724 case 'B': /* obsolescent and undocumented alias */
1725 CASE_OLD_ARG ('o', "o2");
1726 CASE_OLD_ARG ('s', "d2");
1727 case 'h': /* obsolescent and undocumented alias */
1728 CASE_OLD_ARG ('x', "x2");
1734 width_specified = true;
1742 s_err = xstrtoumax (optarg, NULL, 10, &w_tmp, "");
1743 if (s_err != LONGINT_OK)
1744 xstrtol_fatal (s_err, oi, c, long_options, optarg);
1745 if (SIZE_MAX < w_tmp)
1746 error (EXIT_FAILURE, 0, _("%s is too large"), optarg);
1747 desired_width = w_tmp;
1751 case_GETOPT_HELP_CHAR;
1753 case_GETOPT_VERSION_CHAR (PROGRAM_NAME, AUTHORS);
1756 usage (EXIT_FAILURE);
1762 exit (EXIT_FAILURE);
1764 if (flag_dump_strings && n_specs > 0)
1765 error (EXIT_FAILURE, 0,
1766 _("no type may be specified when dumping strings"));
1768 n_files = argc - optind;
1770 /* If the --traditional option is used, there may be from
1771 0 to 3 remaining command line arguments; handle each case
1773 od [file] [[+]offset[.][b] [[+]label[.][b]]]
1774 The offset and label have the same syntax.
1776 If --traditional is not given, and if no modern options are
1777 given, and if the offset begins with + or (if there are two
1778 operands) a digit, accept only this form, as per POSIX:
1779 od [file] [[+]offset[.][b]]
1782 if (!modern | traditional)
1790 if ((traditional || argv[optind][0] == '+')
1791 && parse_old_offset (argv[optind], &o1))
1793 n_bytes_to_skip = o1;
1800 if ((traditional || argv[optind + 1][0] == '+'
1801 || ISDIGIT (argv[optind + 1][0]))
1802 && parse_old_offset (argv[optind + 1], &o2))
1804 if (traditional && parse_old_offset (argv[optind], &o1))
1806 n_bytes_to_skip = o1;
1807 flag_pseudo_start = true;
1814 n_bytes_to_skip = o2;
1816 argv[optind + 1] = argv[optind];
1824 && parse_old_offset (argv[optind + 1], &o1)
1825 && parse_old_offset (argv[optind + 2], &o2))
1827 n_bytes_to_skip = o1;
1828 flag_pseudo_start = true;
1830 argv[optind + 2] = argv[optind];
1837 if (traditional && 1 < n_files)
1839 error (0, 0, _("extra operand %s"), quote (argv[optind + 1]));
1840 error (0, 0, "%s\n",
1841 _("Compatibility mode supports at most one file."));
1842 usage (EXIT_FAILURE);
1846 if (flag_pseudo_start)
1848 if (format_address == format_address_none)
1851 address_pad_len = 7;
1852 format_address = format_address_paren;
1855 format_address = format_address_label;
1858 if (limit_bytes_to_format)
1860 end_offset = n_bytes_to_skip + max_bytes_to_format;
1861 if (end_offset < n_bytes_to_skip)
1862 error (EXIT_FAILURE, 0, _("skip-bytes + read-bytes is too large"));
1866 decode_format_string ("oS");
1870 /* Set the global pointer FILE_LIST so that it
1871 references the first file-argument on the command-line. */
1873 file_list = (char const *const *) &argv[optind];
1877 /* No files were listed on the command line.
1878 Set the global pointer FILE_LIST so that it
1879 references the null-terminated list of one name: "-". */
1881 file_list = default_file_list;
1884 /* open the first input file */
1885 ok = open_next_file ();
1886 if (in_stream == NULL)
1889 /* skip over any unwanted header bytes */
1890 ok &= skip (n_bytes_to_skip);
1891 if (in_stream == NULL)
1894 pseudo_offset = (flag_pseudo_start ? pseudo_start - n_bytes_to_skip : 0);
1896 /* Compute output block length. */
1899 if (width_specified)
1901 if (desired_width != 0 && desired_width % l_c_m == 0)
1902 bytes_per_block = desired_width;
1905 error (0, 0, _("warning: invalid width %lu; using %d instead"),
1906 (unsigned long int) desired_width, l_c_m);
1907 bytes_per_block = l_c_m;
1912 if (l_c_m < DEFAULT_BYTES_PER_BLOCK)
1913 bytes_per_block = l_c_m * (DEFAULT_BYTES_PER_BLOCK / l_c_m);
1915 bytes_per_block = l_c_m;
1919 for (i = 0; i < n_specs; i++)
1921 printf (_("%d: fmt=\"%s\" width=%d\n"),
1922 i, spec[i].fmt_string, width_bytes[spec[i].size]);
1926 ok &= (flag_dump_strings ? dump_strings () : dump ());
1930 if (have_read_stdin && fclose (stdin) == EOF)
1931 error (EXIT_FAILURE, errno, _("standard input"));
1933 exit (ok ? EXIT_SUCCESS : EXIT_FAILURE);