1 /* od -- dump files in octal and other formats
2 Copyright (C) 92, 1995-2008 Free Software Foundation, Inc.
4 This program is free software: you can redistribute it and/or modify
5 it under the terms of the GNU General Public License as published by
6 the Free Software Foundation, either version 3 of the License, or
7 (at your option) any later version.
9 This program is distributed in the hope that it will be useful,
10 but WITHOUT ANY WARRANTY; without even the implied warranty of
11 MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
12 GNU General Public License for more details.
14 You should have received a copy of the GNU General Public License
15 along with this program. If not, see <http://www.gnu.org/licenses/>. */
17 /* Written by Jim Meyering. */
24 #include <sys/types.h>
31 /* The official name of this program (e.g., no `g' prefix). */
32 #define PROGRAM_NAME "od"
34 #define AUTHORS proper_name ("Jim Meyering")
38 /* The default number of input bytes per output line. */
39 #define DEFAULT_BYTES_PER_BLOCK 16
41 /* The number of decimal digits of precision in a float. */
46 /* The number of decimal digits of precision in a double. */
51 #if HAVE_UNSIGNED_LONG_LONG_INT
52 typedef unsigned long long int unsigned_long_long_int;
54 /* This is just a place-holder to avoid a few `#if' directives.
55 In this case, the type isn't actually used. */
56 typedef unsigned long int unsigned_long_long_int;
67 /* FIXME: add INTMAX support, too */
85 /* The maximum number of bytes needed for a format string,
86 including the trailing null. */
90 MAX ((sizeof "%*s%0" - 1 + INT_STRLEN_BOUND (int)
96 sizeof "%*s%.Le" + 2 * INT_STRLEN_BOUND (int))
99 /* Each output format specification (from `-t spec' or from
100 old-style options) is represented by one of these structures. */
103 enum output_format fmt;
105 void (*print_function) (size_t, size_t, void const *, char const *, int);
106 char fmt_string[FMT_BYTES_ALLOCATED];
107 bool hexl_mode_trailer;
112 /* Convert the number of 8-bit bytes of a binary representation to
113 the number of characters (digits + sign if the type is signed)
114 required to represent the same quantity in the specified base/type.
115 For example, a 32-bit (4-byte) quantity may require a field width
116 as wide as the following for these types:
120 8 unsigned hexadecimal */
122 static unsigned int const bytes_to_oct_digits[] =
123 {0, 3, 6, 8, 11, 14, 16, 19, 22, 25, 27, 30, 32, 35, 38, 41, 43};
125 static unsigned int const bytes_to_signed_dec_digits[] =
126 {1, 4, 6, 8, 11, 13, 16, 18, 20, 23, 25, 28, 30, 33, 35, 37, 40};
128 static unsigned int const bytes_to_unsigned_dec_digits[] =
129 {0, 3, 5, 8, 10, 13, 15, 17, 20, 22, 25, 27, 29, 32, 34, 37, 39};
131 static unsigned int const bytes_to_hex_digits[] =
132 {0, 2, 4, 6, 8, 10, 12, 14, 16, 18, 20, 22, 24, 26, 28, 30, 32};
134 #define MAX_INTEGRAL_TYPE_SIZE sizeof (unsigned_long_long_int)
136 /* It'll be a while before we see integral types wider than 16 bytes,
137 but if/when it happens, this check will catch it. Without this check,
138 a wider type would provoke a buffer overrun. */
139 verify (MAX_INTEGRAL_TYPE_SIZE
140 < sizeof bytes_to_hex_digits / sizeof *bytes_to_hex_digits);
142 /* Make sure the other arrays have the same length. */
143 verify (sizeof bytes_to_oct_digits == sizeof bytes_to_signed_dec_digits);
144 verify (sizeof bytes_to_oct_digits == sizeof bytes_to_unsigned_dec_digits);
145 verify (sizeof bytes_to_oct_digits == sizeof bytes_to_hex_digits);
147 /* Convert enum size_spec to the size of the named type. */
148 static const int width_bytes[] =
155 sizeof (unsigned_long_long_int),
161 /* Ensure that for each member of `enum size_spec' there is an
162 initializer in the width_bytes array. */
163 verify (sizeof width_bytes / sizeof width_bytes[0] == N_SIZE_SPECS);
165 /* Names for some non-printing characters. */
166 static const char *const charname[33] =
168 "nul", "soh", "stx", "etx", "eot", "enq", "ack", "bel",
169 "bs", "ht", "nl", "vt", "ff", "cr", "so", "si",
170 "dle", "dc1", "dc2", "dc3", "dc4", "nak", "syn", "etb",
171 "can", "em", "sub", "esc", "fs", "gs", "rs", "us",
175 /* Address base (8, 10 or 16). */
176 static int address_base;
178 /* The number of octal digits required to represent the largest
180 #define MAX_ADDRESS_LENGTH \
181 ((sizeof (uintmax_t) * CHAR_BIT + CHAR_BIT - 1) / 3)
183 /* Width of a normal address. */
184 static int address_pad_len;
186 static size_t string_min;
187 static bool flag_dump_strings;
189 /* True if we should recognize the older non-option arguments
190 that specified at most one file and optional arguments specifying
191 offset and pseudo-start address. */
192 static bool traditional;
194 /* True if an old-style `pseudo-address' was specified. */
195 static bool flag_pseudo_start;
197 /* The difference between the old-style pseudo starting address and
198 the number of bytes to skip. */
199 static uintmax_t pseudo_offset;
201 /* Function that accepts an address and an optional following char,
202 and prints the address and char to stdout. */
203 static void (*format_address) (uintmax_t, char);
205 /* The number of input bytes to skip before formatting and writing. */
206 static uintmax_t n_bytes_to_skip = 0;
208 /* When false, MAX_BYTES_TO_FORMAT and END_OFFSET are ignored, and all
209 input is formatted. */
210 static bool limit_bytes_to_format = false;
212 /* The maximum number of bytes that will be formatted. */
213 static uintmax_t max_bytes_to_format;
215 /* The offset of the first byte after the last byte to be formatted. */
216 static uintmax_t end_offset;
218 /* When true and two or more consecutive blocks are equal, format
219 only the first block and output an asterisk alone on the following
220 line to indicate that identical blocks have been elided. */
221 static bool abbreviate_duplicate_blocks = true;
223 /* An array of specs describing how to format each input block. */
224 static struct tspec *spec;
226 /* The number of format specs. */
227 static size_t n_specs;
229 /* The allocated length of SPEC. */
230 static size_t n_specs_allocated;
232 /* The number of input bytes formatted per output line. It must be
233 a multiple of the least common multiple of the sizes associated with
234 the specified output types. It should be as large as possible, but
235 no larger than 16 -- unless specified with the -w option. */
236 static size_t bytes_per_block;
238 /* Human-readable representation of *file_list (for error messages).
239 It differs from file_list[-1] only when file_list[-1] is "-". */
240 static char const *input_filename;
242 /* A NULL-terminated list of the file-arguments from the command line. */
243 static char const *const *file_list;
245 /* Initializer for file_list if no file-arguments
246 were specified on the command line. */
247 static char const *const default_file_list[] = {"-", NULL};
249 /* The input stream associated with the current file. */
250 static FILE *in_stream;
252 /* If true, at least one of the files we read was standard input. */
253 static bool have_read_stdin;
255 /* Map the size in bytes to a type identifier. */
256 static enum size_spec integral_type_size[MAX_INTEGRAL_TYPE_SIZE + 1];
258 #define MAX_FP_TYPE_SIZE sizeof (long double)
259 static enum size_spec fp_type_size[MAX_FP_TYPE_SIZE + 1];
261 static char const short_options[] = "A:aBbcDdeFfHhIij:LlN:OoS:st:vw::Xx";
263 /* For long options that have no equivalent short option, use a
264 non-character as a pseudo short option, starting with CHAR_MAX + 1. */
267 TRADITIONAL_OPTION = CHAR_MAX + 1
270 static struct option const long_options[] =
272 {"skip-bytes", required_argument, NULL, 'j'},
273 {"address-radix", required_argument, NULL, 'A'},
274 {"read-bytes", required_argument, NULL, 'N'},
275 {"format", required_argument, NULL, 't'},
276 {"output-duplicates", no_argument, NULL, 'v'},
277 {"strings", optional_argument, NULL, 'S'},
278 {"traditional", no_argument, NULL, TRADITIONAL_OPTION},
279 {"width", optional_argument, NULL, 'w'},
281 {GETOPT_HELP_OPTION_DECL},
282 {GETOPT_VERSION_OPTION_DECL},
289 if (status != EXIT_SUCCESS)
290 fprintf (stderr, _("Try `%s --help' for more information.\n"),
295 Usage: %s [OPTION]... [FILE]...\n\
296 or: %s [-abcdfilosx]... [FILE] [[+]OFFSET[.][b]]\n\
297 or: %s --traditional [OPTION]... [FILE] [[+]OFFSET[.][b] [+][LABEL][.][b]]\n\
299 program_name, program_name, program_name);
301 Write an unambiguous representation, octal bytes by default,\n\
302 of FILE to standard output. With more than one FILE argument,\n\
303 concatenate them in the listed order to form the input.\n\
304 With no FILE, or when FILE is -, read standard input.\n\
308 All arguments to long options are mandatory for short options.\n\
311 -A, --address-radix=RADIX decide how file offsets are printed\n\
312 -j, --skip-bytes=BYTES skip BYTES input bytes first\n\
315 -N, --read-bytes=BYTES limit dump to BYTES input bytes\n\
316 -S, --strings[=BYTES] output strings of at least BYTES graphic chars\n\
317 -t, --format=TYPE select output format or formats\n\
318 -v, --output-duplicates do not use * to mark line suppression\n\
319 -w, --width[=BYTES] output BYTES bytes per output line\n\
320 --traditional accept arguments in traditional form\n\
322 fputs (HELP_OPTION_DESCRIPTION, stdout);
323 fputs (VERSION_OPTION_DESCRIPTION, stdout);
326 Traditional format specifications may be intermixed; they accumulate:\n\
327 -a same as -t a, select named characters, ignoring high-order bit\n\
328 -b same as -t o1, select octal bytes\n\
329 -c same as -t c, select ASCII characters or backslash escapes\n\
330 -d same as -t u2, select unsigned decimal 2-byte units\n\
333 -f same as -t fF, select floats\n\
334 -i same as -t dI, select decimal ints\n\
335 -l same as -t dL, select decimal longs\n\
336 -o same as -t o2, select octal 2-byte units\n\
337 -s same as -t d2, select decimal 2-byte units\n\
338 -x same as -t x2, select hexadecimal 2-byte units\n\
342 If first and second call formats both apply, the second format is assumed\n\
343 if the last operand begins with + or (if there are 2 operands) a digit.\n\
344 An OFFSET operand means -j OFFSET. LABEL is the pseudo-address\n\
345 at first byte printed, incremented when dump is progressing.\n\
346 For OFFSET and LABEL, a 0x or 0X prefix indicates hexadecimal;\n\
347 suffixes may be . for octal and b for multiply by 512.\n\
351 TYPE is made up of one or more of these specifications:\n\
353 a named character, ignoring high-order bit\n\
354 c ASCII character or backslash escape\n\
357 d[SIZE] signed decimal, SIZE bytes per integer\n\
358 f[SIZE] floating point, SIZE bytes per integer\n\
359 o[SIZE] octal, SIZE bytes per integer\n\
360 u[SIZE] unsigned decimal, SIZE bytes per integer\n\
361 x[SIZE] hexadecimal, SIZE bytes per integer\n\
365 SIZE is a number. For TYPE in doux, SIZE may also be C for\n\
366 sizeof(char), S for sizeof(short), I for sizeof(int) or L for\n\
367 sizeof(long). If TYPE is f, SIZE may also be F for sizeof(float), D\n\
368 for sizeof(double) or L for sizeof(long double).\n\
372 RADIX is d for decimal, o for octal, x for hexadecimal or n for none.\n\
373 BYTES is hexadecimal with 0x or 0X prefix, and may have a multiplier suffix:\n\
374 b 512, kB 1000, K 1024, MB 1000*1000, M 1024*1024,\n\
375 GB 1000*1000*1000, G 1024*1024*1024, and so on for T, P, E, Z, Y.\n\
376 Adding a z suffix to any type displays printable characters at the end of each\n\
380 --string without a number implies 3. --width without a number\n\
381 implies 32. By default, od uses -A o -t oS -w16.\n\
383 emit_bug_reporting_address ();
388 /* Define the print functions. */
390 #define PRINT_TYPE(N, T) \
392 N (size_t fields, size_t limit, void const *block, \
393 char const *fmt_string, int pad) \
395 T const *p = block; \
397 for (i = fields; limit < i; i--) \
399 int local_pad = (pad + i / 2) / i; \
400 xprintf (fmt_string, local_pad, "", *p++); \
405 PRINT_TYPE (print_s_char, signed char)
406 PRINT_TYPE (print_char, unsigned char)
407 PRINT_TYPE (print_s_short, short int)
408 PRINT_TYPE (print_short, unsigned short int)
409 PRINT_TYPE (print_int, unsigned int)
410 PRINT_TYPE (print_long, unsigned long int)
411 PRINT_TYPE (print_long_long, unsigned_long_long_int)
412 PRINT_TYPE (print_float, float)
413 PRINT_TYPE (print_double, double)
414 PRINT_TYPE (print_long_double, long double)
419 dump_hexl_mode_trailer (size_t n_bytes, const char *block)
422 fputs (" >", stdout);
423 for (i = n_bytes; i > 0; i--)
425 unsigned char c = *block++;
426 unsigned char c2 = (isprint (c) ? c : '.');
433 print_named_ascii (size_t fields, size_t limit, void const *block,
434 const char *unused_fmt_string ATTRIBUTE_UNUSED, int pad)
436 unsigned char const *p = block;
438 for (i = fields; limit < i; i--)
440 int local_pad = (pad + i / 2) / i;
441 int masked_c = *p++ & 0x7f;
447 else if (masked_c <= 040)
448 s = charname[masked_c];
451 sprintf (buf, " %c", masked_c);
455 xprintf ("%*s%3s", local_pad, "", s);
461 print_ascii (size_t fields, size_t limit, void const *block,
462 const char *unused_fmt_string ATTRIBUTE_UNUSED, int pad)
464 unsigned char const *p = block;
466 for (i = fields; limit < i; i--)
468 int local_pad = (pad + i / 2) / i;
469 unsigned char c = *p++;
508 sprintf (buf, (isprint (c) ? " %c" : "%03o"), c);
512 xprintf ("%*s%3s", local_pad, "", s);
517 /* Convert a null-terminated (possibly zero-length) string S to an
518 unsigned long integer value. If S points to a non-digit set *P to S,
519 *VAL to 0, and return true. Otherwise, accumulate the integer value of
520 the string of digits. If the string of digits represents a value
521 larger than ULONG_MAX, don't modify *VAL or *P and return false.
522 Otherwise, advance *P to the first non-digit after S, set *VAL to
523 the result of the conversion and return true. */
526 simple_strtoul (const char *s, const char **p, unsigned long int *val)
528 unsigned long int sum;
534 if (sum > (ULONG_MAX - c) / 10)
543 /* If S points to a single valid modern od format string, put
544 a description of that format in *TSPEC, make *NEXT point at the
545 character following the just-decoded format (if *NEXT is non-NULL),
546 and return true. If S is not valid, don't modify *NEXT or *TSPEC,
547 give a diagnostic, and return false. For example, if S were
548 "d4afL" *NEXT would be set to "afL" and *TSPEC would be
550 fmt = SIGNED_DECIMAL;
551 size = INT or LONG; (whichever integral_type_size[4] resolves to)
552 print_function = print_int; (assuming size == INT)
553 fmt_string = "%*s%011d";
555 pad_width is determined later, but is at least 1
556 S_ORIG is solely for reporting errors. It should be the full format
561 decode_one_format (const char *s_orig, const char *s, const char **next,
564 enum size_spec size_spec;
565 unsigned long int size;
566 enum output_format fmt;
567 const char *pre_fmt_string;
568 void (*print_function) (size_t, size_t, void const *, char const *, int);
574 assert (tspec != NULL);
588 size = sizeof (char);
593 size = sizeof (short int);
603 size = sizeof (long int);
607 if (! simple_strtoul (s, &p, &size))
609 /* The integer at P in S would overflow an unsigned long int.
610 A digit string that long is sufficiently odd looking
611 that the following diagnostic is sufficient. */
612 error (0, 0, _("invalid type string %s"), quote (s_orig));
619 if (MAX_INTEGRAL_TYPE_SIZE < size
620 || integral_type_size[size] == NO_SIZE)
622 error (0, 0, _("invalid type string %s;\n\
623 this system doesn't provide a %lu-byte integral type"), quote (s_orig), size);
631 #define ISPEC_TO_FORMAT(Spec, Min_format, Long_format, Max_format) \
632 ((Spec) == LONG_LONG ? (Max_format) \
633 : ((Spec) == LONG ? (Long_format) \
636 size_spec = integral_type_size[size];
641 fmt = SIGNED_DECIMAL;
642 sprintf (tspec->fmt_string, "%%*s%%%d%s",
643 (field_width = bytes_to_signed_dec_digits[size]),
644 ISPEC_TO_FORMAT (size_spec, "d", "ld", PRIdMAX));
649 sprintf (tspec->fmt_string, "%%*s%%0%d%s",
650 (field_width = bytes_to_oct_digits[size]),
651 ISPEC_TO_FORMAT (size_spec, "o", "lo", PRIoMAX));
655 fmt = UNSIGNED_DECIMAL;
656 sprintf (tspec->fmt_string, "%%*s%%%d%s",
657 (field_width = bytes_to_unsigned_dec_digits[size]),
658 ISPEC_TO_FORMAT (size_spec, "u", "lu", PRIuMAX));
663 sprintf (tspec->fmt_string, "%%*s%%0%d%s",
664 (field_width = bytes_to_hex_digits[size]),
665 ISPEC_TO_FORMAT (size_spec, "x", "lx", PRIxMAX));
672 assert (strlen (tspec->fmt_string) < FMT_BYTES_ALLOCATED);
677 print_function = (fmt == SIGNED_DECIMAL
683 print_function = (fmt == SIGNED_DECIMAL
689 print_function = print_int;
693 print_function = print_long;
697 print_function = print_long_long;
706 fmt = FLOATING_POINT;
712 size = sizeof (float);
717 size = sizeof (double);
722 size = sizeof (long double);
726 if (! simple_strtoul (s, &p, &size))
728 /* The integer at P in S would overflow an unsigned long int.
729 A digit string that long is sufficiently odd looking
730 that the following diagnostic is sufficient. */
731 error (0, 0, _("invalid type string %s"), quote (s_orig));
735 size = sizeof (double);
738 if (size > MAX_FP_TYPE_SIZE
739 || fp_type_size[size] == NO_SIZE)
741 error (0, 0, _("invalid type string %s;\n\
742 this system doesn't provide a %lu-byte floating point type"),
743 quote (s_orig), size);
750 size_spec = fp_type_size[size];
755 print_function = print_float;
756 /* Don't use %#e; not all systems support it. */
757 pre_fmt_string = "%%*s%%%d.%de";
762 print_function = print_double;
763 pre_fmt_string = "%%*s%%%d.%de";
767 case FLOAT_LONG_DOUBLE:
768 print_function = print_long_double;
769 pre_fmt_string = "%%*s%%%d.%dLe";
770 precision = LDBL_DIG;
777 field_width = precision + 8;
778 sprintf (tspec->fmt_string, pre_fmt_string, field_width, precision);
783 fmt = NAMED_CHARACTER;
785 print_function = print_named_ascii;
793 print_function = print_ascii;
798 error (0, 0, _("invalid character `%c' in type string %s"),
803 tspec->size = size_spec;
805 tspec->print_function = print_function;
807 tspec->field_width = field_width;
808 tspec->hexl_mode_trailer = (*s == 'z');
809 if (tspec->hexl_mode_trailer)
818 /* Given a list of one or more input filenames FILE_LIST, set the global
819 file pointer IN_STREAM and the global string INPUT_FILENAME to the
820 first one that can be successfully opened. Modify FILE_LIST to
821 reference the next filename in the list. A file name of "-" is
822 interpreted as standard input. If any file open fails, give an error
823 message and return false. */
826 open_next_file (void)
832 input_filename = *file_list;
833 if (input_filename == NULL)
837 if (STREQ (input_filename, "-"))
839 input_filename = _("standard input");
841 have_read_stdin = true;
842 if (O_BINARY && ! isatty (STDIN_FILENO))
843 freopen (NULL, "rb", stdin);
847 in_stream = fopen (input_filename, (O_BINARY ? "rb" : "r"));
848 if (in_stream == NULL)
850 error (0, errno, "%s", input_filename);
855 while (in_stream == NULL);
857 if (limit_bytes_to_format & !flag_dump_strings)
858 setvbuf (in_stream, NULL, _IONBF, 0);
863 /* Test whether there have been errors on in_stream, and close it if
864 it is not standard input. Return false if there has been an error
865 on in_stream or stdout; return true otherwise. This function will
866 report more than one error only if both a read and a write error
867 have occurred. IN_ERRNO, if nonzero, is the error number
868 corresponding to the most recent action for IN_STREAM. */
871 check_and_close (int in_errno)
875 if (in_stream != NULL)
877 if (ferror (in_stream))
879 error (0, in_errno, _("%s: read error"), input_filename);
880 if (! STREQ (file_list[-1], "-"))
884 else if (! STREQ (file_list[-1], "-") && fclose (in_stream) != 0)
886 error (0, errno, "%s", input_filename);
895 error (0, 0, _("write error"));
902 /* Decode the modern od format string S. Append the decoded
903 representation to the global array SPEC, reallocating SPEC if
904 necessary. Return true if S is valid. */
907 decode_format_string (const char *s)
909 const char *s_orig = s;
916 if (n_specs_allocated <= n_specs)
917 spec = X2NREALLOC (spec, &n_specs_allocated);
919 if (! decode_one_format (s_orig, s, &next, &spec[n_specs]))
930 /* Given a list of one or more input filenames FILE_LIST, set the global
931 file pointer IN_STREAM to position N_SKIP in the concatenation of
932 those files. If any file operation fails or if there are fewer than
933 N_SKIP bytes in the combined input, give an error message and return
934 false. When possible, use seek rather than read operations to
935 advance IN_STREAM. */
938 skip (uintmax_t n_skip)
946 while (in_stream != NULL) /* EOF. */
948 struct stat file_stats;
950 /* First try seeking. For large offsets, this extra work is
951 worthwhile. If the offset is below some threshold it may be
952 more efficient to move the pointer by reading. There are two
953 issues when trying to seek:
954 - the file must be seekable.
955 - before seeking to the specified position, make sure
956 that the new position is in the current file.
957 Try to do that by getting file's size using fstat.
958 But that will work only for regular files. */
960 if (fstat (fileno (in_stream), &file_stats) == 0)
962 /* The st_size field is valid only for regular files
963 (and for symbolic links, which cannot occur here).
964 If the number of bytes left to skip is larger than
965 the size of the current file, we can decrement n_skip
966 and go on to the next file. Skip this optimization also
967 when st_size is 0, because some kernels report that
968 nonempty files in /proc have st_size == 0. */
969 if (S_ISREG (file_stats.st_mode) && 0 < file_stats.st_size)
971 if ((uintmax_t) file_stats.st_size < n_skip)
972 n_skip -= file_stats.st_size;
975 if (fseeko (in_stream, n_skip, SEEK_CUR) != 0)
984 /* If it's not a regular file with nonnegative size,
985 position the file pointer by reading. */
990 size_t n_bytes_read, n_bytes_to_read = BUFSIZ;
994 if (n_skip < n_bytes_to_read)
995 n_bytes_to_read = n_skip;
996 n_bytes_read = fread (buf, 1, n_bytes_to_read, in_stream);
997 n_skip -= n_bytes_read;
998 if (n_bytes_read != n_bytes_to_read)
1012 else /* cannot fstat() file */
1014 error (0, errno, "%s", input_filename);
1018 ok &= check_and_close (in_errno);
1020 ok &= open_next_file ();
1024 error (EXIT_FAILURE, 0, _("cannot skip past end of combined input"));
1030 format_address_none (uintmax_t address ATTRIBUTE_UNUSED, char c ATTRIBUTE_UNUSED)
1035 format_address_std (uintmax_t address, char c)
1037 char buf[MAX_ADDRESS_LENGTH + 2];
1038 char *p = buf + sizeof buf;
1043 pbound = p - address_pad_len;
1045 /* Use a special case of the code for each base. This is measurably
1046 faster than generic code. */
1047 switch (address_base)
1051 *--p = '0' + (address & 7);
1052 while ((address >>= 3) != 0);
1057 *--p = '0' + (address % 10);
1058 while ((address /= 10) != 0);
1063 *--p = "0123456789abcdef"[address & 15];
1064 while ((address >>= 4) != 0);
1075 format_address_paren (uintmax_t address, char c)
1078 format_address_std (address, ')');
1084 format_address_label (uintmax_t address, char c)
1086 format_address_std (address, ' ');
1087 format_address_paren (address + pseudo_offset, c);
1090 /* Write N_BYTES bytes from CURR_BLOCK to standard output once for each
1091 of the N_SPEC format specs. CURRENT_OFFSET is the byte address of
1092 CURR_BLOCK in the concatenation of input files, and it is printed
1093 (optionally) only before the output line associated with the first
1094 format spec. When duplicate blocks are being abbreviated, the output
1095 for a sequence of identical input blocks is the output for the first
1096 block followed by an asterisk alone on a line. It is valid to compare
1097 the blocks PREV_BLOCK and CURR_BLOCK only when N_BYTES == BYTES_PER_BLOCK.
1098 That condition may be false only for the last input block -- and then
1099 only when it has not been padded to length BYTES_PER_BLOCK. */
1102 write_block (uintmax_t current_offset, size_t n_bytes,
1103 const char *prev_block, const char *curr_block)
1105 static bool first = true;
1106 static bool prev_pair_equal = false;
1108 #define EQUAL_BLOCKS(b1, b2) (memcmp (b1, b2, bytes_per_block) == 0)
1110 if (abbreviate_duplicate_blocks
1111 && !first && n_bytes == bytes_per_block
1112 && EQUAL_BLOCKS (prev_block, curr_block))
1114 if (prev_pair_equal)
1116 /* The two preceding blocks were equal, and the current
1117 block is the same as the last one, so print nothing. */
1122 prev_pair_equal = true;
1129 prev_pair_equal = false;
1130 for (i = 0; i < n_specs; i++)
1132 int datum_width = width_bytes[spec[i].size];
1133 int fields_per_block = bytes_per_block / datum_width;
1134 int blank_fields = (bytes_per_block - n_bytes) / datum_width;
1136 format_address (current_offset, '\0');
1138 printf ("%*s", address_pad_len, "");
1139 (*spec[i].print_function) (fields_per_block, blank_fields,
1140 curr_block, spec[i].fmt_string,
1142 if (spec[i].hexl_mode_trailer)
1144 /* space-pad out to full line width, then dump the trailer */
1145 int field_width = spec[i].field_width;
1146 int pad_width = (spec[i].pad_width * blank_fields
1147 / fields_per_block);
1148 printf ("%*s", blank_fields * field_width + pad_width, "");
1149 dump_hexl_mode_trailer (n_bytes, curr_block);
1157 /* Read a single byte into *C from the concatenation of the input files
1158 named in the global array FILE_LIST. On the first call to this
1159 function, the global variable IN_STREAM is expected to be an open
1160 stream associated with the input file INPUT_FILENAME. If IN_STREAM
1161 is at end-of-file, close it and update the global variables IN_STREAM
1162 and INPUT_FILENAME so they correspond to the next file in the list.
1163 Then try to read a byte from the newly opened file. Repeat if
1164 necessary until EOF is reached for the last file in FILE_LIST, then
1165 set *C to EOF and return. Subsequent calls do likewise. Return
1166 true if successful. */
1175 while (in_stream != NULL) /* EOF. */
1177 *c = fgetc (in_stream);
1182 ok &= check_and_close (errno);
1184 ok &= open_next_file ();
1190 /* Read N bytes into BLOCK from the concatenation of the input files
1191 named in the global array FILE_LIST. On the first call to this
1192 function, the global variable IN_STREAM is expected to be an open
1193 stream associated with the input file INPUT_FILENAME. If all N
1194 bytes cannot be read from IN_STREAM, close IN_STREAM and update
1195 the global variables IN_STREAM and INPUT_FILENAME. Then try to
1196 read the remaining bytes from the newly opened file. Repeat if
1197 necessary until EOF is reached for the last file in FILE_LIST.
1198 On subsequent calls, don't modify BLOCK and return true. Set
1199 *N_BYTES_IN_BUFFER to the number of bytes read. If an error occurs,
1200 it will be detected through ferror when the stream is about to be
1201 closed. If there is an error, give a message but continue reading
1202 as usual and return false. Otherwise return true. */
1205 read_block (size_t n, char *block, size_t *n_bytes_in_buffer)
1209 assert (0 < n && n <= bytes_per_block);
1211 *n_bytes_in_buffer = 0;
1216 while (in_stream != NULL) /* EOF. */
1221 n_needed = n - *n_bytes_in_buffer;
1222 n_read = fread (block + *n_bytes_in_buffer, 1, n_needed, in_stream);
1224 *n_bytes_in_buffer += n_read;
1226 if (n_read == n_needed)
1229 ok &= check_and_close (errno);
1231 ok &= open_next_file ();
1237 /* Return the least common multiple of the sizes associated
1238 with the format specs. */
1246 for (i = 0; i < n_specs; i++)
1247 l_c_m = lcm (l_c_m, width_bytes[spec[i].size]);
1251 /* If S is a valid traditional offset specification with an optional
1252 leading '+' return true and set *OFFSET to the offset it denotes. */
1255 parse_old_offset (const char *s, uintmax_t *offset)
1262 /* Skip over any leading '+'. */
1266 /* Determine the radix we'll use to interpret S. If there is a `.',
1267 it's decimal, otherwise, if the string begins with `0X'or `0x',
1268 it's hexadecimal, else octal. */
1269 if (strchr (s, '.') != NULL)
1273 if (s[0] == '0' && (s[1] == 'x' || s[1] == 'X'))
1279 return xstrtoumax (s, NULL, radix, offset, "Bb") == LONGINT_OK;
1282 /* Read a chunk of size BYTES_PER_BLOCK from the input files, write the
1283 formatted block to standard output, and repeat until the specified
1284 maximum number of bytes has been read or until all input has been
1285 processed. If the last block read is smaller than BYTES_PER_BLOCK
1286 and its size is not a multiple of the size associated with a format
1287 spec, extend the input block with zero bytes until its length is a
1288 multiple of all format spec sizes. Write the final block. Finally,
1289 write on a line by itself the offset of the byte after the last byte
1290 read. Accumulate return values from calls to read_block and
1291 check_and_close, and if any was false, return false.
1292 Otherwise, return true. */
1298 uintmax_t current_offset;
1301 size_t n_bytes_read;
1303 block[0] = xnmalloc (2, bytes_per_block);
1304 block[1] = block[0] + bytes_per_block;
1306 current_offset = n_bytes_to_skip;
1308 if (limit_bytes_to_format)
1313 if (current_offset >= end_offset)
1318 n_needed = MIN (end_offset - current_offset,
1319 (uintmax_t) bytes_per_block);
1320 ok &= read_block (n_needed, block[idx], &n_bytes_read);
1321 if (n_bytes_read < bytes_per_block)
1323 assert (n_bytes_read == bytes_per_block);
1324 write_block (current_offset, n_bytes_read,
1325 block[!idx], block[idx]);
1326 current_offset += n_bytes_read;
1334 ok &= read_block (bytes_per_block, block[idx], &n_bytes_read);
1335 if (n_bytes_read < bytes_per_block)
1337 assert (n_bytes_read == bytes_per_block);
1338 write_block (current_offset, n_bytes_read,
1339 block[!idx], block[idx]);
1340 current_offset += n_bytes_read;
1345 if (n_bytes_read > 0)
1348 size_t bytes_to_write;
1352 /* Ensure zero-byte padding up to the smallest multiple of l_c_m that
1353 is at least as large as n_bytes_read. */
1354 bytes_to_write = l_c_m * ((n_bytes_read + l_c_m - 1) / l_c_m);
1356 memset (block[idx] + n_bytes_read, 0, bytes_to_write - n_bytes_read);
1357 write_block (current_offset, n_bytes_read, block[!idx], block[idx]);
1358 current_offset += n_bytes_read;
1361 format_address (current_offset, '\n');
1363 if (limit_bytes_to_format && current_offset >= end_offset)
1364 ok &= check_and_close (0);
1371 /* STRINGS mode. Find each "string constant" in the input.
1372 A string constant is a run of at least `string_min' ASCII
1373 graphic (or formatting) characters terminated by a null.
1374 Based on a function written by Richard Stallman for a
1375 traditional version of od. Return true if successful. */
1380 size_t bufsize = MAX (100, string_min);
1381 char *buf = xmalloc (bufsize);
1382 uintmax_t address = n_bytes_to_skip;
1390 /* See if the next `string_min' chars are all printing chars. */
1393 if (limit_bytes_to_format
1394 && (end_offset < string_min || end_offset - string_min <= address))
1397 for (i = 0; i < string_min; i++)
1399 ok &= read_char (&c);
1407 /* Found a non-printing. Try again starting with next char. */
1412 /* We found a run of `string_min' printable characters.
1413 Now see if it is terminated with a null byte. */
1414 while (!limit_bytes_to_format || address < end_offset)
1418 buf = X2REALLOC (buf, &bufsize);
1420 ok &= read_char (&c);
1428 break; /* It is; print this string. */
1430 goto tryline; /* It isn't; give up on this string. */
1431 buf[i++] = c; /* String continues; store it all. */
1434 /* If we get here, the string is all printable and null-terminated,
1435 so print it. It is all in `buf' and `i' is its length. */
1437 format_address (address - i - 1, ' ');
1439 for (i = 0; (c = buf[i]); i++)
1444 fputs ("\\a", stdout);
1448 fputs ("\\b", stdout);
1452 fputs ("\\f", stdout);
1456 fputs ("\\n", stdout);
1460 fputs ("\\r", stdout);
1464 fputs ("\\t", stdout);
1468 fputs ("\\v", stdout);
1478 /* We reach this point only if we search through
1479 (max_bytes_to_format - string_min) bytes before reaching EOF. */
1483 ok &= check_and_close (0);
1488 main (int argc, char **argv)
1493 size_t desired_width IF_LINT (= 0);
1494 bool modern = false;
1495 bool width_specified = false;
1497 size_t width_per_block = 0;
1498 static char const multipliers[] = "bEGKkMmPTYZ0";
1500 /* The old-style `pseudo starting address' to be printed in parentheses
1501 after any true address. */
1502 uintmax_t pseudo_start IF_LINT (= 0);
1504 initialize_main (&argc, &argv);
1505 set_program_name (argv[0]);
1506 setlocale (LC_ALL, "");
1507 bindtextdomain (PACKAGE, LOCALEDIR);
1508 textdomain (PACKAGE);
1510 atexit (close_stdout);
1512 for (i = 0; i <= MAX_INTEGRAL_TYPE_SIZE; i++)
1513 integral_type_size[i] = NO_SIZE;
1515 integral_type_size[sizeof (char)] = CHAR;
1516 integral_type_size[sizeof (short int)] = SHORT;
1517 integral_type_size[sizeof (int)] = INT;
1518 integral_type_size[sizeof (long int)] = LONG;
1519 #if HAVE_UNSIGNED_LONG_LONG_INT
1520 /* If `long int' and `long long int' have the same size, it's fine
1521 to overwrite the entry for `long' with this one. */
1522 integral_type_size[sizeof (unsigned_long_long_int)] = LONG_LONG;
1525 for (i = 0; i <= MAX_FP_TYPE_SIZE; i++)
1526 fp_type_size[i] = NO_SIZE;
1528 fp_type_size[sizeof (float)] = FLOAT_SINGLE;
1529 /* The array entry for `double' is filled in after that for `long double'
1530 so that if they are the same size, we avoid any overhead of
1531 long double computation in libc. */
1532 fp_type_size[sizeof (long double)] = FLOAT_LONG_DOUBLE;
1533 fp_type_size[sizeof (double)] = FLOAT_DOUBLE;
1536 n_specs_allocated = 0;
1539 format_address = format_address_std;
1541 address_pad_len = 7;
1542 flag_dump_strings = false;
1547 enum strtol_error s_err;
1549 int c = getopt_long (argc, argv, short_options, long_options, &oi);
1560 format_address = format_address_std;
1562 address_pad_len = 7;
1565 format_address = format_address_std;
1567 address_pad_len = 7;
1570 format_address = format_address_std;
1572 address_pad_len = 6;
1575 format_address = format_address_none;
1576 address_pad_len = 0;
1579 error (EXIT_FAILURE, 0,
1580 _("invalid output address radix `%c'; \
1581 it must be one character from [doxn]"),
1589 s_err = xstrtoumax (optarg, NULL, 0, &n_bytes_to_skip, multipliers);
1590 if (s_err != LONGINT_OK)
1591 xstrtol_fatal (s_err, oi, c, long_options, optarg);
1596 limit_bytes_to_format = true;
1598 s_err = xstrtoumax (optarg, NULL, 0, &max_bytes_to_format,
1600 if (s_err != LONGINT_OK)
1601 xstrtol_fatal (s_err, oi, c, long_options, optarg);
1610 s_err = xstrtoumax (optarg, NULL, 0, &tmp, multipliers);
1611 if (s_err != LONGINT_OK)
1612 xstrtol_fatal (s_err, oi, c, long_options, optarg);
1614 /* The minimum string length may be no larger than SIZE_MAX,
1615 since we may allocate a buffer of this size. */
1617 error (EXIT_FAILURE, 0, _("%s is too large"), optarg);
1621 flag_dump_strings = true;
1626 ok &= decode_format_string (optarg);
1631 abbreviate_duplicate_blocks = false;
1634 case TRADITIONAL_OPTION:
1638 /* The next several cases map the traditional format
1639 specification options to the corresponding modern format
1640 specs. GNU od accepts any combination of old- and
1641 new-style options. Format specification options accumulate.
1642 The obsolescent and undocumented formats are compatible
1643 with FreeBSD 4.10 od. */
1645 #define CASE_OLD_ARG(old_char,new_string) \
1647 ok &= decode_format_string (new_string); \
1650 CASE_OLD_ARG ('a', "a");
1651 CASE_OLD_ARG ('b', "o1");
1652 CASE_OLD_ARG ('c', "c");
1653 CASE_OLD_ARG ('D', "u4"); /* obsolescent and undocumented */
1654 CASE_OLD_ARG ('d', "u2");
1655 case 'F': /* obsolescent and undocumented alias */
1656 CASE_OLD_ARG ('e', "fD"); /* obsolescent and undocumented */
1657 CASE_OLD_ARG ('f', "fF");
1658 case 'X': /* obsolescent and undocumented alias */
1659 CASE_OLD_ARG ('H', "x4"); /* obsolescent and undocumented */
1660 CASE_OLD_ARG ('i', "dI");
1661 case 'I': case 'L': /* obsolescent and undocumented aliases */
1662 CASE_OLD_ARG ('l', "dL");
1663 CASE_OLD_ARG ('O', "o4"); /* obsolesent and undocumented */
1664 case 'B': /* obsolescent and undocumented alias */
1665 CASE_OLD_ARG ('o', "o2");
1666 CASE_OLD_ARG ('s', "d2");
1667 case 'h': /* obsolescent and undocumented alias */
1668 CASE_OLD_ARG ('x', "x2");
1674 width_specified = true;
1682 s_err = xstrtoumax (optarg, NULL, 10, &w_tmp, "");
1683 if (s_err != LONGINT_OK)
1684 xstrtol_fatal (s_err, oi, c, long_options, optarg);
1685 if (SIZE_MAX < w_tmp)
1686 error (EXIT_FAILURE, 0, _("%s is too large"), optarg);
1687 desired_width = w_tmp;
1691 case_GETOPT_HELP_CHAR;
1693 case_GETOPT_VERSION_CHAR (PROGRAM_NAME, AUTHORS);
1696 usage (EXIT_FAILURE);
1702 exit (EXIT_FAILURE);
1704 if (flag_dump_strings && n_specs > 0)
1705 error (EXIT_FAILURE, 0,
1706 _("no type may be specified when dumping strings"));
1708 n_files = argc - optind;
1710 /* If the --traditional option is used, there may be from
1711 0 to 3 remaining command line arguments; handle each case
1713 od [file] [[+]offset[.][b] [[+]label[.][b]]]
1714 The offset and label have the same syntax.
1716 If --traditional is not given, and if no modern options are
1717 given, and if the offset begins with + or (if there are two
1718 operands) a digit, accept only this form, as per POSIX:
1719 od [file] [[+]offset[.][b]]
1722 if (!modern | traditional)
1730 if ((traditional || argv[optind][0] == '+')
1731 && parse_old_offset (argv[optind], &o1))
1733 n_bytes_to_skip = o1;
1740 if ((traditional || argv[optind + 1][0] == '+'
1741 || ISDIGIT (argv[optind + 1][0]))
1742 && parse_old_offset (argv[optind + 1], &o2))
1744 if (traditional && parse_old_offset (argv[optind], &o1))
1746 n_bytes_to_skip = o1;
1747 flag_pseudo_start = true;
1754 n_bytes_to_skip = o2;
1756 argv[optind + 1] = argv[optind];
1764 && parse_old_offset (argv[optind + 1], &o1)
1765 && parse_old_offset (argv[optind + 2], &o2))
1767 n_bytes_to_skip = o1;
1768 flag_pseudo_start = true;
1770 argv[optind + 2] = argv[optind];
1777 if (traditional && 1 < n_files)
1779 error (0, 0, _("extra operand %s"), quote (argv[optind + 1]));
1780 error (0, 0, "%s\n",
1781 _("compatibility mode supports at most one file"));
1782 usage (EXIT_FAILURE);
1786 if (flag_pseudo_start)
1788 if (format_address == format_address_none)
1791 address_pad_len = 7;
1792 format_address = format_address_paren;
1795 format_address = format_address_label;
1798 if (limit_bytes_to_format)
1800 end_offset = n_bytes_to_skip + max_bytes_to_format;
1801 if (end_offset < n_bytes_to_skip)
1802 error (EXIT_FAILURE, 0, _("skip-bytes + read-bytes is too large"));
1806 decode_format_string ("oS");
1810 /* Set the global pointer FILE_LIST so that it
1811 references the first file-argument on the command-line. */
1813 file_list = (char const *const *) &argv[optind];
1817 /* No files were listed on the command line.
1818 Set the global pointer FILE_LIST so that it
1819 references the null-terminated list of one name: "-". */
1821 file_list = default_file_list;
1824 /* open the first input file */
1825 ok = open_next_file ();
1826 if (in_stream == NULL)
1829 /* skip over any unwanted header bytes */
1830 ok &= skip (n_bytes_to_skip);
1831 if (in_stream == NULL)
1834 pseudo_offset = (flag_pseudo_start ? pseudo_start - n_bytes_to_skip : 0);
1836 /* Compute output block length. */
1839 if (width_specified)
1841 if (desired_width != 0 && desired_width % l_c_m == 0)
1842 bytes_per_block = desired_width;
1845 error (0, 0, _("warning: invalid width %lu; using %d instead"),
1846 (unsigned long int) desired_width, l_c_m);
1847 bytes_per_block = l_c_m;
1852 if (l_c_m < DEFAULT_BYTES_PER_BLOCK)
1853 bytes_per_block = l_c_m * (DEFAULT_BYTES_PER_BLOCK / l_c_m);
1855 bytes_per_block = l_c_m;
1858 /* Compute padding necessary to align output block. */
1859 for (i = 0; i < n_specs; i++)
1861 int fields_per_block = bytes_per_block / width_bytes[spec[i].size];
1862 int block_width = (spec[i].field_width + 1) * fields_per_block;
1863 if (width_per_block < block_width)
1864 width_per_block = block_width;
1866 for (i = 0; i < n_specs; i++)
1868 int fields_per_block = bytes_per_block / width_bytes[spec[i].size];
1869 int block_width = spec[i].field_width * fields_per_block;
1870 spec[i].pad_width = width_per_block - block_width;
1874 printf (_("lcm=%d, width_per_block=%zu\n"), l_c_m, width_per_block);
1875 for (i = 0; i < n_specs; i++)
1877 int fields_per_block = bytes_per_block / width_bytes[spec[i].size];
1878 assert (bytes_per_block % width_bytes[spec[i].size] == 0);
1879 assert (1 <= spec[i].pad_width / fields_per_block);
1880 printf (_("%d: fmt=\"%s\" in_width=%d out_width=%d pad=%d\n"),
1881 i, spec[i].fmt_string, width_bytes[spec[i].size],
1882 spec[i].field_width, spec[i].pad_width);
1886 ok &= (flag_dump_strings ? dump_strings () : dump ());
1890 if (have_read_stdin && fclose (stdin) == EOF)
1891 error (EXIT_FAILURE, errno, _("standard input"));
1893 exit (ok ? EXIT_SUCCESS : EXIT_FAILURE);