1 /* od -- dump files in octal and other formats
2 Copyright (C) 92, 1995-2002 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 2, or (at your option)
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, write to the Free Software Foundation,
16 Inc., 59 Temple Place - Suite 330, Boston, MA 02111-1307, USA. */
18 /* Written by Jim Meyering. */
25 #include <sys/types.h>
31 /* The official name of this program (e.g., no `g' prefix). */
32 #define PROGRAM_NAME "od"
34 #define AUTHORS "Jim Meyering"
36 #if defined(__GNUC__) || defined(STDC_HEADERS)
40 #ifdef HAVE_LONG_DOUBLE
41 typedef long double LONG_DOUBLE;
43 typedef double LONG_DOUBLE;
50 /* The default number of input bytes per output line. */
51 #define DEFAULT_BYTES_PER_BLOCK 16
53 /* The number of decimal digits of precision in a float. */
58 /* The number of decimal digits of precision in a double. */
63 /* The number of decimal digits of precision in a long double. */
65 # define LDBL_DIG DBL_DIG
76 /* FIXME: add INTMAX support, too */
93 /* Each output format specification (from `-t spec' or from
94 old-style options) is represented by one of these structures. */
97 enum output_format fmt;
99 void (*print_function) PARAMS ((size_t, const char *, const char *));
101 int hexl_mode_trailer;
105 /* The name this program was run with. */
108 /* Convert the number of 8-bit bytes of a binary representation to
109 the number of characters (digits + sign if the type is signed)
110 required to represent the same quantity in the specified base/type.
111 For example, a 32-bit (4-byte) quantity may require a field width
112 as wide as the following for these types:
116 8 unsigned hexadecimal */
118 static const unsigned int bytes_to_oct_digits[] =
119 {0, 3, 6, 8, 11, 14, 16, 19, 22, 25, 27, 30, 32, 35, 38, 41, 43};
121 static const unsigned int bytes_to_signed_dec_digits[] =
122 {1, 4, 6, 8, 11, 13, 16, 18, 20, 23, 25, 28, 30, 33, 35, 37, 40};
124 static const unsigned int bytes_to_unsigned_dec_digits[] =
125 {0, 3, 5, 8, 10, 13, 15, 17, 20, 22, 25, 27, 29, 32, 34, 37, 39};
127 static const unsigned int bytes_to_hex_digits[] =
128 {0, 2, 4, 6, 8, 10, 12, 14, 16, 18, 20, 22, 24, 26, 28, 30, 32};
130 /* Convert enum size_spec to the size of the named type. */
131 static const int width_bytes[] =
143 /* Names for some non-printing characters. */
144 static const char *const charname[33] =
146 "nul", "soh", "stx", "etx", "eot", "enq", "ack", "bel",
147 "bs", "ht", "nl", "vt", "ff", "cr", "so", "si",
148 "dle", "dc1", "dc2", "dc3", "dc4", "nak", "syn", "etb",
149 "can", "em", "sub", "esc", "fs", "gs", "rs", "us",
153 /* Address base (8, 10 or 16). */
154 static int address_base;
156 /* The number of octal digits required to represent the largest
158 #define MAX_ADDRESS_LENGTH \
159 ((sizeof (uintmax_t) * CHAR_BIT + CHAR_BIT - 1) / 3)
161 /* Width of a normal address. */
162 static int address_pad_len;
164 static size_t string_min;
165 static int flag_dump_strings;
167 /* Non-zero if we should recognize the older non-option arguments
168 that specified at most one file and optional arguments specifying
169 offset and pseudo-start address. */
170 static int traditional;
172 /* Non-zero if an old-style `pseudo-address' was specified. */
173 static int flag_pseudo_start;
175 /* The difference between the old-style pseudo starting address and
176 the number of bytes to skip. */
177 static uintmax_t pseudo_offset;
179 /* Function that accepts an address and an optional following char,
180 and prints the address and char to stdout. */
181 static void (*format_address) PARAMS ((uintmax_t, char));
183 /* The number of input bytes to skip before formatting and writing. */
184 static uintmax_t n_bytes_to_skip = 0;
186 /* When zero, MAX_BYTES_TO_FORMAT and END_OFFSET are ignored, and all
187 input is formatted. */
188 static int limit_bytes_to_format = 0;
190 /* The maximum number of bytes that will be formatted. */
191 static uintmax_t max_bytes_to_format;
193 /* The offset of the first byte after the last byte to be formatted. */
194 static uintmax_t end_offset;
196 /* When nonzero and two or more consecutive blocks are equal, format
197 only the first block and output an asterisk alone on the following
198 line to indicate that identical blocks have been elided. */
199 static int abbreviate_duplicate_blocks = 1;
201 /* An array of specs describing how to format each input block. */
202 static struct tspec *spec;
204 /* The number of format specs. */
205 static size_t n_specs;
207 /* The allocated length of SPEC. */
208 static size_t n_specs_allocated;
210 /* The number of input bytes formatted per output line. It must be
211 a multiple of the least common multiple of the sizes associated with
212 the specified output types. It should be as large as possible, but
213 no larger than 16 -- unless specified with the -w option. */
214 static size_t bytes_per_block;
216 /* Human-readable representation of *file_list (for error messages).
217 It differs from *file_list only when *file_list is "-". */
218 static char const *input_filename;
220 /* A NULL-terminated list of the file-arguments from the command line. */
221 static char const *const *file_list;
223 /* Initializer for file_list if no file-arguments
224 were specified on the command line. */
225 static char const *const default_file_list[] = {"-", NULL};
227 /* The input stream associated with the current file. */
228 static FILE *in_stream;
230 /* If nonzero, at least one of the files we read was standard input. */
231 static int have_read_stdin;
233 #if HAVE_UNSIGNED_LONG_LONG
234 typedef unsigned long long ulonglong_t;
236 /* This is just a place-holder to avoid a few `#if' directives.
237 In this case, the type isn't actually used. */
238 typedef unsigned long int ulonglong_t;
241 #define MAX_INTEGRAL_TYPE_SIZE sizeof (ulonglong_t)
242 static enum size_spec integral_type_size[MAX_INTEGRAL_TYPE_SIZE + 1];
244 #define MAX_FP_TYPE_SIZE sizeof(LONG_DOUBLE)
245 static enum size_spec fp_type_size[MAX_FP_TYPE_SIZE + 1];
247 static char const short_options[] =
248 "abcdfhilos" OPTARG_POSIX "xw" OPTARG_POSIX "A:j:N:t:v";
250 /* For long options that have no equivalent short option, use a
251 non-character as a pseudo short option, starting with CHAR_MAX + 1. */
254 STRINGS_OPTION = CHAR_MAX + 1,
259 static struct option const long_options[] =
261 {"skip-bytes", required_argument, NULL, 'j'},
262 {"address-radix", required_argument, NULL, 'A'},
263 {"read-bytes", required_argument, NULL, 'N'},
264 {"format", required_argument, NULL, 't'},
265 {"output-duplicates", no_argument, NULL, 'v'},
267 {"strings", optional_argument, NULL, STRINGS_OPTION},
268 {"traditional", no_argument, NULL, TRADITIONAL_OPTION},
269 {"width", optional_argument, NULL, WIDTH_OPTION},
271 {GETOPT_HELP_OPTION_DECL},
272 {GETOPT_VERSION_OPTION_DECL},
280 fprintf (stderr, _("Try `%s --help' for more information.\n"),
285 Usage: %s [OPTION]... [FILE]...\n\
286 or: %s --traditional [FILE] [[+]OFFSET [[+]LABEL]]\n\
288 program_name, program_name);
290 Write an unambiguous representation, octal bytes by default,\n\
291 of FILE to standard output. With more than one FILE argument,\n\
292 concatenate them in the listed order to form the input.\n\
293 With no FILE, or when FILE is -, read standard input.\n\
296 if (POSIX2_VERSION < 200112)
298 Mandatory arguments to long options are mandatory for short options too.\n\
302 All arguments to long options are mandatory for short options.\n\
305 -A, --address-radix=RADIX decide how file offsets are printed\n\
306 -j, --skip-bytes=BYTES skip BYTES input bytes first\n\
309 -N, --read-bytes=BYTES limit dump to BYTES input bytes\n\
310 -s, --strings[=BYTES] output strings of at least BYTES graphic chars\n\
311 -t, --format=TYPE select output format or formats\n\
312 -v, --output-duplicates do not use * to mark line suppression\n\
313 -w, --width[=BYTES] output BYTES bytes per output line\n\
314 --traditional accept arguments in traditional form\n\
316 fputs (HELP_OPTION_DESCRIPTION, stdout);
317 fputs (VERSION_OPTION_DESCRIPTION, stdout);
320 Traditional format specifications may be intermixed; they accumulate:\n\
321 -a same as -t a, select named characters\n\
322 -b same as -t oC, select octal bytes\n\
323 -c same as -t c, select ASCII characters or backslash escapes\n\
324 -d same as -t u2, select unsigned decimal shorts\n\
327 -f same as -t fF, select floats\n\
328 -h same as -t x2, select hexadecimal shorts\n\
329 -i same as -t d2, select decimal shorts\n\
330 -l same as -t d4, select decimal longs\n\
331 -o same as -t o2, select octal shorts\n\
332 -x same as -t x2, select hexadecimal shorts\n\
336 For older syntax (second call format), OFFSET means -j OFFSET. LABEL\n\
337 is the pseudo-address at first byte printed, incremented when dump is\n\
338 progressing. For OFFSET and LABEL, a 0x or 0X prefix indicates\n\
339 hexadecimal, suffixes may be . for octal and b for multiply by 512.\n\
341 TYPE is made up of one or more of these specifications:\n\
344 c ASCII character or backslash escape\n\
347 d[SIZE] signed decimal, SIZE bytes per integer\n\
348 f[SIZE] floating point, SIZE bytes per integer\n\
349 o[SIZE] octal, SIZE bytes per integer\n\
350 u[SIZE] unsigned decimal, SIZE bytes per integer\n\
351 x[SIZE] hexadecimal, SIZE bytes per integer\n\
355 SIZE is a number. For TYPE in doux, SIZE may also be C for\n\
356 sizeof(char), S for sizeof(short), I for sizeof(int) or L for\n\
357 sizeof(long). If TYPE is f, SIZE may also be F for sizeof(float), D\n\
358 for sizeof(double) or L for sizeof(long double).\n\
362 RADIX is d for decimal, o for octal, x for hexadecimal or n for none.\n\
363 BYTES is hexadecimal with 0x or 0X prefix, it is multiplied by 512\n\
364 with b suffix, by 1024 with k and by 1048576 with m. Adding a z suffix to\n\
365 any type adds a display of printable characters to the end of each line\n\
369 --string without a number implies 3. --width without a number\n\
370 implies 32. By default, od uses -A o -t d2 -w 16.\n\
372 puts (_("\nReport bugs to <bug-textutils@gnu.org>."));
374 exit (status == 0 ? EXIT_SUCCESS : EXIT_FAILURE);
377 /* Compute the greatest common denominator of U and V
378 using Euclid's algorithm. */
381 gcd (unsigned int u, unsigned int v)
393 /* Compute the least common multiple of U and V. */
396 lcm (unsigned int u, unsigned int v)
398 unsigned int t = gcd (u, v);
405 print_s_char (size_t n_bytes, const char *block, const char *fmt_string)
408 for (i = n_bytes; i > 0; i--)
410 int tmp = (unsigned) *(const unsigned char *) block;
412 tmp -= SCHAR_MAX - SCHAR_MIN + 1;
413 assert (tmp <= SCHAR_MAX);
414 printf (fmt_string, tmp);
415 block += sizeof (unsigned char);
420 print_char (size_t n_bytes, const char *block, const char *fmt_string)
423 for (i = n_bytes; i > 0; i--)
425 unsigned int tmp = *(const unsigned char *) block;
426 printf (fmt_string, tmp);
427 block += sizeof (unsigned char);
432 print_s_short (size_t n_bytes, const char *block, const char *fmt_string)
435 for (i = n_bytes / sizeof (unsigned short); i > 0; i--)
437 int tmp = (unsigned) *(const unsigned short *) block;
439 tmp -= SHRT_MAX - SHRT_MIN + 1;
440 assert (tmp <= SHRT_MAX);
441 printf (fmt_string, tmp);
442 block += sizeof (unsigned short);
447 print_short (size_t n_bytes, const char *block, const char *fmt_string)
450 for (i = n_bytes / sizeof (unsigned short); i > 0; i--)
452 unsigned int tmp = *(const unsigned short *) block;
453 printf (fmt_string, tmp);
454 block += sizeof (unsigned short);
459 print_int (size_t n_bytes, const char *block, const char *fmt_string)
462 for (i = n_bytes / sizeof (unsigned int); i > 0; i--)
464 unsigned int tmp = *(const unsigned int *) block;
465 printf (fmt_string, tmp);
466 block += sizeof (unsigned int);
471 print_long (size_t n_bytes, const char *block, const char *fmt_string)
474 for (i = n_bytes / sizeof (unsigned long); i > 0; i--)
476 unsigned long tmp = *(const unsigned long *) block;
477 printf (fmt_string, tmp);
478 block += sizeof (unsigned long);
483 print_long_long (size_t n_bytes, const char *block, const char *fmt_string)
486 for (i = n_bytes / sizeof (ulonglong_t); i > 0; i--)
488 ulonglong_t tmp = *(const ulonglong_t *) block;
489 printf (fmt_string, tmp);
490 block += sizeof (ulonglong_t);
495 print_float (size_t n_bytes, const char *block, const char *fmt_string)
498 for (i = n_bytes / sizeof (float); i > 0; i--)
500 float tmp = *(const float *) block;
501 printf (fmt_string, tmp);
502 block += sizeof (float);
507 print_double (size_t n_bytes, const char *block, const char *fmt_string)
510 for (i = n_bytes / sizeof (double); i > 0; i--)
512 double tmp = *(const double *) block;
513 printf (fmt_string, tmp);
514 block += sizeof (double);
518 #ifdef HAVE_LONG_DOUBLE
520 print_long_double (size_t n_bytes, const char *block, const char *fmt_string)
523 for (i = n_bytes / sizeof (LONG_DOUBLE); i > 0; i--)
525 LONG_DOUBLE tmp = *(const LONG_DOUBLE *) block;
526 printf (fmt_string, tmp);
527 block += sizeof (LONG_DOUBLE);
534 dump_hexl_mode_trailer (size_t n_bytes, const char *block)
537 fputs (" >", stdout);
538 for (i = n_bytes; i > 0; i--)
540 unsigned int c = *(const unsigned char *) block;
541 unsigned int c2 = (ISPRINT(c) ? c : '.');
543 block += sizeof (unsigned char);
549 print_named_ascii (size_t n_bytes, const char *block,
550 const char *unused_fmt_string ATTRIBUTE_UNUSED)
553 for (i = n_bytes; i > 0; i--)
555 unsigned int c = *(const unsigned char *) block;
556 unsigned int masked_c = (0x7f & c);
562 else if (masked_c <= 040)
563 s = charname[masked_c];
566 sprintf (buf, " %c", masked_c);
571 block += sizeof (unsigned char);
576 print_ascii (size_t n_bytes, const char *block,
577 const char *unused_fmt_string ATTRIBUTE_UNUSED)
580 for (i = n_bytes; i > 0; i--)
582 unsigned int c = *(const unsigned char *) block;
621 sprintf (buf, (ISPRINT (c) ? " %c" : "%03o"), c);
622 s = (const char *) buf;
626 block += sizeof (unsigned char);
630 /* Convert a null-terminated (possibly zero-length) string S to an
631 unsigned long integer value. If S points to a non-digit set *P to S,
632 *VAL to 0, and return 0. Otherwise, accumulate the integer value of
633 the string of digits. If the string of digits represents a value
634 larger than ULONG_MAX, don't modify *VAL or *P and return nonzero.
635 Otherwise, advance *P to the first non-digit after S, set *VAL to
636 the result of the conversion and return zero. */
639 simple_strtoul (const char *s, const char **p, long unsigned int *val)
641 unsigned long int sum;
646 unsigned int c = *s++ - '0';
647 if (sum > (ULONG_MAX - c) / 10)
656 /* If S points to a single valid modern od format string, put
657 a description of that format in *TSPEC, make *NEXT point at the
658 character following the just-decoded format (if *NEXT is non-NULL),
659 and return zero. If S is not valid, don't modify *NEXT or *TSPEC,
660 give a diagnostic, and return nonzero. For example, if S were
661 "d4afL" *NEXT would be set to "afL" and *TSPEC would be
663 fmt = SIGNED_DECIMAL;
664 size = INT or LONG; (whichever integral_type_size[4] resolves to)
665 print_function = print_int; (assuming size == INT)
666 fmt_string = "%011d%c";
668 S_ORIG is solely for reporting errors. It should be the full format
673 decode_one_format (const char *s_orig, const char *s, const char **next,
676 enum size_spec size_spec;
677 unsigned long int size;
678 enum output_format fmt;
679 const char *pre_fmt_string;
681 void (*print_function) PARAMS ((size_t, const char *, const char *));
684 unsigned int field_width = 0;
686 assert (tspec != NULL);
700 size = sizeof (char);
705 size = sizeof (short);
715 size = sizeof (long int);
719 if (simple_strtoul (s, &p, &size) != 0)
721 /* The integer at P in S would overflow an unsigned long.
722 A digit string that long is sufficiently odd looking
723 that the following diagnostic is sufficient. */
724 error (0, 0, _("invalid type string `%s'"), s_orig);
731 if (MAX_INTEGRAL_TYPE_SIZE < size
732 || integral_type_size[size] == NO_SIZE)
734 error (0, 0, _("invalid type string `%s';\n\
735 this system doesn't provide a %lu-byte integral type"), s_orig, size);
743 #define FMT_BYTES_ALLOCATED 9
744 fmt_string = xmalloc (FMT_BYTES_ALLOCATED);
746 size_spec = integral_type_size[size];
751 fmt = SIGNED_DECIMAL;
752 sprintf (fmt_string, " %%%u%sd",
753 (field_width = bytes_to_signed_dec_digits[size]),
754 (size_spec == LONG ? "l"
755 : (size_spec == LONG_LONG ? "ll"
761 sprintf (fmt_string, " %%0%u%so",
762 (field_width = bytes_to_oct_digits[size]),
763 (size_spec == LONG ? "l" : ""));
767 fmt = UNSIGNED_DECIMAL;
768 sprintf (fmt_string, " %%%u%su",
769 (field_width = bytes_to_unsigned_dec_digits[size]),
770 (size_spec == LONG ? "l" : ""));
775 sprintf (fmt_string, " %%0%u%sx",
776 (field_width = bytes_to_hex_digits[size]),
777 (size_spec == LONG ? "l" : ""));
784 assert (strlen (fmt_string) < FMT_BYTES_ALLOCATED);
789 print_function = (fmt == SIGNED_DECIMAL
795 print_function = (fmt == SIGNED_DECIMAL
801 print_function = print_int;
805 print_function = print_long;
809 print_function = print_long_long;
818 fmt = FLOATING_POINT;
824 size = sizeof (float);
829 size = sizeof (double);
834 size = sizeof (LONG_DOUBLE);
838 if (simple_strtoul (s, &p, &size) != 0)
840 /* The integer at P in S would overflow an unsigned long.
841 A digit string that long is sufficiently odd looking
842 that the following diagnostic is sufficient. */
843 error (0, 0, _("invalid type string `%s'"), s_orig);
847 size = sizeof (double);
850 if (size > MAX_FP_TYPE_SIZE
851 || fp_type_size[size] == NO_SIZE)
853 error (0, 0, _("invalid type string `%s';\n\
854 this system doesn't provide a %lu-byte floating point type"), s_orig, size);
861 size_spec = fp_type_size[size];
866 print_function = print_float;
867 /* Don't use %#e; not all systems support it. */
868 pre_fmt_string = " %%%d.%de";
869 fmt_string = xmalloc (strlen (pre_fmt_string));
870 sprintf (fmt_string, pre_fmt_string,
871 (field_width = FLT_DIG + 8), FLT_DIG);
875 print_function = print_double;
876 pre_fmt_string = " %%%d.%de";
877 fmt_string = xmalloc (strlen (pre_fmt_string));
878 sprintf (fmt_string, pre_fmt_string,
879 (field_width = DBL_DIG + 8), DBL_DIG);
882 #ifdef HAVE_LONG_DOUBLE
883 case FLOAT_LONG_DOUBLE:
884 print_function = print_long_double;
885 pre_fmt_string = " %%%d.%dLe";
886 fmt_string = xmalloc (strlen (pre_fmt_string));
887 sprintf (fmt_string, pre_fmt_string,
888 (field_width = LDBL_DIG + 8), LDBL_DIG);
899 fmt = NAMED_CHARACTER;
902 print_function = print_named_ascii;
911 print_function = print_ascii;
916 error (0, 0, _("invalid character `%c' in type string `%s'"),
921 tspec->size = size_spec;
923 tspec->print_function = print_function;
924 tspec->fmt_string = fmt_string;
926 tspec->field_width = field_width;
927 tspec->hexl_mode_trailer = (*s == 'z');
928 if (tspec->hexl_mode_trailer)
937 /* Given a list of one or more input filenames FILE_LIST, set the global
938 file pointer IN_STREAM and the global string INPUT_FILENAME to the
939 first one that can be successfully opened. Modify FILE_LIST to
940 reference the next filename in the list. A file name of "-" is
941 interpreted as standard input. If any file open fails, give an error
942 message and return nonzero. */
945 open_next_file (void)
951 input_filename = *file_list;
952 if (input_filename == NULL)
956 if (STREQ (input_filename, "-"))
958 input_filename = _("standard input");
964 in_stream = fopen (input_filename, "r");
965 if (in_stream == NULL)
967 error (0, errno, "%s", input_filename);
972 while (in_stream == NULL);
974 if (limit_bytes_to_format && !flag_dump_strings)
975 SETVBUF (in_stream, NULL, _IONBF, 0);
976 SET_BINARY (fileno (in_stream));
981 /* Test whether there have been errors on in_stream, and close it if
982 it is not standard input. Return nonzero if there has been an error
983 on in_stream or stdout; return zero otherwise. This function will
984 report more than one error only if both a read and a write error
988 check_and_close (void)
992 if (in_stream != NULL)
994 if (ferror (in_stream))
996 error (0, errno, "%s", input_filename);
997 if (in_stream != stdin)
1001 else if (in_stream != stdin && fclose (in_stream) == EOF)
1003 error (0, errno, "%s", input_filename);
1010 if (ferror (stdout))
1012 error (0, errno, _("standard output"));
1019 /* Decode the modern od format string S. Append the decoded
1020 representation to the global array SPEC, reallocating SPEC if
1021 necessary. Return zero if S is valid, nonzero otherwise. */
1024 decode_format_string (const char *s)
1026 const char *s_orig = s;
1034 if (decode_one_format (s_orig, s, &next, &tspec))
1040 if (n_specs >= n_specs_allocated)
1042 n_specs_allocated = 1 + (3 * n_specs_allocated) / 2;
1043 spec = (struct tspec *) xrealloc ((char *) spec,
1045 * sizeof (struct tspec)));
1048 memcpy ((char *) &spec[n_specs], (char *) &tspec,
1049 sizeof (struct tspec));
1056 /* Given a list of one or more input filenames FILE_LIST, set the global
1057 file pointer IN_STREAM to position N_SKIP in the concatenation of
1058 those files. If any file operation fails or if there are fewer than
1059 N_SKIP bytes in the combined input, give an error message and return
1060 nonzero. When possible, use seek rather than read operations to
1061 advance IN_STREAM. */
1064 skip (uintmax_t n_skip)
1071 while (in_stream != NULL) /* EOF. */
1073 struct stat file_stats;
1075 /* First try seeking. For large offsets, this extra work is
1076 worthwhile. If the offset is below some threshold it may be
1077 more efficient to move the pointer by reading. There are two
1078 issues when trying to seek:
1079 - the file must be seekable.
1080 - before seeking to the specified position, make sure
1081 that the new position is in the current file.
1082 Try to do that by getting file's size using fstat.
1083 But that will work only for regular files. */
1085 if (fstat (fileno (in_stream), &file_stats) == 0)
1087 /* The st_size field is valid only for regular files
1088 (and for symbolic links, which cannot occur here).
1089 If the number of bytes left to skip is at least
1090 as large as the size of the current file, we can
1091 decrement n_skip and go on to the next file. */
1093 if (S_ISREG (file_stats.st_mode) && 0 <= file_stats.st_size)
1095 if (file_stats.st_size <= n_skip)
1096 n_skip -= file_stats.st_size;
1099 if (fseeko (in_stream, n_skip, SEEK_CUR) != 0)
1101 error (0, errno, "%s", input_filename);
1108 /* If it's not a regular file with nonnegative size,
1109 position the file pointer by reading. */
1114 size_t n_bytes_read, n_bytes_to_read = BUFSIZ;
1118 if (n_skip < n_bytes_to_read)
1119 n_bytes_to_read = n_skip;
1120 n_bytes_read = fread (buf, 1, n_bytes_to_read, in_stream);
1121 n_skip -= n_bytes_read;
1122 if (n_bytes_read != n_bytes_to_read)
1131 else /* cannot fstat() file */
1133 error (0, errno, "%s", input_filename);
1137 err |= check_and_close ();
1139 err |= open_next_file ();
1143 error (EXIT_FAILURE, 0, _("cannot skip past end of combined input"));
1149 format_address_none (uintmax_t address ATTRIBUTE_UNUSED, char c ATTRIBUTE_UNUSED)
1154 format_address_std (uintmax_t address, char c)
1156 char buf[MAX_ADDRESS_LENGTH + 2];
1157 char *p = buf + sizeof buf;
1162 pbound = p - address_pad_len;
1164 /* Use a special case of the code for each base. This is measurably
1165 faster than generic code. */
1166 switch (address_base)
1170 *--p = '0' + (address & 7);
1171 while ((address >>= 3) != 0);
1176 *--p = '0' + (address % 10);
1177 while ((address /= 10) != 0);
1182 *--p = "0123456789abcdef"[address & 15];
1183 while ((address >>= 4) != 0);
1194 format_address_paren (uintmax_t address, char c)
1197 format_address_std (address, ')');
1202 format_address_label (uintmax_t address, char c)
1204 format_address_std (address, ' ');
1205 format_address_paren (address + pseudo_offset, c);
1208 /* Write N_BYTES bytes from CURR_BLOCK to standard output once for each
1209 of the N_SPEC format specs. CURRENT_OFFSET is the byte address of
1210 CURR_BLOCK in the concatenation of input files, and it is printed
1211 (optionally) only before the output line associated with the first
1212 format spec. When duplicate blocks are being abbreviated, the output
1213 for a sequence of identical input blocks is the output for the first
1214 block followed by an asterisk alone on a line. It is valid to compare
1215 the blocks PREV_BLOCK and CURR_BLOCK only when N_BYTES == BYTES_PER_BLOCK.
1216 That condition may be false only for the last input block -- and then
1217 only when it has not been padded to length BYTES_PER_BLOCK. */
1220 write_block (uintmax_t current_offset, size_t n_bytes,
1221 const char *prev_block, const char *curr_block)
1223 static int first = 1;
1224 static int prev_pair_equal = 0;
1226 #define EQUAL_BLOCKS(b1, b2) (memcmp ((b1), (b2), bytes_per_block) == 0)
1228 if (abbreviate_duplicate_blocks
1229 && !first && n_bytes == bytes_per_block
1230 && EQUAL_BLOCKS (prev_block, curr_block))
1232 if (prev_pair_equal)
1234 /* The two preceding blocks were equal, and the current
1235 block is the same as the last one, so print nothing. */
1240 prev_pair_equal = 1;
1247 prev_pair_equal = 0;
1248 for (i = 0; i < n_specs; i++)
1251 format_address (current_offset, '\0');
1253 printf ("%*s", address_pad_len, "");
1254 (*spec[i].print_function) (n_bytes, curr_block, spec[i].fmt_string);
1255 if (spec[i].hexl_mode_trailer)
1257 /* space-pad out to full line width, then dump the trailer */
1258 int datum_width = width_bytes[spec[i].size];
1259 int blank_fields = (bytes_per_block - n_bytes) / datum_width;
1260 int field_width = spec[i].field_width + 1;
1261 printf ("%*s", blank_fields * field_width, "");
1262 dump_hexl_mode_trailer (n_bytes, curr_block);
1270 /* Read a single byte into *C from the concatenation of the input files
1271 named in the global array FILE_LIST. On the first call to this
1272 function, the global variable IN_STREAM is expected to be an open
1273 stream associated with the input file INPUT_FILENAME. If IN_STREAM
1274 is at end-of-file, close it and update the global variables IN_STREAM
1275 and INPUT_FILENAME so they correspond to the next file in the list.
1276 Then try to read a byte from the newly opened file. Repeat if
1277 necessary until EOF is reached for the last file in FILE_LIST, then
1278 set *C to EOF and return. Subsequent calls do likewise. The return
1279 value is nonzero if any errors occured, zero otherwise. */
1288 while (in_stream != NULL) /* EOF. */
1290 *c = fgetc (in_stream);
1295 err |= check_and_close ();
1297 err |= open_next_file ();
1303 /* Read N bytes into BLOCK from the concatenation of the input files
1304 named in the global array FILE_LIST. On the first call to this
1305 function, the global variable IN_STREAM is expected to be an open
1306 stream associated with the input file INPUT_FILENAME. If all N
1307 bytes cannot be read from IN_STREAM, close IN_STREAM and update
1308 the global variables IN_STREAM and INPUT_FILENAME. Then try to
1309 read the remaining bytes from the newly opened file. Repeat if
1310 necessary until EOF is reached for the last file in FILE_LIST.
1311 On subsequent calls, don't modify BLOCK and return zero. Set
1312 *N_BYTES_IN_BUFFER to the number of bytes read. If an error occurs,
1313 it will be detected through ferror when the stream is about to be
1314 closed. If there is an error, give a message but continue reading
1315 as usual and return nonzero. Otherwise return zero. */
1318 read_block (size_t n, char *block, size_t *n_bytes_in_buffer)
1322 assert (0 < n && n <= bytes_per_block);
1324 *n_bytes_in_buffer = 0;
1329 while (in_stream != NULL) /* EOF. */
1334 n_needed = n - *n_bytes_in_buffer;
1335 n_read = fread (block + *n_bytes_in_buffer, 1, n_needed, in_stream);
1337 *n_bytes_in_buffer += n_read;
1339 if (n_read == n_needed)
1342 err |= check_and_close ();
1344 err |= open_next_file ();
1350 /* Return the least common multiple of the sizes associated
1351 with the format specs. */
1359 for (i = 0; i < n_specs; i++)
1360 l_c_m = lcm (l_c_m, width_bytes[(int) spec[i].size]);
1364 /* If S is a valid traditional offset specification with an optional
1365 leading '+' return nonzero and set *OFFSET to the offset it denotes. */
1368 parse_old_offset (const char *s, uintmax_t *offset)
1371 enum strtol_error s_err;
1376 /* Skip over any leading '+'. */
1380 /* Determine the radix we'll use to interpret S. If there is a `.',
1381 it's decimal, otherwise, if the string begins with `0X'or `0x',
1382 it's hexadecimal, else octal. */
1383 if (strchr (s, '.') != NULL)
1387 if (s[0] == '0' && (s[1] == 'x' || s[1] == 'X'))
1393 s_err = xstrtoumax (s, NULL, radix, offset, "Bb");
1394 if (s_err != LONGINT_OK)
1396 STRTOL_FAIL_WARN (s, _("old-style offset"), s_err);
1402 /* Read a chunk of size BYTES_PER_BLOCK from the input files, write the
1403 formatted block to standard output, and repeat until the specified
1404 maximum number of bytes has been read or until all input has been
1405 processed. If the last block read is smaller than BYTES_PER_BLOCK
1406 and its size is not a multiple of the size associated with a format
1407 spec, extend the input block with zero bytes until its length is a
1408 multiple of all format spec sizes. Write the final block. Finally,
1409 write on a line by itself the offset of the byte after the last byte
1410 read. Accumulate return values from calls to read_block and
1411 check_and_close, and if any was nonzero, return nonzero.
1412 Otherwise, return zero. */
1418 uintmax_t current_offset;
1421 size_t n_bytes_read;
1423 block[0] = (char *) alloca (bytes_per_block);
1424 block[1] = (char *) alloca (bytes_per_block);
1426 current_offset = n_bytes_to_skip;
1430 if (limit_bytes_to_format)
1435 if (current_offset >= end_offset)
1440 n_needed = MIN (end_offset - current_offset,
1441 (uintmax_t) bytes_per_block);
1442 err |= read_block (n_needed, block[idx], &n_bytes_read);
1443 if (n_bytes_read < bytes_per_block)
1445 assert (n_bytes_read == bytes_per_block);
1446 write_block (current_offset, n_bytes_read,
1447 block[!idx], block[idx]);
1448 current_offset += n_bytes_read;
1456 err |= read_block (bytes_per_block, block[idx], &n_bytes_read);
1457 if (n_bytes_read < bytes_per_block)
1459 assert (n_bytes_read == bytes_per_block);
1460 write_block (current_offset, n_bytes_read,
1461 block[!idx], block[idx]);
1462 current_offset += n_bytes_read;
1467 if (n_bytes_read > 0)
1470 size_t bytes_to_write;
1474 /* Make bytes_to_write the smallest multiple of l_c_m that
1475 is at least as large as n_bytes_read. */
1476 bytes_to_write = l_c_m * ((n_bytes_read + l_c_m - 1) / l_c_m);
1478 memset (block[idx] + n_bytes_read, 0, bytes_to_write - n_bytes_read);
1479 write_block (current_offset, bytes_to_write,
1480 block[!idx], block[idx]);
1481 current_offset += n_bytes_read;
1484 format_address (current_offset, '\n');
1486 if (limit_bytes_to_format && current_offset >= end_offset)
1487 err |= check_and_close ();
1492 /* STRINGS mode. Find each "string constant" in the input.
1493 A string constant is a run of at least `string_min' ASCII
1494 graphic (or formatting) characters terminated by a null.
1495 Based on a function written by Richard Stallman for a
1496 traditional version of od. Return nonzero if an error
1497 occurs. Otherwise, return zero. */
1502 size_t bufsize = MAX (100, string_min);
1503 char *buf = xmalloc (bufsize);
1504 uintmax_t address = n_bytes_to_skip;
1513 /* See if the next `string_min' chars are all printing chars. */
1516 if (limit_bytes_to_format
1517 && (end_offset < string_min || end_offset - string_min <= address))
1520 for (i = 0; i < string_min; i++)
1522 err |= read_char (&c);
1530 /* Found a non-printing. Try again starting with next char. */
1535 /* We found a run of `string_min' printable characters.
1536 Now see if it is terminated with a null byte. */
1537 while (!limit_bytes_to_format || address < end_offset)
1541 bufsize = 1 + 3 * bufsize / 2;
1542 buf = xrealloc (buf, bufsize);
1544 err |= read_char (&c);
1552 break; /* It is; print this string. */
1554 goto tryline; /* It isn't; give up on this string. */
1555 buf[i++] = c; /* String continues; store it all. */
1558 /* If we get here, the string is all printable and null-terminated,
1559 so print it. It is all in `buf' and `i' is its length. */
1561 format_address (address - i - 1, ' ');
1563 for (i = 0; (c = buf[i]); i++)
1568 fputs ("\\a", stdout);
1572 fputs ("\\b", stdout);
1576 fputs ("\\f", stdout);
1580 fputs ("\\n", stdout);
1584 fputs ("\\r", stdout);
1588 fputs ("\\t", stdout);
1592 fputs ("\\v", stdout);
1602 /* We reach this point only if we search through
1603 (max_bytes_to_format - string_min) bytes before reaching EOF. */
1607 err |= check_and_close ();
1612 main (int argc, char **argv)
1618 size_t desired_width IF_LINT (= 0);
1619 int width_specified = 0;
1620 int n_failed_decodes = 0;
1622 bool posix_pedantic = (getenv ("POSIXLY_CORRECT") != NULL);
1624 /* The old-style `pseudo starting address' to be printed in parentheses
1625 after any true address. */
1626 uintmax_t pseudo_start IF_LINT (= 0);
1628 program_name = argv[0];
1629 setlocale (LC_ALL, "");
1630 bindtextdomain (PACKAGE, LOCALEDIR);
1631 textdomain (PACKAGE);
1633 atexit (close_stdout);
1637 for (i = 0; i <= MAX_INTEGRAL_TYPE_SIZE; i++)
1638 integral_type_size[i] = NO_SIZE;
1640 integral_type_size[sizeof (char)] = CHAR;
1641 integral_type_size[sizeof (short int)] = SHORT;
1642 integral_type_size[sizeof (int)] = INT;
1643 integral_type_size[sizeof (long int)] = LONG;
1644 #if HAVE_UNSIGNED_LONG_LONG
1645 integral_type_size[sizeof (ulonglong_t)] = LONG_LONG;
1648 for (i = 0; i <= MAX_FP_TYPE_SIZE; i++)
1649 fp_type_size[i] = NO_SIZE;
1651 fp_type_size[sizeof (float)] = FLOAT_SINGLE;
1652 /* The array entry for `double' is filled in after that for LONG_DOUBLE
1653 so that if `long double' is the same type or if long double isn't
1654 supported FLOAT_LONG_DOUBLE will never be used. */
1655 fp_type_size[sizeof (LONG_DOUBLE)] = FLOAT_LONG_DOUBLE;
1656 fp_type_size[sizeof (double)] = FLOAT_DOUBLE;
1659 n_specs_allocated = 5;
1660 spec = (struct tspec *) xmalloc (n_specs_allocated * sizeof (struct tspec));
1662 format_address = format_address_std;
1664 address_pad_len = 7;
1665 flag_dump_strings = 0;
1667 while ((c = getopt_long (argc, argv, short_options, long_options, NULL))
1671 enum strtol_error s_err;
1682 format_address = format_address_std;
1684 address_pad_len = 7;
1687 format_address = format_address_std;
1689 address_pad_len = 7;
1692 format_address = format_address_std;
1694 address_pad_len = 6;
1697 format_address = format_address_none;
1698 address_pad_len = 0;
1701 error (EXIT_FAILURE, 0,
1702 _("invalid output address radix `%c'; \
1703 it must be one character from [doxn]"),
1710 s_err = xstrtoumax (optarg, NULL, 0, &n_bytes_to_skip, "bkm");
1711 if (s_err != LONGINT_OK)
1712 STRTOL_FATAL_ERROR (optarg, _("skip argument"), s_err);
1716 limit_bytes_to_format = 1;
1718 s_err = xstrtoumax (optarg, NULL, 0, &max_bytes_to_format, "bkm");
1719 if (s_err != LONGINT_OK)
1720 STRTOL_FATAL_ERROR (optarg, _("limit argument"), s_err);
1724 if (POSIX2_VERSION < 200112 && OBSOLETE_OPTION_WARNINGS
1725 && ! optarg && ! posix_pedantic)
1727 _("warning: `od -s' is obsolete; use `od --strings'"));
1729 case STRINGS_OPTION:
1734 s_err = xstrtoumax (optarg, NULL, 0, &tmp, "bkm");
1735 if (s_err != LONGINT_OK)
1736 STRTOL_FATAL_ERROR (optarg, _("minimum string length"), s_err);
1738 /* The minimum string length may be no larger than SIZE_MAX,
1739 since we may allocate a buffer of this size. */
1741 error (EXIT_FAILURE, 0, _("%s is too large"), optarg);
1745 flag_dump_strings = 1;
1749 if (decode_format_string (optarg))
1754 abbreviate_duplicate_blocks = 0;
1757 case TRADITIONAL_OPTION:
1761 /* The next several cases map the traditional format
1762 specification options to the corresponding modern format
1763 specs. GNU od accepts any combination of old- and
1764 new-style options. Format specification options accumulate. */
1766 #define CASE_OLD_ARG(old_char,new_string) \
1769 if (decode_format_string (new_string)) \
1770 ++n_failed_decodes; \
1774 CASE_OLD_ARG ('a', "a");
1775 CASE_OLD_ARG ('b', "oC");
1776 CASE_OLD_ARG ('c', "c");
1777 CASE_OLD_ARG ('d', "u2");
1778 CASE_OLD_ARG ('f', "fF");
1779 CASE_OLD_ARG ('h', "x2");
1780 CASE_OLD_ARG ('i', "d2");
1781 CASE_OLD_ARG ('l', "d4");
1782 CASE_OLD_ARG ('o', "o2");
1783 CASE_OLD_ARG ('x', "x2");
1785 /* FIXME: POSIX 1003.1-2001 with XSI requires this:
1787 CASE_OLD_ARG ('s', "d2");
1789 for the traditional syntax, but this conflicts with case
1795 if (POSIX2_VERSION < 200112 && OBSOLETE_OPTION_WARNINGS
1796 && ! optarg && ! posix_pedantic)
1797 error (0, 0, _("warning: `od -w' is obsolete; use `od --width'"));
1800 width_specified = 1;
1808 s_err = xstrtoumax (optarg, NULL, 10, &w_tmp, "");
1809 if (s_err != LONGINT_OK)
1810 STRTOL_FATAL_ERROR (optarg, _("width specification"), s_err);
1811 if (SIZE_MAX < w_tmp)
1812 error (EXIT_FAILURE, 0, _("%s is too large"), optarg);
1813 desired_width = w_tmp;
1817 case_GETOPT_HELP_CHAR;
1819 case_GETOPT_VERSION_CHAR (PROGRAM_NAME, AUTHORS);
1827 if (n_failed_decodes > 0)
1828 exit (EXIT_FAILURE);
1830 if (flag_dump_strings && n_specs > 0)
1831 error (EXIT_FAILURE, 0,
1832 _("no type may be specified when dumping strings"));
1834 n_files = argc - optind;
1836 /* If the --traditional option is used, there may be from
1837 0 to 3 remaining command line arguments; handle each case
1839 od [file] [[+]offset[.][b] [[+]label[.][b]]]
1840 The offset and pseudo_start have the same syntax.
1842 FIXME: POSIX 1003.1-2001 with XSI requires support for the
1843 traditional syntax even if --traditional is not given. */
1851 if (parse_old_offset (argv[optind], &offset))
1853 n_bytes_to_skip = offset;
1858 else if (n_files == 2)
1861 if (parse_old_offset (argv[optind], &o1)
1862 && parse_old_offset (argv[optind + 1], &o2))
1864 n_bytes_to_skip = o1;
1865 flag_pseudo_start = 1;
1870 else if (parse_old_offset (argv[optind + 1], &o2))
1872 n_bytes_to_skip = o2;
1874 argv[optind + 1] = argv[optind];
1880 _("invalid second operand in compatibility mode `%s'"),
1885 else if (n_files == 3)
1888 if (parse_old_offset (argv[optind + 1], &o1)
1889 && parse_old_offset (argv[optind + 2], &o2))
1891 n_bytes_to_skip = o1;
1892 flag_pseudo_start = 1;
1894 argv[optind + 2] = argv[optind];
1901 _("in compatibility mode, the last two arguments must be offsets"));
1905 else if (n_files > 3)
1908 _("compatibility mode supports at most three arguments"));
1912 if (flag_pseudo_start)
1914 if (format_address == format_address_none)
1917 address_pad_len = 7;
1918 format_address = format_address_paren;
1921 format_address = format_address_label;
1925 if (limit_bytes_to_format)
1927 end_offset = n_bytes_to_skip + max_bytes_to_format;
1928 if (end_offset < n_bytes_to_skip)
1929 error (EXIT_FAILURE, 0, "skip-bytes + read-bytes is too large");
1934 if (decode_one_format ("o2", "o2", NULL, &(spec[0])))
1936 /* This happens on Cray systems that don't have a 2-byte
1938 exit (EXIT_FAILURE);
1946 /* Set the global pointer FILE_LIST so that it
1947 references the first file-argument on the command-line. */
1949 file_list = (char const *const *) &argv[optind];
1953 /* No files were listed on the command line.
1954 Set the global pointer FILE_LIST so that it
1955 references the null-terminated list of one name: "-". */
1957 file_list = default_file_list;
1960 /* open the first input file */
1961 err |= open_next_file ();
1962 if (in_stream == NULL)
1965 /* skip over any unwanted header bytes */
1966 err |= skip (n_bytes_to_skip);
1967 if (in_stream == NULL)
1970 pseudo_offset = (flag_pseudo_start ? pseudo_start - n_bytes_to_skip : 0);
1972 /* Compute output block length. */
1975 if (width_specified)
1977 if (desired_width != 0 && desired_width % l_c_m == 0)
1978 bytes_per_block = desired_width;
1981 error (0, 0, _("warning: invalid width %lu; using %d instead"),
1982 (unsigned long) desired_width, l_c_m);
1983 bytes_per_block = l_c_m;
1988 if (l_c_m < DEFAULT_BYTES_PER_BLOCK)
1989 bytes_per_block = l_c_m * (DEFAULT_BYTES_PER_BLOCK / l_c_m);
1991 bytes_per_block = l_c_m;
1995 for (i = 0; i < n_specs; i++)
1997 printf (_("%d: fmt=\"%s\" width=%d\n"),
1998 i, spec[i].fmt_string, width_bytes[spec[i].size]);
2002 err |= (flag_dump_strings ? dump_strings () : dump ());
2006 if (have_read_stdin && fclose (stdin) == EOF)
2007 error (EXIT_FAILURE, errno, _("standard input"));
2009 exit (err == 0 ? EXIT_SUCCESS : EXIT_FAILURE);