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>
32 /* The official name of this program (e.g., no `g' prefix). */
33 #define PROGRAM_NAME "od"
35 #define AUTHORS proper_name ("Jim Meyering")
39 /* The default number of input bytes per output line. */
40 #define DEFAULT_BYTES_PER_BLOCK 16
42 /* The number of decimal digits of precision in a float. */
47 /* The number of decimal digits of precision in a double. */
52 #if HAVE_UNSIGNED_LONG_LONG_INT
53 typedef unsigned long long int unsigned_long_long_int;
55 /* This is just a place-holder to avoid a few `#if' directives.
56 In this case, the type isn't actually used. */
57 typedef unsigned long int unsigned_long_long_int;
68 /* FIXME: add INTMAX support, too */
86 #define MAX_INTEGRAL_TYPE_SIZE sizeof (unsigned_long_long_int)
88 /* The maximum number of bytes needed for a format string, including
89 the trailing nul. Each format string expects a variable amount of
90 padding (guaranteed to be at least 1 plus the field width), then an
91 element that will be formatted in the field. */
95 MAX ((sizeof "%*.99" - 1
104 /* Ensure that our choice for FMT_BYTES_ALLOCATED is reasonable. */
105 verify (LDBL_DIG <= 99);
106 verify (MAX_INTEGRAL_TYPE_SIZE * CHAR_BIT / 3 <= 99);
108 /* Each output format specification (from `-t spec' or from
109 old-style options) is represented by one of these structures. */
112 enum output_format fmt;
113 enum size_spec size; /* Type of input object. */
114 /* FIELDS is the number of fields per line, BLANK is the number of
115 fields to leave blank. WIDTH is width of one field, excluding
116 leading space, and PAD is total pad to divide among FIELDS.
117 PAD is at least as large as FIELDS. */
118 void (*print_function) (size_t fields, size_t blank, void const *data,
119 char const *fmt, int width, int pad);
120 char fmt_string[FMT_BYTES_ALLOCATED]; /* Of the style "%*d". */
121 bool hexl_mode_trailer;
122 int field_width; /* Minimum width of a field, excluding leading space. */
123 int pad_width; /* Total padding to be divided among fields. */
126 /* Convert the number of 8-bit bytes of a binary representation to
127 the number of characters (digits + sign if the type is signed)
128 required to represent the same quantity in the specified base/type.
129 For example, a 32-bit (4-byte) quantity may require a field width
130 as wide as the following for these types:
134 8 unsigned hexadecimal */
136 static unsigned int const bytes_to_oct_digits[] =
137 {0, 3, 6, 8, 11, 14, 16, 19, 22, 25, 27, 30, 32, 35, 38, 41, 43};
139 static unsigned int const bytes_to_signed_dec_digits[] =
140 {1, 4, 6, 8, 11, 13, 16, 18, 20, 23, 25, 28, 30, 33, 35, 37, 40};
142 static unsigned int const bytes_to_unsigned_dec_digits[] =
143 {0, 3, 5, 8, 10, 13, 15, 17, 20, 22, 25, 27, 29, 32, 34, 37, 39};
145 static unsigned int const bytes_to_hex_digits[] =
146 {0, 2, 4, 6, 8, 10, 12, 14, 16, 18, 20, 22, 24, 26, 28, 30, 32};
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 char const charname[33][4] =
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 /* Minimum length when detecting --strings. */
199 static size_t string_min;
201 /* True when in --strings mode. */
202 static bool flag_dump_strings;
204 /* True if we should recognize the older non-option arguments
205 that specified at most one file and optional arguments specifying
206 offset and pseudo-start address. */
207 static bool traditional;
209 /* True if an old-style `pseudo-address' was specified. */
210 static bool flag_pseudo_start;
212 /* The difference between the old-style pseudo starting address and
213 the number of bytes to skip. */
214 static uintmax_t pseudo_offset;
216 /* Function that accepts an address and an optional following char,
217 and prints the address and char to stdout. */
218 static void (*format_address) (uintmax_t, char);
220 /* The number of input bytes to skip before formatting and writing. */
221 static uintmax_t n_bytes_to_skip = 0;
223 /* When false, MAX_BYTES_TO_FORMAT and END_OFFSET are ignored, and all
224 input is formatted. */
225 static bool limit_bytes_to_format = false;
227 /* The maximum number of bytes that will be formatted. */
228 static uintmax_t max_bytes_to_format;
230 /* The offset of the first byte after the last byte to be formatted. */
231 static uintmax_t end_offset;
233 /* When true and two or more consecutive blocks are equal, format
234 only the first block and output an asterisk alone on the following
235 line to indicate that identical blocks have been elided. */
236 static bool abbreviate_duplicate_blocks = true;
238 /* An array of specs describing how to format each input block. */
239 static struct tspec *spec;
241 /* The number of format specs. */
242 static size_t n_specs;
244 /* The allocated length of SPEC. */
245 static size_t n_specs_allocated;
247 /* The number of input bytes formatted per output line. It must be
248 a multiple of the least common multiple of the sizes associated with
249 the specified output types. It should be as large as possible, but
250 no larger than 16 -- unless specified with the -w option. */
251 static size_t bytes_per_block;
253 /* Human-readable representation of *file_list (for error messages).
254 It differs from file_list[-1] only when file_list[-1] is "-". */
255 static char const *input_filename;
257 /* A NULL-terminated list of the file-arguments from the command line. */
258 static char const *const *file_list;
260 /* Initializer for file_list if no file-arguments
261 were specified on the command line. */
262 static char const *const default_file_list[] = {"-", NULL};
264 /* The input stream associated with the current file. */
265 static FILE *in_stream;
267 /* If true, at least one of the files we read was standard input. */
268 static bool have_read_stdin;
270 /* Map the size in bytes to a type identifier. */
271 static enum size_spec integral_type_size[MAX_INTEGRAL_TYPE_SIZE + 1];
273 #define MAX_FP_TYPE_SIZE sizeof (long double)
274 static enum size_spec fp_type_size[MAX_FP_TYPE_SIZE + 1];
276 static char const short_options[] = "A:aBbcDdeFfHhIij:LlN:OoS:st:vw::Xx";
278 /* For long options that have no equivalent short option, use a
279 non-character as a pseudo short option, starting with CHAR_MAX + 1. */
282 TRADITIONAL_OPTION = CHAR_MAX + 1
285 static struct option const long_options[] =
287 {"skip-bytes", required_argument, NULL, 'j'},
288 {"address-radix", required_argument, NULL, 'A'},
289 {"read-bytes", required_argument, NULL, 'N'},
290 {"format", required_argument, NULL, 't'},
291 {"output-duplicates", no_argument, NULL, 'v'},
292 {"strings", optional_argument, NULL, 'S'},
293 {"traditional", no_argument, NULL, TRADITIONAL_OPTION},
294 {"width", optional_argument, NULL, 'w'},
296 {GETOPT_HELP_OPTION_DECL},
297 {GETOPT_VERSION_OPTION_DECL},
304 if (status != EXIT_SUCCESS)
305 fprintf (stderr, _("Try `%s --help' for more information.\n"),
310 Usage: %s [OPTION]... [FILE]...\n\
311 or: %s [-abcdfilosx]... [FILE] [[+]OFFSET[.][b]]\n\
312 or: %s --traditional [OPTION]... [FILE] [[+]OFFSET[.][b] [+][LABEL][.][b]]\n\
314 program_name, program_name, program_name);
316 Write an unambiguous representation, octal bytes by default,\n\
317 of FILE to standard output. With more than one FILE argument,\n\
318 concatenate them in the listed order to form the input.\n\
319 With no FILE, or when FILE is -, read standard input.\n\
323 All arguments to long options are mandatory for short options.\n\
326 -A, --address-radix=RADIX decide how file offsets are printed\n\
327 -j, --skip-bytes=BYTES skip BYTES input bytes first\n\
330 -N, --read-bytes=BYTES limit dump to BYTES input bytes\n\
331 -S, --strings[=BYTES] output strings of at least BYTES graphic chars\n\
332 -t, --format=TYPE select output format or formats\n\
333 -v, --output-duplicates do not use * to mark line suppression\n\
334 -w, --width[=BYTES] output BYTES bytes per output line\n\
335 --traditional accept arguments in traditional form\n\
337 fputs (HELP_OPTION_DESCRIPTION, stdout);
338 fputs (VERSION_OPTION_DESCRIPTION, stdout);
341 Traditional format specifications may be intermixed; they accumulate:\n\
342 -a same as -t a, select named characters, ignoring high-order bit\n\
343 -b same as -t o1, select octal bytes\n\
344 -c same as -t c, select ASCII characters or backslash escapes\n\
345 -d same as -t u2, select unsigned decimal 2-byte units\n\
348 -f same as -t fF, select floats\n\
349 -i same as -t dI, select decimal ints\n\
350 -l same as -t dL, select decimal longs\n\
351 -o same as -t o2, select octal 2-byte units\n\
352 -s same as -t d2, select decimal 2-byte units\n\
353 -x same as -t x2, select hexadecimal 2-byte units\n\
357 If first and second call formats both apply, the second format is assumed\n\
358 if the last operand begins with + or (if there are 2 operands) a digit.\n\
359 An OFFSET operand means -j OFFSET. LABEL is the pseudo-address\n\
360 at first byte printed, incremented when dump is progressing.\n\
361 For OFFSET and LABEL, a 0x or 0X prefix indicates hexadecimal;\n\
362 suffixes may be . for octal and b for multiply by 512.\n\
366 TYPE is made up of one or more of these specifications:\n\
368 a named character, ignoring high-order bit\n\
369 c ASCII character or backslash escape\n\
372 d[SIZE] signed decimal, SIZE bytes per integer\n\
373 f[SIZE] floating point, SIZE bytes per integer\n\
374 o[SIZE] octal, SIZE bytes per integer\n\
375 u[SIZE] unsigned decimal, SIZE bytes per integer\n\
376 x[SIZE] hexadecimal, SIZE bytes per integer\n\
380 SIZE is a number. For TYPE in doux, SIZE may also be C for\n\
381 sizeof(char), S for sizeof(short), I for sizeof(int) or L for\n\
382 sizeof(long). If TYPE is f, SIZE may also be F for sizeof(float), D\n\
383 for sizeof(double) or L for sizeof(long double).\n\
387 RADIX is d for decimal, o for octal, x for hexadecimal or n for none.\n\
388 BYTES is hexadecimal with 0x or 0X prefix, and may have a multiplier suffix:\n\
389 b 512, kB 1000, K 1024, MB 1000*1000, M 1024*1024,\n\
390 GB 1000*1000*1000, G 1024*1024*1024, and so on for T, P, E, Z, Y.\n\
391 Adding a z suffix to any type displays printable characters at the end of each\n\
395 Option --string without a number implies 3; option --width without a number\n\
396 implies 32. By default, od uses -A o -t oS -w16.\n\
398 emit_bug_reporting_address ();
403 /* Define the print functions. */
405 #define PRINT_TYPE(N, T) \
407 N (size_t fields, size_t blank, void const *block, \
408 char const *fmt_string, int width, int pad) \
410 T const *p = block; \
412 int pad_remaining = pad; \
413 for (i = fields; blank < i; i--) \
415 int next_pad = pad * (i - 1) / fields; \
416 xprintf (fmt_string, pad_remaining - next_pad + width, *p++); \
417 pad_remaining = next_pad; \
421 PRINT_TYPE (print_s_char, signed char)
422 PRINT_TYPE (print_char, unsigned char)
423 PRINT_TYPE (print_s_short, short int)
424 PRINT_TYPE (print_short, unsigned short int)
425 PRINT_TYPE (print_int, unsigned int)
426 PRINT_TYPE (print_long, unsigned long int)
427 PRINT_TYPE (print_long_long, unsigned_long_long_int)
428 PRINT_TYPE (print_float, float)
429 PRINT_TYPE (print_double, double)
430 PRINT_TYPE (print_long_double, long double)
435 dump_hexl_mode_trailer (size_t n_bytes, const char *block)
438 fputs (" >", stdout);
439 for (i = n_bytes; i > 0; i--)
441 unsigned char c = *block++;
442 unsigned char c2 = (isprint (c) ? c : '.');
449 print_named_ascii (size_t fields, size_t blank, void const *block,
450 const char *unused_fmt_string ATTRIBUTE_UNUSED,
453 unsigned char const *p = block;
455 int pad_remaining = pad;
456 for (i = fields; blank < i; i--)
458 int next_pad = pad * (i - 1) / fields;
459 int masked_c = *p++ & 0x7f;
465 else if (masked_c <= 040)
466 s = charname[masked_c];
474 xprintf ("%*s", pad_remaining - next_pad + width, s);
475 pad_remaining = next_pad;
480 print_ascii (size_t fields, size_t blank, void const *block,
481 const char *unused_fmt_string ATTRIBUTE_UNUSED, int width,
484 unsigned char const *p = block;
486 int pad_remaining = pad;
487 for (i = fields; blank < i; i--)
489 int next_pad = pad * (i - 1) / fields;
490 unsigned char c = *p++;
529 sprintf (buf, (isprint (c) ? "%c" : "%03o"), c);
533 xprintf ("%*s", pad_remaining - next_pad + width, s);
534 pad_remaining = next_pad;
538 /* Convert a null-terminated (possibly zero-length) string S to an
539 unsigned long integer value. If S points to a non-digit set *P to S,
540 *VAL to 0, and return true. Otherwise, accumulate the integer value of
541 the string of digits. If the string of digits represents a value
542 larger than ULONG_MAX, don't modify *VAL or *P and return false.
543 Otherwise, advance *P to the first non-digit after S, set *VAL to
544 the result of the conversion and return true. */
547 simple_strtoul (const char *s, const char **p, unsigned long int *val)
549 unsigned long int sum;
555 if (sum > (ULONG_MAX - c) / 10)
564 /* If S points to a single valid modern od format string, put
565 a description of that format in *TSPEC, make *NEXT point at the
566 character following the just-decoded format (if *NEXT is non-NULL),
567 and return true. If S is not valid, don't modify *NEXT or *TSPEC,
568 give a diagnostic, and return false. For example, if S were
569 "d4afL" *NEXT would be set to "afL" and *TSPEC would be
571 fmt = SIGNED_DECIMAL;
572 size = INT or LONG; (whichever integral_type_size[4] resolves to)
573 print_function = print_int; (assuming size == INT)
577 pad_width is determined later, but is at least as large as the
578 number of fields printed per row.
579 S_ORIG is solely for reporting errors. It should be the full format
584 decode_one_format (const char *s_orig, const char *s, const char **next,
587 enum size_spec size_spec;
588 unsigned long int size;
589 enum output_format fmt;
590 const char *pre_fmt_string;
591 void (*print_function) (size_t, size_t, void const *, char const *,
598 assert (tspec != NULL);
612 size = sizeof (char);
617 size = sizeof (short int);
627 size = sizeof (long int);
631 if (! simple_strtoul (s, &p, &size))
633 /* The integer at P in S would overflow an unsigned long int.
634 A digit string that long is sufficiently odd looking
635 that the following diagnostic is sufficient. */
636 error (0, 0, _("invalid type string %s"), quote (s_orig));
643 if (MAX_INTEGRAL_TYPE_SIZE < size
644 || integral_type_size[size] == NO_SIZE)
646 error (0, 0, _("invalid type string %s;\n\
647 this system doesn't provide a %lu-byte integral type"), quote (s_orig), size);
655 #define ISPEC_TO_FORMAT(Spec, Min_format, Long_format, Max_format) \
656 ((Spec) == LONG_LONG ? (Max_format) \
657 : ((Spec) == LONG ? (Long_format) \
660 size_spec = integral_type_size[size];
665 fmt = SIGNED_DECIMAL;
666 field_width = bytes_to_signed_dec_digits[size];
667 sprintf (tspec->fmt_string, "%%*%s",
668 ISPEC_TO_FORMAT (size_spec, "d", "ld", PRIdMAX));
673 sprintf (tspec->fmt_string, "%%*.%d%s",
674 (field_width = bytes_to_oct_digits[size]),
675 ISPEC_TO_FORMAT (size_spec, "o", "lo", PRIoMAX));
679 fmt = UNSIGNED_DECIMAL;
680 field_width = bytes_to_unsigned_dec_digits[size];
681 sprintf (tspec->fmt_string, "%%*%s",
682 ISPEC_TO_FORMAT (size_spec, "u", "lu", PRIuMAX));
687 sprintf (tspec->fmt_string, "%%*.%d%s",
688 (field_width = bytes_to_hex_digits[size]),
689 ISPEC_TO_FORMAT (size_spec, "x", "lx", PRIxMAX));
696 assert (strlen (tspec->fmt_string) < FMT_BYTES_ALLOCATED);
701 print_function = (fmt == SIGNED_DECIMAL
707 print_function = (fmt == SIGNED_DECIMAL
713 print_function = print_int;
717 print_function = print_long;
721 print_function = print_long_long;
730 fmt = FLOATING_POINT;
736 size = sizeof (float);
741 size = sizeof (double);
746 size = sizeof (long double);
750 if (! simple_strtoul (s, &p, &size))
752 /* The integer at P in S would overflow an unsigned long int.
753 A digit string that long is sufficiently odd looking
754 that the following diagnostic is sufficient. */
755 error (0, 0, _("invalid type string %s"), quote (s_orig));
759 size = sizeof (double);
762 if (size > MAX_FP_TYPE_SIZE
763 || fp_type_size[size] == NO_SIZE)
765 error (0, 0, _("invalid type string %s;\n\
766 this system doesn't provide a %lu-byte floating point type"),
767 quote (s_orig), size);
774 size_spec = fp_type_size[size];
779 print_function = print_float;
780 /* FIXME - should we use %g instead of %e? */
781 pre_fmt_string = "%%*.%de";
786 print_function = print_double;
787 pre_fmt_string = "%%*.%de";
791 case FLOAT_LONG_DOUBLE:
792 print_function = print_long_double;
793 pre_fmt_string = "%%*.%dLe";
794 precision = LDBL_DIG;
801 field_width = precision + 8;
802 sprintf (tspec->fmt_string, pre_fmt_string, precision);
803 assert (strlen (tspec->fmt_string) < FMT_BYTES_ALLOCATED);
808 fmt = NAMED_CHARACTER;
810 print_function = print_named_ascii;
818 print_function = print_ascii;
823 error (0, 0, _("invalid character `%c' in type string %s"),
828 tspec->size = size_spec;
830 tspec->print_function = print_function;
832 tspec->field_width = field_width;
833 tspec->hexl_mode_trailer = (*s == 'z');
834 if (tspec->hexl_mode_trailer)
843 /* Given a list of one or more input filenames FILE_LIST, set the global
844 file pointer IN_STREAM and the global string INPUT_FILENAME to the
845 first one that can be successfully opened. Modify FILE_LIST to
846 reference the next filename in the list. A file name of "-" is
847 interpreted as standard input. If any file open fails, give an error
848 message and return false. */
851 open_next_file (void)
857 input_filename = *file_list;
858 if (input_filename == NULL)
862 if (STREQ (input_filename, "-"))
864 input_filename = _("standard input");
866 have_read_stdin = true;
867 if (O_BINARY && ! isatty (STDIN_FILENO))
868 xfreopen (NULL, "rb", stdin);
872 in_stream = fopen (input_filename, (O_BINARY ? "rb" : "r"));
873 if (in_stream == NULL)
875 error (0, errno, "%s", input_filename);
880 while (in_stream == NULL);
882 if (limit_bytes_to_format & !flag_dump_strings)
883 setvbuf (in_stream, NULL, _IONBF, 0);
888 /* Test whether there have been errors on in_stream, and close it if
889 it is not standard input. Return false if there has been an error
890 on in_stream or stdout; return true otherwise. This function will
891 report more than one error only if both a read and a write error
892 have occurred. IN_ERRNO, if nonzero, is the error number
893 corresponding to the most recent action for IN_STREAM. */
896 check_and_close (int in_errno)
900 if (in_stream != NULL)
902 if (ferror (in_stream))
904 error (0, in_errno, _("%s: read error"), input_filename);
905 if (! STREQ (file_list[-1], "-"))
909 else if (! STREQ (file_list[-1], "-") && fclose (in_stream) != 0)
911 error (0, errno, "%s", input_filename);
920 error (0, 0, _("write error"));
927 /* Decode the modern od format string S. Append the decoded
928 representation to the global array SPEC, reallocating SPEC if
929 necessary. Return true if S is valid. */
932 decode_format_string (const char *s)
934 const char *s_orig = s;
941 if (n_specs_allocated <= n_specs)
942 spec = X2NREALLOC (spec, &n_specs_allocated);
944 if (! decode_one_format (s_orig, s, &next, &spec[n_specs]))
955 /* Given a list of one or more input filenames FILE_LIST, set the global
956 file pointer IN_STREAM to position N_SKIP in the concatenation of
957 those files. If any file operation fails or if there are fewer than
958 N_SKIP bytes in the combined input, give an error message and return
959 false. When possible, use seek rather than read operations to
960 advance IN_STREAM. */
963 skip (uintmax_t n_skip)
971 while (in_stream != NULL) /* EOF. */
973 struct stat file_stats;
975 /* First try seeking. For large offsets, this extra work is
976 worthwhile. If the offset is below some threshold it may be
977 more efficient to move the pointer by reading. There are two
978 issues when trying to seek:
979 - the file must be seekable.
980 - before seeking to the specified position, make sure
981 that the new position is in the current file.
982 Try to do that by getting file's size using fstat.
983 But that will work only for regular files. */
985 if (fstat (fileno (in_stream), &file_stats) == 0)
987 /* The st_size field is valid only for regular files
988 (and for symbolic links, which cannot occur here).
989 If the number of bytes left to skip is larger than
990 the size of the current file, we can decrement n_skip
991 and go on to the next file. Skip this optimization also
992 when st_size is 0, because some kernels report that
993 nonempty files in /proc have st_size == 0. */
994 if (S_ISREG (file_stats.st_mode) && 0 < file_stats.st_size)
996 if ((uintmax_t) file_stats.st_size < n_skip)
997 n_skip -= file_stats.st_size;
1000 if (fseeko (in_stream, n_skip, SEEK_CUR) != 0)
1009 /* If it's not a regular file with nonnegative size,
1010 position the file pointer by reading. */
1015 size_t n_bytes_read, n_bytes_to_read = BUFSIZ;
1019 if (n_skip < n_bytes_to_read)
1020 n_bytes_to_read = n_skip;
1021 n_bytes_read = fread (buf, 1, n_bytes_to_read, in_stream);
1022 n_skip -= n_bytes_read;
1023 if (n_bytes_read != n_bytes_to_read)
1037 else /* cannot fstat() file */
1039 error (0, errno, "%s", input_filename);
1043 ok &= check_and_close (in_errno);
1045 ok &= open_next_file ();
1049 error (EXIT_FAILURE, 0, _("cannot skip past end of combined input"));
1055 format_address_none (uintmax_t address ATTRIBUTE_UNUSED, char c ATTRIBUTE_UNUSED)
1060 format_address_std (uintmax_t address, char c)
1062 char buf[MAX_ADDRESS_LENGTH + 2];
1063 char *p = buf + sizeof buf;
1068 pbound = p - address_pad_len;
1070 /* Use a special case of the code for each base. This is measurably
1071 faster than generic code. */
1072 switch (address_base)
1076 *--p = '0' + (address & 7);
1077 while ((address >>= 3) != 0);
1082 *--p = '0' + (address % 10);
1083 while ((address /= 10) != 0);
1088 *--p = "0123456789abcdef"[address & 15];
1089 while ((address >>= 4) != 0);
1100 format_address_paren (uintmax_t address, char c)
1103 format_address_std (address, ')');
1109 format_address_label (uintmax_t address, char c)
1111 format_address_std (address, ' ');
1112 format_address_paren (address + pseudo_offset, c);
1115 /* Write N_BYTES bytes from CURR_BLOCK to standard output once for each
1116 of the N_SPEC format specs. CURRENT_OFFSET is the byte address of
1117 CURR_BLOCK in the concatenation of input files, and it is printed
1118 (optionally) only before the output line associated with the first
1119 format spec. When duplicate blocks are being abbreviated, the output
1120 for a sequence of identical input blocks is the output for the first
1121 block followed by an asterisk alone on a line. It is valid to compare
1122 the blocks PREV_BLOCK and CURR_BLOCK only when N_BYTES == BYTES_PER_BLOCK.
1123 That condition may be false only for the last input block. */
1126 write_block (uintmax_t current_offset, size_t n_bytes,
1127 const char *prev_block, const char *curr_block)
1129 static bool first = true;
1130 static bool prev_pair_equal = false;
1132 #define EQUAL_BLOCKS(b1, b2) (memcmp (b1, b2, bytes_per_block) == 0)
1134 if (abbreviate_duplicate_blocks
1135 && !first && n_bytes == bytes_per_block
1136 && EQUAL_BLOCKS (prev_block, curr_block))
1138 if (prev_pair_equal)
1140 /* The two preceding blocks were equal, and the current
1141 block is the same as the last one, so print nothing. */
1146 prev_pair_equal = true;
1153 prev_pair_equal = false;
1154 for (i = 0; i < n_specs; i++)
1156 int datum_width = width_bytes[spec[i].size];
1157 int fields_per_block = bytes_per_block / datum_width;
1158 int blank_fields = (bytes_per_block - n_bytes) / datum_width;
1160 format_address (current_offset, '\0');
1162 printf ("%*s", address_pad_len, "");
1163 (*spec[i].print_function) (fields_per_block, blank_fields,
1164 curr_block, spec[i].fmt_string,
1165 spec[i].field_width, spec[i].pad_width);
1166 if (spec[i].hexl_mode_trailer)
1168 /* space-pad out to full line width, then dump the trailer */
1169 int field_width = spec[i].field_width;
1170 int pad_width = (spec[i].pad_width * blank_fields
1171 / fields_per_block);
1172 printf ("%*s", blank_fields * field_width + pad_width, "");
1173 dump_hexl_mode_trailer (n_bytes, curr_block);
1181 /* Read a single byte into *C from the concatenation of the input files
1182 named in the global array FILE_LIST. On the first call to this
1183 function, the global variable IN_STREAM is expected to be an open
1184 stream associated with the input file INPUT_FILENAME. If IN_STREAM
1185 is at end-of-file, close it and update the global variables IN_STREAM
1186 and INPUT_FILENAME so they correspond to the next file in the list.
1187 Then try to read a byte from the newly opened file. Repeat if
1188 necessary until EOF is reached for the last file in FILE_LIST, then
1189 set *C to EOF and return. Subsequent calls do likewise. Return
1190 true if successful. */
1199 while (in_stream != NULL) /* EOF. */
1201 *c = fgetc (in_stream);
1206 ok &= check_and_close (errno);
1208 ok &= open_next_file ();
1214 /* Read N bytes into BLOCK from the concatenation of the input files
1215 named in the global array FILE_LIST. On the first call to this
1216 function, the global variable IN_STREAM is expected to be an open
1217 stream associated with the input file INPUT_FILENAME. If all N
1218 bytes cannot be read from IN_STREAM, close IN_STREAM and update
1219 the global variables IN_STREAM and INPUT_FILENAME. Then try to
1220 read the remaining bytes from the newly opened file. Repeat if
1221 necessary until EOF is reached for the last file in FILE_LIST.
1222 On subsequent calls, don't modify BLOCK and return true. Set
1223 *N_BYTES_IN_BUFFER to the number of bytes read. If an error occurs,
1224 it will be detected through ferror when the stream is about to be
1225 closed. If there is an error, give a message but continue reading
1226 as usual and return false. Otherwise return true. */
1229 read_block (size_t n, char *block, size_t *n_bytes_in_buffer)
1233 assert (0 < n && n <= bytes_per_block);
1235 *n_bytes_in_buffer = 0;
1240 while (in_stream != NULL) /* EOF. */
1245 n_needed = n - *n_bytes_in_buffer;
1246 n_read = fread (block + *n_bytes_in_buffer, 1, n_needed, in_stream);
1248 *n_bytes_in_buffer += n_read;
1250 if (n_read == n_needed)
1253 ok &= check_and_close (errno);
1255 ok &= open_next_file ();
1261 /* Return the least common multiple of the sizes associated
1262 with the format specs. */
1270 for (i = 0; i < n_specs; i++)
1271 l_c_m = lcm (l_c_m, width_bytes[spec[i].size]);
1275 /* If S is a valid traditional offset specification with an optional
1276 leading '+' return true and set *OFFSET to the offset it denotes. */
1279 parse_old_offset (const char *s, uintmax_t *offset)
1286 /* Skip over any leading '+'. */
1290 /* Determine the radix we'll use to interpret S. If there is a `.',
1291 it's decimal, otherwise, if the string begins with `0X'or `0x',
1292 it's hexadecimal, else octal. */
1293 if (strchr (s, '.') != NULL)
1297 if (s[0] == '0' && (s[1] == 'x' || s[1] == 'X'))
1303 return xstrtoumax (s, NULL, radix, offset, "Bb") == LONGINT_OK;
1306 /* Read a chunk of size BYTES_PER_BLOCK from the input files, write the
1307 formatted block to standard output, and repeat until the specified
1308 maximum number of bytes has been read or until all input has been
1309 processed. If the last block read is smaller than BYTES_PER_BLOCK
1310 and its size is not a multiple of the size associated with a format
1311 spec, extend the input block with zero bytes until its length is a
1312 multiple of all format spec sizes. Write the final block. Finally,
1313 write on a line by itself the offset of the byte after the last byte
1314 read. Accumulate return values from calls to read_block and
1315 check_and_close, and if any was false, return false.
1316 Otherwise, return true. */
1322 uintmax_t current_offset;
1325 size_t n_bytes_read;
1327 block[0] = xnmalloc (2, bytes_per_block);
1328 block[1] = block[0] + bytes_per_block;
1330 current_offset = n_bytes_to_skip;
1332 if (limit_bytes_to_format)
1337 if (current_offset >= end_offset)
1342 n_needed = MIN (end_offset - current_offset,
1343 (uintmax_t) bytes_per_block);
1344 ok &= read_block (n_needed, block[idx], &n_bytes_read);
1345 if (n_bytes_read < bytes_per_block)
1347 assert (n_bytes_read == bytes_per_block);
1348 write_block (current_offset, n_bytes_read,
1349 block[!idx], block[idx]);
1350 current_offset += n_bytes_read;
1358 ok &= read_block (bytes_per_block, block[idx], &n_bytes_read);
1359 if (n_bytes_read < bytes_per_block)
1361 assert (n_bytes_read == bytes_per_block);
1362 write_block (current_offset, n_bytes_read,
1363 block[!idx], block[idx]);
1364 current_offset += n_bytes_read;
1369 if (n_bytes_read > 0)
1372 size_t bytes_to_write;
1376 /* Ensure zero-byte padding up to the smallest multiple of l_c_m that
1377 is at least as large as n_bytes_read. */
1378 bytes_to_write = l_c_m * ((n_bytes_read + l_c_m - 1) / l_c_m);
1380 memset (block[idx] + n_bytes_read, 0, bytes_to_write - n_bytes_read);
1381 write_block (current_offset, n_bytes_read, block[!idx], block[idx]);
1382 current_offset += n_bytes_read;
1385 format_address (current_offset, '\n');
1387 if (limit_bytes_to_format && current_offset >= end_offset)
1388 ok &= check_and_close (0);
1395 /* STRINGS mode. Find each "string constant" in the input.
1396 A string constant is a run of at least `string_min' ASCII
1397 graphic (or formatting) characters terminated by a null.
1398 Based on a function written by Richard Stallman for a
1399 traditional version of od. Return true if successful. */
1404 size_t bufsize = MAX (100, string_min);
1405 char *buf = xmalloc (bufsize);
1406 uintmax_t address = n_bytes_to_skip;
1414 /* See if the next `string_min' chars are all printing chars. */
1417 if (limit_bytes_to_format
1418 && (end_offset < string_min || end_offset - string_min <= address))
1421 for (i = 0; i < string_min; i++)
1423 ok &= read_char (&c);
1431 /* Found a non-printing. Try again starting with next char. */
1436 /* We found a run of `string_min' printable characters.
1437 Now see if it is terminated with a null byte. */
1438 while (!limit_bytes_to_format || address < end_offset)
1442 buf = X2REALLOC (buf, &bufsize);
1444 ok &= read_char (&c);
1452 break; /* It is; print this string. */
1454 goto tryline; /* It isn't; give up on this string. */
1455 buf[i++] = c; /* String continues; store it all. */
1458 /* If we get here, the string is all printable and null-terminated,
1459 so print it. It is all in `buf' and `i' is its length. */
1461 format_address (address - i - 1, ' ');
1463 for (i = 0; (c = buf[i]); i++)
1468 fputs ("\\a", stdout);
1472 fputs ("\\b", stdout);
1476 fputs ("\\f", stdout);
1480 fputs ("\\n", stdout);
1484 fputs ("\\r", stdout);
1488 fputs ("\\t", stdout);
1492 fputs ("\\v", stdout);
1502 /* We reach this point only if we search through
1503 (max_bytes_to_format - string_min) bytes before reaching EOF. */
1507 ok &= check_and_close (0);
1512 main (int argc, char **argv)
1517 size_t desired_width IF_LINT (= 0);
1518 bool modern = false;
1519 bool width_specified = false;
1521 size_t width_per_block = 0;
1522 static char const multipliers[] = "bEGKkMmPTYZ0";
1524 /* The old-style `pseudo starting address' to be printed in parentheses
1525 after any true address. */
1526 uintmax_t pseudo_start IF_LINT (= 0);
1528 initialize_main (&argc, &argv);
1529 set_program_name (argv[0]);
1530 setlocale (LC_ALL, "");
1531 bindtextdomain (PACKAGE, LOCALEDIR);
1532 textdomain (PACKAGE);
1534 atexit (close_stdout);
1536 for (i = 0; i <= MAX_INTEGRAL_TYPE_SIZE; i++)
1537 integral_type_size[i] = NO_SIZE;
1539 integral_type_size[sizeof (char)] = CHAR;
1540 integral_type_size[sizeof (short int)] = SHORT;
1541 integral_type_size[sizeof (int)] = INT;
1542 integral_type_size[sizeof (long int)] = LONG;
1543 #if HAVE_UNSIGNED_LONG_LONG_INT
1544 /* If `long int' and `long long int' have the same size, it's fine
1545 to overwrite the entry for `long' with this one. */
1546 integral_type_size[sizeof (unsigned_long_long_int)] = LONG_LONG;
1549 for (i = 0; i <= MAX_FP_TYPE_SIZE; i++)
1550 fp_type_size[i] = NO_SIZE;
1552 fp_type_size[sizeof (float)] = FLOAT_SINGLE;
1553 /* The array entry for `double' is filled in after that for `long double'
1554 so that if they are the same size, we avoid any overhead of
1555 long double computation in libc. */
1556 fp_type_size[sizeof (long double)] = FLOAT_LONG_DOUBLE;
1557 fp_type_size[sizeof (double)] = FLOAT_DOUBLE;
1560 n_specs_allocated = 0;
1563 format_address = format_address_std;
1565 address_pad_len = 7;
1566 flag_dump_strings = false;
1571 enum strtol_error s_err;
1573 int c = getopt_long (argc, argv, short_options, long_options, &oi);
1584 format_address = format_address_std;
1586 address_pad_len = 7;
1589 format_address = format_address_std;
1591 address_pad_len = 7;
1594 format_address = format_address_std;
1596 address_pad_len = 6;
1599 format_address = format_address_none;
1600 address_pad_len = 0;
1603 error (EXIT_FAILURE, 0,
1604 _("invalid output address radix `%c'; \
1605 it must be one character from [doxn]"),
1613 s_err = xstrtoumax (optarg, NULL, 0, &n_bytes_to_skip, multipliers);
1614 if (s_err != LONGINT_OK)
1615 xstrtol_fatal (s_err, oi, c, long_options, optarg);
1620 limit_bytes_to_format = true;
1622 s_err = xstrtoumax (optarg, NULL, 0, &max_bytes_to_format,
1624 if (s_err != LONGINT_OK)
1625 xstrtol_fatal (s_err, oi, c, long_options, optarg);
1634 s_err = xstrtoumax (optarg, NULL, 0, &tmp, multipliers);
1635 if (s_err != LONGINT_OK)
1636 xstrtol_fatal (s_err, oi, c, long_options, optarg);
1638 /* The minimum string length may be no larger than SIZE_MAX,
1639 since we may allocate a buffer of this size. */
1641 error (EXIT_FAILURE, 0, _("%s is too large"), optarg);
1645 flag_dump_strings = true;
1650 ok &= decode_format_string (optarg);
1655 abbreviate_duplicate_blocks = false;
1658 case TRADITIONAL_OPTION:
1662 /* The next several cases map the traditional format
1663 specification options to the corresponding modern format
1664 specs. GNU od accepts any combination of old- and
1665 new-style options. Format specification options accumulate.
1666 The obsolescent and undocumented formats are compatible
1667 with FreeBSD 4.10 od. */
1669 #define CASE_OLD_ARG(old_char,new_string) \
1671 ok &= decode_format_string (new_string); \
1674 CASE_OLD_ARG ('a', "a");
1675 CASE_OLD_ARG ('b', "o1");
1676 CASE_OLD_ARG ('c', "c");
1677 CASE_OLD_ARG ('D', "u4"); /* obsolescent and undocumented */
1678 CASE_OLD_ARG ('d', "u2");
1679 case 'F': /* obsolescent and undocumented alias */
1680 CASE_OLD_ARG ('e', "fD"); /* obsolescent and undocumented */
1681 CASE_OLD_ARG ('f', "fF");
1682 case 'X': /* obsolescent and undocumented alias */
1683 CASE_OLD_ARG ('H', "x4"); /* obsolescent and undocumented */
1684 CASE_OLD_ARG ('i', "dI");
1685 case 'I': case 'L': /* obsolescent and undocumented aliases */
1686 CASE_OLD_ARG ('l', "dL");
1687 CASE_OLD_ARG ('O', "o4"); /* obsolesent and undocumented */
1688 case 'B': /* obsolescent and undocumented alias */
1689 CASE_OLD_ARG ('o', "o2");
1690 CASE_OLD_ARG ('s', "d2");
1691 case 'h': /* obsolescent and undocumented alias */
1692 CASE_OLD_ARG ('x', "x2");
1698 width_specified = true;
1706 s_err = xstrtoumax (optarg, NULL, 10, &w_tmp, "");
1707 if (s_err != LONGINT_OK)
1708 xstrtol_fatal (s_err, oi, c, long_options, optarg);
1709 if (SIZE_MAX < w_tmp)
1710 error (EXIT_FAILURE, 0, _("%s is too large"), optarg);
1711 desired_width = w_tmp;
1715 case_GETOPT_HELP_CHAR;
1717 case_GETOPT_VERSION_CHAR (PROGRAM_NAME, AUTHORS);
1720 usage (EXIT_FAILURE);
1726 exit (EXIT_FAILURE);
1728 if (flag_dump_strings && n_specs > 0)
1729 error (EXIT_FAILURE, 0,
1730 _("no type may be specified when dumping strings"));
1732 n_files = argc - optind;
1734 /* If the --traditional option is used, there may be from
1735 0 to 3 remaining command line arguments; handle each case
1737 od [file] [[+]offset[.][b] [[+]label[.][b]]]
1738 The offset and label have the same syntax.
1740 If --traditional is not given, and if no modern options are
1741 given, and if the offset begins with + or (if there are two
1742 operands) a digit, accept only this form, as per POSIX:
1743 od [file] [[+]offset[.][b]]
1746 if (!modern | traditional)
1754 if ((traditional || argv[optind][0] == '+')
1755 && parse_old_offset (argv[optind], &o1))
1757 n_bytes_to_skip = o1;
1764 if ((traditional || argv[optind + 1][0] == '+'
1765 || ISDIGIT (argv[optind + 1][0]))
1766 && parse_old_offset (argv[optind + 1], &o2))
1768 if (traditional && parse_old_offset (argv[optind], &o1))
1770 n_bytes_to_skip = o1;
1771 flag_pseudo_start = true;
1778 n_bytes_to_skip = o2;
1780 argv[optind + 1] = argv[optind];
1788 && parse_old_offset (argv[optind + 1], &o1)
1789 && parse_old_offset (argv[optind + 2], &o2))
1791 n_bytes_to_skip = o1;
1792 flag_pseudo_start = true;
1794 argv[optind + 2] = argv[optind];
1801 if (traditional && 1 < n_files)
1803 error (0, 0, _("extra operand %s"), quote (argv[optind + 1]));
1804 error (0, 0, "%s\n",
1805 _("compatibility mode supports at most one file"));
1806 usage (EXIT_FAILURE);
1810 if (flag_pseudo_start)
1812 if (format_address == format_address_none)
1815 address_pad_len = 7;
1816 format_address = format_address_paren;
1819 format_address = format_address_label;
1822 if (limit_bytes_to_format)
1824 end_offset = n_bytes_to_skip + max_bytes_to_format;
1825 if (end_offset < n_bytes_to_skip)
1826 error (EXIT_FAILURE, 0, _("skip-bytes + read-bytes is too large"));
1830 decode_format_string ("oS");
1834 /* Set the global pointer FILE_LIST so that it
1835 references the first file-argument on the command-line. */
1837 file_list = (char const *const *) &argv[optind];
1841 /* No files were listed on the command line.
1842 Set the global pointer FILE_LIST so that it
1843 references the null-terminated list of one name: "-". */
1845 file_list = default_file_list;
1848 /* open the first input file */
1849 ok = open_next_file ();
1850 if (in_stream == NULL)
1853 /* skip over any unwanted header bytes */
1854 ok &= skip (n_bytes_to_skip);
1855 if (in_stream == NULL)
1858 pseudo_offset = (flag_pseudo_start ? pseudo_start - n_bytes_to_skip : 0);
1860 /* Compute output block length. */
1863 if (width_specified)
1865 if (desired_width != 0 && desired_width % l_c_m == 0)
1866 bytes_per_block = desired_width;
1869 error (0, 0, _("warning: invalid width %lu; using %d instead"),
1870 (unsigned long int) desired_width, l_c_m);
1871 bytes_per_block = l_c_m;
1876 if (l_c_m < DEFAULT_BYTES_PER_BLOCK)
1877 bytes_per_block = l_c_m * (DEFAULT_BYTES_PER_BLOCK / l_c_m);
1879 bytes_per_block = l_c_m;
1882 /* Compute padding necessary to align output block. */
1883 for (i = 0; i < n_specs; i++)
1885 int fields_per_block = bytes_per_block / width_bytes[spec[i].size];
1886 int block_width = (spec[i].field_width + 1) * fields_per_block;
1887 if (width_per_block < block_width)
1888 width_per_block = block_width;
1890 for (i = 0; i < n_specs; i++)
1892 int fields_per_block = bytes_per_block / width_bytes[spec[i].size];
1893 int block_width = spec[i].field_width * fields_per_block;
1894 spec[i].pad_width = width_per_block - block_width;
1898 printf ("lcm=%d, width_per_block=%zu\n", l_c_m, width_per_block);
1899 for (i = 0; i < n_specs; i++)
1901 int fields_per_block = bytes_per_block / width_bytes[spec[i].size];
1902 assert (bytes_per_block % width_bytes[spec[i].size] == 0);
1903 assert (1 <= spec[i].pad_width / fields_per_block);
1904 printf ("%d: fmt=\"%s\" in_width=%d out_width=%d pad=%d\n",
1905 i, spec[i].fmt_string, width_bytes[spec[i].size],
1906 spec[i].field_width, spec[i].pad_width);
1910 ok &= (flag_dump_strings ? dump_strings () : dump ());
1914 if (have_read_stdin && fclose (stdin) == EOF)
1915 error (EXIT_FAILURE, errno, _("standard input"));
1917 exit (ok ? EXIT_SUCCESS : EXIT_FAILURE);