1 /* od -- dump files in octal and other formats
2 Copyright (C) 92, 1995-2007 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 "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 /* The number of decimal digits of precision in a long double. */
58 # define LDBL_DIG DBL_DIG
61 #if HAVE_UNSIGNED_LONG_LONG_INT
62 typedef unsigned long long int unsigned_long_long_int;
64 /* This is just a place-holder to avoid a few `#if' directives.
65 In this case, the type isn't actually used. */
66 typedef unsigned long int unsigned_long_long_int;
77 /* FIXME: add INTMAX support, too */
95 /* The maximum number of bytes needed for a format string,
96 including the trailing null. */
100 MAX ((sizeof " %0" - 1 + INT_STRLEN_BOUND (int)
106 sizeof " %.Le" + 2 * INT_STRLEN_BOUND (int))
109 /* Each output format specification (from `-t spec' or from
110 old-style options) is represented by one of these structures. */
113 enum output_format fmt;
115 void (*print_function) (size_t, void const *, char const *);
116 char fmt_string[FMT_BYTES_ALLOCATED];
117 bool hexl_mode_trailer;
121 /* The name this program was run with. */
124 /* Convert the number of 8-bit bytes of a binary representation to
125 the number of characters (digits + sign if the type is signed)
126 required to represent the same quantity in the specified base/type.
127 For example, a 32-bit (4-byte) quantity may require a field width
128 as wide as the following for these types:
132 8 unsigned hexadecimal */
134 static unsigned int const bytes_to_oct_digits[] =
135 {0, 3, 6, 8, 11, 14, 16, 19, 22, 25, 27, 30, 32, 35, 38, 41, 43};
137 static unsigned int const bytes_to_signed_dec_digits[] =
138 {1, 4, 6, 8, 11, 13, 16, 18, 20, 23, 25, 28, 30, 33, 35, 37, 40};
140 static unsigned int const bytes_to_unsigned_dec_digits[] =
141 {0, 3, 5, 8, 10, 13, 15, 17, 20, 22, 25, 27, 29, 32, 34, 37, 39};
143 static unsigned int const bytes_to_hex_digits[] =
144 {0, 2, 4, 6, 8, 10, 12, 14, 16, 18, 20, 22, 24, 26, 28, 30, 32};
146 #define MAX_INTEGRAL_TYPE_SIZE sizeof (unsigned_long_long_int)
148 /* It'll be a while before we see integral types wider than 16 bytes,
149 but if/when it happens, this check will catch it. Without this check,
150 a wider type would provoke a buffer overrun. */
151 verify (MAX_INTEGRAL_TYPE_SIZE
152 < sizeof bytes_to_hex_digits / sizeof *bytes_to_hex_digits);
154 /* Make sure the other arrays have the same length. */
155 verify (sizeof bytes_to_oct_digits == sizeof bytes_to_signed_dec_digits);
156 verify (sizeof bytes_to_oct_digits == sizeof bytes_to_unsigned_dec_digits);
157 verify (sizeof bytes_to_oct_digits == sizeof bytes_to_hex_digits);
159 /* Convert enum size_spec to the size of the named type. */
160 static const int width_bytes[] =
167 sizeof (unsigned_long_long_int),
173 /* Ensure that for each member of `enum size_spec' there is an
174 initializer in the width_bytes array. */
175 verify (sizeof width_bytes / sizeof width_bytes[0] == N_SIZE_SPECS);
177 /* Names for some non-printing characters. */
178 static const char *const charname[33] =
180 "nul", "soh", "stx", "etx", "eot", "enq", "ack", "bel",
181 "bs", "ht", "nl", "vt", "ff", "cr", "so", "si",
182 "dle", "dc1", "dc2", "dc3", "dc4", "nak", "syn", "etb",
183 "can", "em", "sub", "esc", "fs", "gs", "rs", "us",
187 /* Address base (8, 10 or 16). */
188 static int address_base;
190 /* The number of octal digits required to represent the largest
192 #define MAX_ADDRESS_LENGTH \
193 ((sizeof (uintmax_t) * CHAR_BIT + CHAR_BIT - 1) / 3)
195 /* Width of a normal address. */
196 static int address_pad_len;
198 static size_t string_min;
199 static bool flag_dump_strings;
201 /* True if we should recognize the older non-option arguments
202 that specified at most one file and optional arguments specifying
203 offset and pseudo-start address. */
204 static bool traditional;
206 /* True if an old-style `pseudo-address' was specified. */
207 static bool flag_pseudo_start;
209 /* The difference between the old-style pseudo starting address and
210 the number of bytes to skip. */
211 static uintmax_t pseudo_offset;
213 /* Function that accepts an address and an optional following char,
214 and prints the address and char to stdout. */
215 static void (*format_address) (uintmax_t, char);
217 /* The number of input bytes to skip before formatting and writing. */
218 static uintmax_t n_bytes_to_skip = 0;
220 /* When false, MAX_BYTES_TO_FORMAT and END_OFFSET are ignored, and all
221 input is formatted. */
222 static bool limit_bytes_to_format = false;
224 /* The maximum number of bytes that will be formatted. */
225 static uintmax_t max_bytes_to_format;
227 /* The offset of the first byte after the last byte to be formatted. */
228 static uintmax_t end_offset;
230 /* When true and two or more consecutive blocks are equal, format
231 only the first block and output an asterisk alone on the following
232 line to indicate that identical blocks have been elided. */
233 static bool abbreviate_duplicate_blocks = true;
235 /* An array of specs describing how to format each input block. */
236 static struct tspec *spec;
238 /* The number of format specs. */
239 static size_t n_specs;
241 /* The allocated length of SPEC. */
242 static size_t n_specs_allocated;
244 /* The number of input bytes formatted per output line. It must be
245 a multiple of the least common multiple of the sizes associated with
246 the specified output types. It should be as large as possible, but
247 no larger than 16 -- unless specified with the -w option. */
248 static size_t bytes_per_block;
250 /* Human-readable representation of *file_list (for error messages).
251 It differs from file_list[-1] only when file_list[-1] is "-". */
252 static char const *input_filename;
254 /* A NULL-terminated list of the file-arguments from the command line. */
255 static char const *const *file_list;
257 /* Initializer for file_list if no file-arguments
258 were specified on the command line. */
259 static char const *const default_file_list[] = {"-", NULL};
261 /* The input stream associated with the current file. */
262 static FILE *in_stream;
264 /* If true, at least one of the files we read was standard input. */
265 static bool have_read_stdin;
267 /* Map the size in bytes to a type identifier. */
268 static enum size_spec integral_type_size[MAX_INTEGRAL_TYPE_SIZE + 1];
270 #define MAX_FP_TYPE_SIZE sizeof (LONG_DOUBLE)
271 static enum size_spec fp_type_size[MAX_FP_TYPE_SIZE + 1];
273 static char const short_options[] = "A:aBbcDdeFfHhIij:LlN:OoS:st:vw::Xx";
275 /* For long options that have no equivalent short option, use a
276 non-character as a pseudo short option, starting with CHAR_MAX + 1. */
279 TRADITIONAL_OPTION = CHAR_MAX + 1
282 static struct option const long_options[] =
284 {"skip-bytes", required_argument, NULL, 'j'},
285 {"address-radix", required_argument, NULL, 'A'},
286 {"read-bytes", required_argument, NULL, 'N'},
287 {"format", required_argument, NULL, 't'},
288 {"output-duplicates", no_argument, NULL, 'v'},
289 {"strings", optional_argument, NULL, 'S'},
290 {"traditional", no_argument, NULL, TRADITIONAL_OPTION},
291 {"width", optional_argument, NULL, 'w'},
293 {GETOPT_HELP_OPTION_DECL},
294 {GETOPT_VERSION_OPTION_DECL},
301 if (status != EXIT_SUCCESS)
302 fprintf (stderr, _("Try `%s --help' for more information.\n"),
307 Usage: %s [OPTION]... [FILE]...\n\
308 or: %s [-abcdfilosx]... [FILE] [[+]OFFSET[.][b]]\n\
309 or: %s --traditional [OPTION]... [FILE] [[+]OFFSET[.][b] [+][LABEL][.][b]]\n\
311 program_name, program_name, program_name);
313 Write an unambiguous representation, octal bytes by default,\n\
314 of FILE to standard output. With more than one FILE argument,\n\
315 concatenate them in the listed order to form the input.\n\
316 With no FILE, or when FILE is -, read standard input.\n\
320 All arguments to long options are mandatory for short options.\n\
323 -A, --address-radix=RADIX decide how file offsets are printed\n\
324 -j, --skip-bytes=BYTES skip BYTES input bytes first\n\
327 -N, --read-bytes=BYTES limit dump to BYTES input bytes\n\
328 -S, --strings[=BYTES] output strings of at least BYTES graphic chars\n\
329 -t, --format=TYPE select output format or formats\n\
330 -v, --output-duplicates do not use * to mark line suppression\n\
331 -w, --width[=BYTES] output BYTES bytes per output line\n\
332 --traditional accept arguments in traditional form\n\
334 fputs (HELP_OPTION_DESCRIPTION, stdout);
335 fputs (VERSION_OPTION_DESCRIPTION, stdout);
338 Traditional format specifications may be intermixed; they accumulate:\n\
339 -a same as -t a, select named characters, ignoring high-order bit\n\
340 -b same as -t o1, select octal bytes\n\
341 -c same as -t c, select ASCII characters or backslash escapes\n\
342 -d same as -t u2, select unsigned decimal 2-byte units\n\
345 -f same as -t fF, select floats\n\
346 -i same as -t dI, select decimal ints\n\
347 -l same as -t dL, select decimal longs\n\
348 -o same as -t o2, select octal 2-byte units\n\
349 -s same as -t d2, select decimal 2-byte units\n\
350 -x same as -t x2, select hexadecimal 2-byte units\n\
354 If first and second call formats both apply, the second format is assumed\n\
355 if the last operand begins with + or (if there are 2 operands) a digit.\n\
356 An OFFSET operand means -j OFFSET. LABEL is the pseudo-address\n\
357 at first byte printed, incremented when dump is progressing.\n\
358 For OFFSET and LABEL, a 0x or 0X prefix indicates hexadecimal;\n\
359 suffixes may be . for octal and b for multiply by 512.\n\
363 TYPE is made up of one or more of these specifications:\n\
365 a named character, ignoring high-order bit\n\
366 c ASCII character or backslash escape\n\
369 d[SIZE] signed decimal, SIZE bytes per integer\n\
370 f[SIZE] floating point, SIZE bytes per integer\n\
371 o[SIZE] octal, SIZE bytes per integer\n\
372 u[SIZE] unsigned decimal, SIZE bytes per integer\n\
373 x[SIZE] hexadecimal, SIZE bytes per integer\n\
377 SIZE is a number. For TYPE in doux, SIZE may also be C for\n\
378 sizeof(char), S for sizeof(short), I for sizeof(int) or L for\n\
379 sizeof(long). If TYPE is f, SIZE may also be F for sizeof(float), D\n\
380 for sizeof(double) or L for sizeof(long double).\n\
384 RADIX is d for decimal, o for octal, x for hexadecimal or n for none.\n\
385 BYTES is hexadecimal with 0x or 0X prefix, and may have a multiplier suffix:\n\
386 b 512, kB 1000, K 1024, MB 1000*1000, M 1024*1024,\n\
387 GB 1000*1000*1000, G 1024*1024*1024, and so on for T, P, E, Z, Y.\n\
388 Adding a z suffix to any type displays printable characters at the end of each\n\
392 --string without a number implies 3. --width without a number\n\
393 implies 32. By default, od uses -A o -t d2 -w16.\n\
395 emit_bug_reporting_address ();
400 /* Define the print functions. */
403 print_s_char (size_t n_bytes, void const *block, char const *fmt_string)
405 signed char const *p = block;
407 for (i = n_bytes / sizeof *p; i != 0; i--)
408 printf (fmt_string, *p++);
412 print_char (size_t n_bytes, void const *block, char const *fmt_string)
414 unsigned char const *p = block;
416 for (i = n_bytes / sizeof *p; i != 0; i--)
417 printf (fmt_string, *p++);
421 print_s_short (size_t n_bytes, void const *block, char const *fmt_string)
423 short int const *p = block;
425 for (i = n_bytes / sizeof *p; i != 0; i--)
426 printf (fmt_string, *p++);
430 print_short (size_t n_bytes, void const *block, char const *fmt_string)
432 unsigned short int const *p = block;
434 for (i = n_bytes / sizeof *p; i != 0; i--)
435 printf (fmt_string, *p++);
439 print_int (size_t n_bytes, void const *block, char const *fmt_string)
441 unsigned int const *p = block;
443 for (i = n_bytes / sizeof *p; i != 0; i--)
444 printf (fmt_string, *p++);
448 print_long (size_t n_bytes, void const *block, char const *fmt_string)
450 unsigned long int const *p = block;
452 for (i = n_bytes / sizeof *p; i != 0; i--)
453 printf (fmt_string, *p++);
457 print_long_long (size_t n_bytes, void const *block, char const *fmt_string)
459 unsigned_long_long_int const *p = block;
461 for (i = n_bytes / sizeof *p; i != 0; i--)
462 printf (fmt_string, *p++);
466 print_float (size_t n_bytes, void const *block, char const *fmt_string)
468 float const *p = block;
470 for (i = n_bytes / sizeof *p; i != 0; i--)
471 printf (fmt_string, *p++);
475 print_double (size_t n_bytes, void const *block, char const *fmt_string)
477 double const *p = block;
479 for (i = n_bytes / sizeof *p; i != 0; i--)
480 printf (fmt_string, *p++);
483 #ifdef HAVE_LONG_DOUBLE
485 print_long_double (size_t n_bytes, void const *block, char const *fmt_string)
487 long double const *p = block;
489 for (i = n_bytes / sizeof *p; i != 0; i--)
490 printf (fmt_string, *p++);
495 dump_hexl_mode_trailer (size_t n_bytes, const char *block)
498 fputs (" >", stdout);
499 for (i = n_bytes; i > 0; i--)
501 unsigned char c = *block++;
502 unsigned char c2 = (isprint (c) ? c : '.');
509 print_named_ascii (size_t n_bytes, void const *block,
510 const char *unused_fmt_string ATTRIBUTE_UNUSED)
512 unsigned char const *p = block;
514 for (i = n_bytes; i > 0; i--)
516 int masked_c = *p++ & 0x7f;
522 else if (masked_c <= 040)
523 s = charname[masked_c];
526 sprintf (buf, " %c", masked_c);
535 print_ascii (size_t n_bytes, void const *block,
536 const char *unused_fmt_string ATTRIBUTE_UNUSED)
538 unsigned char const *p = block;
540 for (i = n_bytes; i > 0; i--)
542 unsigned char c = *p++;
581 sprintf (buf, (isprint (c) ? " %c" : "%03o"), c);
589 /* Convert a null-terminated (possibly zero-length) string S to an
590 unsigned long integer value. If S points to a non-digit set *P to S,
591 *VAL to 0, and return true. Otherwise, accumulate the integer value of
592 the string of digits. If the string of digits represents a value
593 larger than ULONG_MAX, don't modify *VAL or *P and return false.
594 Otherwise, advance *P to the first non-digit after S, set *VAL to
595 the result of the conversion and return true. */
598 simple_strtoul (const char *s, const char **p, unsigned long int *val)
600 unsigned long int sum;
606 if (sum > (ULONG_MAX - c) / 10)
615 /* If S points to a single valid modern od format string, put
616 a description of that format in *TSPEC, make *NEXT point at the
617 character following the just-decoded format (if *NEXT is non-NULL),
618 and return true. If S is not valid, don't modify *NEXT or *TSPEC,
619 give a diagnostic, and return false. For example, if S were
620 "d4afL" *NEXT would be set to "afL" and *TSPEC would be
622 fmt = SIGNED_DECIMAL;
623 size = INT or LONG; (whichever integral_type_size[4] resolves to)
624 print_function = print_int; (assuming size == INT)
625 fmt_string = "%011d%c";
627 S_ORIG is solely for reporting errors. It should be the full format
632 decode_one_format (const char *s_orig, const char *s, const char **next,
635 enum size_spec size_spec;
636 unsigned long int size;
637 enum output_format fmt;
638 const char *pre_fmt_string;
639 void (*print_function) (size_t, void const *, char const *);
645 assert (tspec != NULL);
659 size = sizeof (char);
664 size = sizeof (short int);
674 size = sizeof (long int);
678 if (! simple_strtoul (s, &p, &size))
680 /* The integer at P in S would overflow an unsigned long int.
681 A digit string that long is sufficiently odd looking
682 that the following diagnostic is sufficient. */
683 error (0, 0, _("invalid type string %s"), quote (s_orig));
690 if (MAX_INTEGRAL_TYPE_SIZE < size
691 || integral_type_size[size] == NO_SIZE)
693 error (0, 0, _("invalid type string %s;\n\
694 this system doesn't provide a %lu-byte integral type"), quote (s_orig), size);
702 #define ISPEC_TO_FORMAT(Spec, Min_format, Long_format, Max_format) \
703 ((Spec) == LONG_LONG ? (Max_format) \
704 : ((Spec) == LONG ? (Long_format) \
707 size_spec = integral_type_size[size];
712 fmt = SIGNED_DECIMAL;
713 sprintf (tspec->fmt_string, " %%%d%s",
714 (field_width = bytes_to_signed_dec_digits[size]),
715 ISPEC_TO_FORMAT (size_spec, "d", "ld", PRIdMAX));
720 sprintf (tspec->fmt_string, " %%0%d%s",
721 (field_width = bytes_to_oct_digits[size]),
722 ISPEC_TO_FORMAT (size_spec, "o", "lo", PRIoMAX));
726 fmt = UNSIGNED_DECIMAL;
727 sprintf (tspec->fmt_string, " %%%d%s",
728 (field_width = bytes_to_unsigned_dec_digits[size]),
729 ISPEC_TO_FORMAT (size_spec, "u", "lu", PRIuMAX));
734 sprintf (tspec->fmt_string, " %%0%d%s",
735 (field_width = bytes_to_hex_digits[size]),
736 ISPEC_TO_FORMAT (size_spec, "x", "lx", PRIxMAX));
743 assert (strlen (tspec->fmt_string) < FMT_BYTES_ALLOCATED);
748 print_function = (fmt == SIGNED_DECIMAL
754 print_function = (fmt == SIGNED_DECIMAL
760 print_function = print_int;
764 print_function = print_long;
768 print_function = print_long_long;
777 fmt = FLOATING_POINT;
783 size = sizeof (float);
788 size = sizeof (double);
793 size = sizeof (LONG_DOUBLE);
797 if (! simple_strtoul (s, &p, &size))
799 /* The integer at P in S would overflow an unsigned long int.
800 A digit string that long is sufficiently odd looking
801 that the following diagnostic is sufficient. */
802 error (0, 0, _("invalid type string %s"), quote (s_orig));
806 size = sizeof (double);
809 if (size > MAX_FP_TYPE_SIZE
810 || fp_type_size[size] == NO_SIZE)
812 error (0, 0, _("invalid type string %s;\n\
813 this system doesn't provide a %lu-byte floating point type"),
814 quote (s_orig), size);
821 size_spec = fp_type_size[size];
826 print_function = print_float;
827 /* Don't use %#e; not all systems support it. */
828 pre_fmt_string = " %%%d.%de";
833 print_function = print_double;
834 pre_fmt_string = " %%%d.%de";
838 #ifdef HAVE_LONG_DOUBLE
839 case FLOAT_LONG_DOUBLE:
840 print_function = print_long_double;
841 pre_fmt_string = " %%%d.%dLe";
842 precision = LDBL_DIG;
850 field_width = precision + 8;
851 sprintf (tspec->fmt_string, pre_fmt_string, field_width, precision);
856 fmt = NAMED_CHARACTER;
858 print_function = print_named_ascii;
866 print_function = print_ascii;
871 error (0, 0, _("invalid character `%c' in type string %s"),
876 tspec->size = size_spec;
878 tspec->print_function = print_function;
880 tspec->field_width = field_width;
881 tspec->hexl_mode_trailer = (*s == 'z');
882 if (tspec->hexl_mode_trailer)
891 /* Given a list of one or more input filenames FILE_LIST, set the global
892 file pointer IN_STREAM and the global string INPUT_FILENAME to the
893 first one that can be successfully opened. Modify FILE_LIST to
894 reference the next filename in the list. A file name of "-" is
895 interpreted as standard input. If any file open fails, give an error
896 message and return false. */
899 open_next_file (void)
905 input_filename = *file_list;
906 if (input_filename == NULL)
910 if (STREQ (input_filename, "-"))
912 input_filename = _("standard input");
914 have_read_stdin = true;
915 if (O_BINARY && ! isatty (STDIN_FILENO))
916 freopen (NULL, "rb", stdin);
920 in_stream = fopen (input_filename, (O_BINARY ? "rb" : "r"));
921 if (in_stream == NULL)
923 error (0, errno, "%s", input_filename);
928 while (in_stream == NULL);
930 if (limit_bytes_to_format & !flag_dump_strings)
931 setvbuf (in_stream, NULL, _IONBF, 0);
936 /* Test whether there have been errors on in_stream, and close it if
937 it is not standard input. Return false if there has been an error
938 on in_stream or stdout; return true otherwise. This function will
939 report more than one error only if both a read and a write error
940 have occurred. IN_ERRNO, if nonzero, is the error number
941 corresponding to the most recent action for IN_STREAM. */
944 check_and_close (int in_errno)
948 if (in_stream != NULL)
950 if (ferror (in_stream))
952 error (0, in_errno, _("%s: read error"), input_filename);
953 if (! STREQ (file_list[-1], "-"))
957 else if (! STREQ (file_list[-1], "-") && fclose (in_stream) != 0)
959 error (0, errno, "%s", input_filename);
968 error (0, 0, _("write error"));
975 /* Decode the modern od format string S. Append the decoded
976 representation to the global array SPEC, reallocating SPEC if
977 necessary. Return true if S is valid. */
980 decode_format_string (const char *s)
982 const char *s_orig = s;
989 if (n_specs_allocated <= n_specs)
990 spec = X2NREALLOC (spec, &n_specs_allocated);
992 if (! decode_one_format (s_orig, s, &next, &spec[n_specs]))
1003 /* Given a list of one or more input filenames FILE_LIST, set the global
1004 file pointer IN_STREAM to position N_SKIP in the concatenation of
1005 those files. If any file operation fails or if there are fewer than
1006 N_SKIP bytes in the combined input, give an error message and return
1007 false. When possible, use seek rather than read operations to
1008 advance IN_STREAM. */
1011 skip (uintmax_t n_skip)
1019 while (in_stream != NULL) /* EOF. */
1021 struct stat file_stats;
1023 /* First try seeking. For large offsets, this extra work is
1024 worthwhile. If the offset is below some threshold it may be
1025 more efficient to move the pointer by reading. There are two
1026 issues when trying to seek:
1027 - the file must be seekable.
1028 - before seeking to the specified position, make sure
1029 that the new position is in the current file.
1030 Try to do that by getting file's size using fstat.
1031 But that will work only for regular files. */
1033 if (fstat (fileno (in_stream), &file_stats) == 0)
1035 /* The st_size field is valid only for regular files
1036 (and for symbolic links, which cannot occur here).
1037 If the number of bytes left to skip is larger than
1038 the size of the current file, we can decrement n_skip
1039 and go on to the next file. Skip this optimization also
1040 when st_size is 0, because some kernels report that
1041 nonempty files in /proc have st_size == 0. */
1042 if (S_ISREG (file_stats.st_mode) && 0 < file_stats.st_size)
1044 if ((uintmax_t) file_stats.st_size < n_skip)
1045 n_skip -= file_stats.st_size;
1048 if (fseeko (in_stream, n_skip, SEEK_CUR) != 0)
1057 /* If it's not a regular file with nonnegative size,
1058 position the file pointer by reading. */
1063 size_t n_bytes_read, n_bytes_to_read = BUFSIZ;
1067 if (n_skip < n_bytes_to_read)
1068 n_bytes_to_read = n_skip;
1069 n_bytes_read = fread (buf, 1, n_bytes_to_read, in_stream);
1070 n_skip -= n_bytes_read;
1071 if (n_bytes_read != n_bytes_to_read)
1085 else /* cannot fstat() file */
1087 error (0, errno, "%s", input_filename);
1091 ok &= check_and_close (in_errno);
1093 ok &= open_next_file ();
1097 error (EXIT_FAILURE, 0, _("cannot skip past end of combined input"));
1103 format_address_none (uintmax_t address ATTRIBUTE_UNUSED, char c ATTRIBUTE_UNUSED)
1108 format_address_std (uintmax_t address, char c)
1110 char buf[MAX_ADDRESS_LENGTH + 2];
1111 char *p = buf + sizeof buf;
1116 pbound = p - address_pad_len;
1118 /* Use a special case of the code for each base. This is measurably
1119 faster than generic code. */
1120 switch (address_base)
1124 *--p = '0' + (address & 7);
1125 while ((address >>= 3) != 0);
1130 *--p = '0' + (address % 10);
1131 while ((address /= 10) != 0);
1136 *--p = "0123456789abcdef"[address & 15];
1137 while ((address >>= 4) != 0);
1148 format_address_paren (uintmax_t address, char c)
1151 format_address_std (address, ')');
1157 format_address_label (uintmax_t address, char c)
1159 format_address_std (address, ' ');
1160 format_address_paren (address + pseudo_offset, c);
1163 /* Write N_BYTES bytes from CURR_BLOCK to standard output once for each
1164 of the N_SPEC format specs. CURRENT_OFFSET is the byte address of
1165 CURR_BLOCK in the concatenation of input files, and it is printed
1166 (optionally) only before the output line associated with the first
1167 format spec. When duplicate blocks are being abbreviated, the output
1168 for a sequence of identical input blocks is the output for the first
1169 block followed by an asterisk alone on a line. It is valid to compare
1170 the blocks PREV_BLOCK and CURR_BLOCK only when N_BYTES == BYTES_PER_BLOCK.
1171 That condition may be false only for the last input block -- and then
1172 only when it has not been padded to length BYTES_PER_BLOCK. */
1175 write_block (uintmax_t current_offset, size_t n_bytes,
1176 const char *prev_block, const char *curr_block)
1178 static bool first = true;
1179 static bool prev_pair_equal = false;
1181 #define EQUAL_BLOCKS(b1, b2) (memcmp (b1, b2, bytes_per_block) == 0)
1183 if (abbreviate_duplicate_blocks
1184 && !first && n_bytes == bytes_per_block
1185 && EQUAL_BLOCKS (prev_block, curr_block))
1187 if (prev_pair_equal)
1189 /* The two preceding blocks were equal, and the current
1190 block is the same as the last one, so print nothing. */
1195 prev_pair_equal = true;
1202 prev_pair_equal = false;
1203 for (i = 0; i < n_specs; i++)
1206 format_address (current_offset, '\0');
1208 printf ("%*s", address_pad_len, "");
1209 (*spec[i].print_function) (n_bytes, curr_block, spec[i].fmt_string);
1210 if (spec[i].hexl_mode_trailer)
1212 /* space-pad out to full line width, then dump the trailer */
1213 int datum_width = width_bytes[spec[i].size];
1214 int blank_fields = (bytes_per_block - n_bytes) / datum_width;
1215 int field_width = spec[i].field_width + 1;
1216 printf ("%*s", blank_fields * field_width, "");
1217 dump_hexl_mode_trailer (n_bytes, curr_block);
1225 /* Read a single byte into *C from the concatenation of the input files
1226 named in the global array FILE_LIST. On the first call to this
1227 function, the global variable IN_STREAM is expected to be an open
1228 stream associated with the input file INPUT_FILENAME. If IN_STREAM
1229 is at end-of-file, close it and update the global variables IN_STREAM
1230 and INPUT_FILENAME so they correspond to the next file in the list.
1231 Then try to read a byte from the newly opened file. Repeat if
1232 necessary until EOF is reached for the last file in FILE_LIST, then
1233 set *C to EOF and return. Subsequent calls do likewise. Return
1234 true if successful. */
1243 while (in_stream != NULL) /* EOF. */
1245 *c = fgetc (in_stream);
1250 ok &= check_and_close (errno);
1252 ok &= open_next_file ();
1258 /* Read N bytes into BLOCK from the concatenation of the input files
1259 named in the global array FILE_LIST. On the first call to this
1260 function, the global variable IN_STREAM is expected to be an open
1261 stream associated with the input file INPUT_FILENAME. If all N
1262 bytes cannot be read from IN_STREAM, close IN_STREAM and update
1263 the global variables IN_STREAM and INPUT_FILENAME. Then try to
1264 read the remaining bytes from the newly opened file. Repeat if
1265 necessary until EOF is reached for the last file in FILE_LIST.
1266 On subsequent calls, don't modify BLOCK and return true. Set
1267 *N_BYTES_IN_BUFFER to the number of bytes read. If an error occurs,
1268 it will be detected through ferror when the stream is about to be
1269 closed. If there is an error, give a message but continue reading
1270 as usual and return false. Otherwise return true. */
1273 read_block (size_t n, char *block, size_t *n_bytes_in_buffer)
1277 assert (0 < n && n <= bytes_per_block);
1279 *n_bytes_in_buffer = 0;
1284 while (in_stream != NULL) /* EOF. */
1289 n_needed = n - *n_bytes_in_buffer;
1290 n_read = fread (block + *n_bytes_in_buffer, 1, n_needed, in_stream);
1292 *n_bytes_in_buffer += n_read;
1294 if (n_read == n_needed)
1297 ok &= check_and_close (errno);
1299 ok &= open_next_file ();
1305 /* Return the least common multiple of the sizes associated
1306 with the format specs. */
1314 for (i = 0; i < n_specs; i++)
1315 l_c_m = lcm (l_c_m, width_bytes[spec[i].size]);
1319 /* If S is a valid traditional offset specification with an optional
1320 leading '+' return true and set *OFFSET to the offset it denotes. */
1323 parse_old_offset (const char *s, uintmax_t *offset)
1330 /* Skip over any leading '+'. */
1334 /* Determine the radix we'll use to interpret S. If there is a `.',
1335 it's decimal, otherwise, if the string begins with `0X'or `0x',
1336 it's hexadecimal, else octal. */
1337 if (strchr (s, '.') != NULL)
1341 if (s[0] == '0' && (s[1] == 'x' || s[1] == 'X'))
1347 return xstrtoumax (s, NULL, radix, offset, "Bb") == LONGINT_OK;
1350 /* Read a chunk of size BYTES_PER_BLOCK from the input files, write the
1351 formatted block to standard output, and repeat until the specified
1352 maximum number of bytes has been read or until all input has been
1353 processed. If the last block read is smaller than BYTES_PER_BLOCK
1354 and its size is not a multiple of the size associated with a format
1355 spec, extend the input block with zero bytes until its length is a
1356 multiple of all format spec sizes. Write the final block. Finally,
1357 write on a line by itself the offset of the byte after the last byte
1358 read. Accumulate return values from calls to read_block and
1359 check_and_close, and if any was false, return false.
1360 Otherwise, return true. */
1366 uintmax_t current_offset;
1369 size_t n_bytes_read;
1371 block[0] = xnmalloc (2, bytes_per_block);
1372 block[1] = block[0] + bytes_per_block;
1374 current_offset = n_bytes_to_skip;
1376 if (limit_bytes_to_format)
1381 if (current_offset >= end_offset)
1386 n_needed = MIN (end_offset - current_offset,
1387 (uintmax_t) bytes_per_block);
1388 ok &= read_block (n_needed, block[idx], &n_bytes_read);
1389 if (n_bytes_read < bytes_per_block)
1391 assert (n_bytes_read == bytes_per_block);
1392 write_block (current_offset, n_bytes_read,
1393 block[!idx], block[idx]);
1394 current_offset += n_bytes_read;
1402 ok &= read_block (bytes_per_block, block[idx], &n_bytes_read);
1403 if (n_bytes_read < bytes_per_block)
1405 assert (n_bytes_read == bytes_per_block);
1406 write_block (current_offset, n_bytes_read,
1407 block[!idx], block[idx]);
1408 current_offset += n_bytes_read;
1413 if (n_bytes_read > 0)
1416 size_t bytes_to_write;
1420 /* Make bytes_to_write the smallest multiple of l_c_m that
1421 is at least as large as n_bytes_read. */
1422 bytes_to_write = l_c_m * ((n_bytes_read + l_c_m - 1) / l_c_m);
1424 memset (block[idx] + n_bytes_read, 0, bytes_to_write - n_bytes_read);
1425 write_block (current_offset, bytes_to_write,
1426 block[!idx], block[idx]);
1427 current_offset += n_bytes_read;
1430 format_address (current_offset, '\n');
1432 if (limit_bytes_to_format && current_offset >= end_offset)
1433 ok &= check_and_close (0);
1440 /* STRINGS mode. Find each "string constant" in the input.
1441 A string constant is a run of at least `string_min' ASCII
1442 graphic (or formatting) characters terminated by a null.
1443 Based on a function written by Richard Stallman for a
1444 traditional version of od. Return true if successful. */
1449 size_t bufsize = MAX (100, string_min);
1450 char *buf = xmalloc (bufsize);
1451 uintmax_t address = n_bytes_to_skip;
1459 /* See if the next `string_min' chars are all printing chars. */
1462 if (limit_bytes_to_format
1463 && (end_offset < string_min || end_offset - string_min <= address))
1466 for (i = 0; i < string_min; i++)
1468 ok &= read_char (&c);
1476 /* Found a non-printing. Try again starting with next char. */
1481 /* We found a run of `string_min' printable characters.
1482 Now see if it is terminated with a null byte. */
1483 while (!limit_bytes_to_format || address < end_offset)
1487 buf = X2REALLOC (buf, &bufsize);
1489 ok &= read_char (&c);
1497 break; /* It is; print this string. */
1499 goto tryline; /* It isn't; give up on this string. */
1500 buf[i++] = c; /* String continues; store it all. */
1503 /* If we get here, the string is all printable and null-terminated,
1504 so print it. It is all in `buf' and `i' is its length. */
1506 format_address (address - i - 1, ' ');
1508 for (i = 0; (c = buf[i]); i++)
1513 fputs ("\\a", stdout);
1517 fputs ("\\b", stdout);
1521 fputs ("\\f", stdout);
1525 fputs ("\\n", stdout);
1529 fputs ("\\r", stdout);
1533 fputs ("\\t", stdout);
1537 fputs ("\\v", stdout);
1547 /* We reach this point only if we search through
1548 (max_bytes_to_format - string_min) bytes before reaching EOF. */
1552 ok &= check_and_close (0);
1557 main (int argc, char **argv)
1562 size_t desired_width IF_LINT (= 0);
1563 bool modern = false;
1564 bool width_specified = false;
1566 static char const multipliers[] = "bEGKkMmPTYZ0";
1568 /* The old-style `pseudo starting address' to be printed in parentheses
1569 after any true address. */
1570 uintmax_t pseudo_start IF_LINT (= 0);
1572 initialize_main (&argc, &argv);
1573 program_name = argv[0];
1574 setlocale (LC_ALL, "");
1575 bindtextdomain (PACKAGE, LOCALEDIR);
1576 textdomain (PACKAGE);
1578 atexit (close_stdout);
1580 for (i = 0; i <= MAX_INTEGRAL_TYPE_SIZE; i++)
1581 integral_type_size[i] = NO_SIZE;
1583 integral_type_size[sizeof (char)] = CHAR;
1584 integral_type_size[sizeof (short int)] = SHORT;
1585 integral_type_size[sizeof (int)] = INT;
1586 integral_type_size[sizeof (long int)] = LONG;
1587 #if HAVE_UNSIGNED_LONG_LONG_INT
1588 /* If `long int' and `long long int' have the same size, it's fine
1589 to overwrite the entry for `long' with this one. */
1590 integral_type_size[sizeof (unsigned_long_long_int)] = LONG_LONG;
1593 for (i = 0; i <= MAX_FP_TYPE_SIZE; i++)
1594 fp_type_size[i] = NO_SIZE;
1596 fp_type_size[sizeof (float)] = FLOAT_SINGLE;
1597 /* The array entry for `double' is filled in after that for LONG_DOUBLE
1598 so that if `long double' is the same type or if long double isn't
1599 supported FLOAT_LONG_DOUBLE will never be used. */
1600 fp_type_size[sizeof (LONG_DOUBLE)] = FLOAT_LONG_DOUBLE;
1601 fp_type_size[sizeof (double)] = FLOAT_DOUBLE;
1604 n_specs_allocated = 0;
1607 format_address = format_address_std;
1609 address_pad_len = 7;
1610 flag_dump_strings = false;
1615 enum strtol_error s_err;
1617 int c = getopt_long (argc, argv, short_options, long_options, &oi);
1628 format_address = format_address_std;
1630 address_pad_len = 7;
1633 format_address = format_address_std;
1635 address_pad_len = 7;
1638 format_address = format_address_std;
1640 address_pad_len = 6;
1643 format_address = format_address_none;
1644 address_pad_len = 0;
1647 error (EXIT_FAILURE, 0,
1648 _("invalid output address radix `%c'; \
1649 it must be one character from [doxn]"),
1657 s_err = xstrtoumax (optarg, NULL, 0, &n_bytes_to_skip, multipliers);
1658 if (s_err != LONGINT_OK)
1659 xstrtol_fatal (s_err, oi, c, long_options, optarg);
1664 limit_bytes_to_format = true;
1666 s_err = xstrtoumax (optarg, NULL, 0, &max_bytes_to_format,
1668 if (s_err != LONGINT_OK)
1669 xstrtol_fatal (s_err, oi, c, long_options, optarg);
1678 s_err = xstrtoumax (optarg, NULL, 0, &tmp, multipliers);
1679 if (s_err != LONGINT_OK)
1680 xstrtol_fatal (s_err, oi, c, long_options, optarg);
1682 /* The minimum string length may be no larger than SIZE_MAX,
1683 since we may allocate a buffer of this size. */
1685 error (EXIT_FAILURE, 0, _("%s is too large"), optarg);
1689 flag_dump_strings = true;
1694 ok &= decode_format_string (optarg);
1699 abbreviate_duplicate_blocks = false;
1702 case TRADITIONAL_OPTION:
1706 /* The next several cases map the traditional format
1707 specification options to the corresponding modern format
1708 specs. GNU od accepts any combination of old- and
1709 new-style options. Format specification options accumulate.
1710 The obsolescent and undocumented formats are compatible
1711 with FreeBSD 4.10 od. */
1713 #define CASE_OLD_ARG(old_char,new_string) \
1715 ok &= decode_format_string (new_string); \
1718 CASE_OLD_ARG ('a', "a");
1719 CASE_OLD_ARG ('b', "o1");
1720 CASE_OLD_ARG ('c', "c");
1721 CASE_OLD_ARG ('D', "u4"); /* obsolescent and undocumented */
1722 CASE_OLD_ARG ('d', "u2");
1723 case 'F': /* obsolescent and undocumented alias */
1724 CASE_OLD_ARG ('e', "fD"); /* obsolescent and undocumented */
1725 CASE_OLD_ARG ('f', "fF");
1726 case 'X': /* obsolescent and undocumented alias */
1727 CASE_OLD_ARG ('H', "x4"); /* obsolescent and undocumented */
1728 CASE_OLD_ARG ('i', "dI");
1729 case 'I': case 'L': /* obsolescent and undocumented aliases */
1730 CASE_OLD_ARG ('l', "dL");
1731 CASE_OLD_ARG ('O', "o4"); /* obsolesent and undocumented */
1732 case 'B': /* obsolescent and undocumented alias */
1733 CASE_OLD_ARG ('o', "o2");
1734 CASE_OLD_ARG ('s', "d2");
1735 case 'h': /* obsolescent and undocumented alias */
1736 CASE_OLD_ARG ('x', "x2");
1742 width_specified = true;
1750 s_err = xstrtoumax (optarg, NULL, 10, &w_tmp, "");
1751 if (s_err != LONGINT_OK)
1752 xstrtol_fatal (s_err, oi, c, long_options, optarg);
1753 if (SIZE_MAX < w_tmp)
1754 error (EXIT_FAILURE, 0, _("%s is too large"), optarg);
1755 desired_width = w_tmp;
1759 case_GETOPT_HELP_CHAR;
1761 case_GETOPT_VERSION_CHAR (PROGRAM_NAME, AUTHORS);
1764 usage (EXIT_FAILURE);
1770 exit (EXIT_FAILURE);
1772 if (flag_dump_strings && n_specs > 0)
1773 error (EXIT_FAILURE, 0,
1774 _("no type may be specified when dumping strings"));
1776 n_files = argc - optind;
1778 /* If the --traditional option is used, there may be from
1779 0 to 3 remaining command line arguments; handle each case
1781 od [file] [[+]offset[.][b] [[+]label[.][b]]]
1782 The offset and label have the same syntax.
1784 If --traditional is not given, and if no modern options are
1785 given, and if the offset begins with + or (if there are two
1786 operands) a digit, accept only this form, as per POSIX:
1787 od [file] [[+]offset[.][b]]
1790 if (!modern | traditional)
1798 if ((traditional || argv[optind][0] == '+')
1799 && parse_old_offset (argv[optind], &o1))
1801 n_bytes_to_skip = o1;
1808 if ((traditional || argv[optind + 1][0] == '+'
1809 || ISDIGIT (argv[optind + 1][0]))
1810 && parse_old_offset (argv[optind + 1], &o2))
1812 if (traditional && parse_old_offset (argv[optind], &o1))
1814 n_bytes_to_skip = o1;
1815 flag_pseudo_start = true;
1822 n_bytes_to_skip = o2;
1824 argv[optind + 1] = argv[optind];
1832 && parse_old_offset (argv[optind + 1], &o1)
1833 && parse_old_offset (argv[optind + 2], &o2))
1835 n_bytes_to_skip = o1;
1836 flag_pseudo_start = true;
1838 argv[optind + 2] = argv[optind];
1845 if (traditional && 1 < n_files)
1847 error (0, 0, _("extra operand %s"), quote (argv[optind + 1]));
1848 error (0, 0, "%s\n",
1849 _("Compatibility mode supports at most one file."));
1850 usage (EXIT_FAILURE);
1854 if (flag_pseudo_start)
1856 if (format_address == format_address_none)
1859 address_pad_len = 7;
1860 format_address = format_address_paren;
1863 format_address = format_address_label;
1866 if (limit_bytes_to_format)
1868 end_offset = n_bytes_to_skip + max_bytes_to_format;
1869 if (end_offset < n_bytes_to_skip)
1870 error (EXIT_FAILURE, 0, _("skip-bytes + read-bytes is too large"));
1874 decode_format_string ("oS");
1878 /* Set the global pointer FILE_LIST so that it
1879 references the first file-argument on the command-line. */
1881 file_list = (char const *const *) &argv[optind];
1885 /* No files were listed on the command line.
1886 Set the global pointer FILE_LIST so that it
1887 references the null-terminated list of one name: "-". */
1889 file_list = default_file_list;
1892 /* open the first input file */
1893 ok = open_next_file ();
1894 if (in_stream == NULL)
1897 /* skip over any unwanted header bytes */
1898 ok &= skip (n_bytes_to_skip);
1899 if (in_stream == NULL)
1902 pseudo_offset = (flag_pseudo_start ? pseudo_start - n_bytes_to_skip : 0);
1904 /* Compute output block length. */
1907 if (width_specified)
1909 if (desired_width != 0 && desired_width % l_c_m == 0)
1910 bytes_per_block = desired_width;
1913 error (0, 0, _("warning: invalid width %lu; using %d instead"),
1914 (unsigned long int) desired_width, l_c_m);
1915 bytes_per_block = l_c_m;
1920 if (l_c_m < DEFAULT_BYTES_PER_BLOCK)
1921 bytes_per_block = l_c_m * (DEFAULT_BYTES_PER_BLOCK / l_c_m);
1923 bytes_per_block = l_c_m;
1927 for (i = 0; i < n_specs; i++)
1929 printf (_("%d: fmt=\"%s\" width=%d\n"),
1930 i, spec[i].fmt_string, width_bytes[spec[i].size]);
1934 ok &= (flag_dump_strings ? dump_strings () : dump ());
1938 if (have_read_stdin && fclose (stdin) == EOF)
1939 error (EXIT_FAILURE, errno, _("standard input"));
1941 exit (ok ? EXIT_SUCCESS : EXIT_FAILURE);