1 /* od -- dump files in octal and other formats
2 Copyright (C) 92, 1995-2003 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;
46 /* The default number of input bytes per output line. */
47 #define DEFAULT_BYTES_PER_BLOCK 16
49 /* The number of decimal digits of precision in a float. */
54 /* The number of decimal digits of precision in a double. */
59 /* The number of decimal digits of precision in a long double. */
61 # define LDBL_DIG DBL_DIG
64 #if HAVE_UNSIGNED_LONG_LONG
65 typedef unsigned long long ulonglong_t;
67 /* This is just a place-holder to avoid a few `#if' directives.
68 In this case, the type isn't actually used. */
69 typedef unsigned long int ulonglong_t;
80 /* FIXME: add INTMAX support, too */
98 /* Each output format specification (from `-t spec' or from
99 old-style options) is represented by one of these structures. */
102 enum output_format fmt;
104 void (*print_function) (size_t, const char *, const char *);
106 int hexl_mode_trailer;
110 /* The name this program was run with. */
113 /* Convert the number of 8-bit bytes of a binary representation to
114 the number of characters (digits + sign if the type is signed)
115 required to represent the same quantity in the specified base/type.
116 For example, a 32-bit (4-byte) quantity may require a field width
117 as wide as the following for these types:
121 8 unsigned hexadecimal */
123 static const unsigned int bytes_to_oct_digits[] =
124 {0, 3, 6, 8, 11, 14, 16, 19, 22, 25, 27, 30, 32, 35, 38, 41, 43};
126 static const unsigned int bytes_to_signed_dec_digits[] =
127 {1, 4, 6, 8, 11, 13, 16, 18, 20, 23, 25, 28, 30, 33, 35, 37, 40};
129 static const unsigned int bytes_to_unsigned_dec_digits[] =
130 {0, 3, 5, 8, 10, 13, 15, 17, 20, 22, 25, 27, 29, 32, 34, 37, 39};
132 static const unsigned int bytes_to_hex_digits[] =
133 {0, 2, 4, 6, 8, 10, 12, 14, 16, 18, 20, 22, 24, 26, 28, 30, 32};
135 /* Convert enum size_spec to the size of the named type. */
136 static const int width_bytes[] =
143 sizeof (ulonglong_t),
149 /* Ensure that for each member of `enum size_spec' there is an
150 initializer in the width_bytes array. */
153 int assert_width_bytes_matches_size_spec_decl
154 [sizeof width_bytes / sizeof width_bytes[0] == N_SIZE_SPECS ? 1 : -1];
157 /* Names for some non-printing characters. */
158 static const char *const charname[33] =
160 "nul", "soh", "stx", "etx", "eot", "enq", "ack", "bel",
161 "bs", "ht", "nl", "vt", "ff", "cr", "so", "si",
162 "dle", "dc1", "dc2", "dc3", "dc4", "nak", "syn", "etb",
163 "can", "em", "sub", "esc", "fs", "gs", "rs", "us",
167 /* Address base (8, 10 or 16). */
168 static int address_base;
170 /* The number of octal digits required to represent the largest
172 #define MAX_ADDRESS_LENGTH \
173 ((sizeof (uintmax_t) * CHAR_BIT + CHAR_BIT - 1) / 3)
175 /* Width of a normal address. */
176 static int address_pad_len;
178 static size_t string_min;
179 static int flag_dump_strings;
181 /* Non-zero if we should recognize the older non-option arguments
182 that specified at most one file and optional arguments specifying
183 offset and pseudo-start address. */
184 static int traditional;
186 /* Non-zero if an old-style `pseudo-address' was specified. */
187 static int flag_pseudo_start;
189 /* The difference between the old-style pseudo starting address and
190 the number of bytes to skip. */
191 static uintmax_t pseudo_offset;
193 /* Function that accepts an address and an optional following char,
194 and prints the address and char to stdout. */
195 static void (*format_address) (uintmax_t, char);
197 /* The number of input bytes to skip before formatting and writing. */
198 static uintmax_t n_bytes_to_skip = 0;
200 /* When zero, MAX_BYTES_TO_FORMAT and END_OFFSET are ignored, and all
201 input is formatted. */
202 static int limit_bytes_to_format = 0;
204 /* The maximum number of bytes that will be formatted. */
205 static uintmax_t max_bytes_to_format;
207 /* The offset of the first byte after the last byte to be formatted. */
208 static uintmax_t end_offset;
210 /* When nonzero and two or more consecutive blocks are equal, format
211 only the first block and output an asterisk alone on the following
212 line to indicate that identical blocks have been elided. */
213 static int abbreviate_duplicate_blocks = 1;
215 /* An array of specs describing how to format each input block. */
216 static struct tspec *spec;
218 /* The number of format specs. */
219 static size_t n_specs;
221 /* The allocated length of SPEC. */
222 static size_t n_specs_allocated;
224 /* The number of input bytes formatted per output line. It must be
225 a multiple of the least common multiple of the sizes associated with
226 the specified output types. It should be as large as possible, but
227 no larger than 16 -- unless specified with the -w option. */
228 static size_t bytes_per_block;
230 /* Human-readable representation of *file_list (for error messages).
231 It differs from *file_list only when *file_list is "-". */
232 static char const *input_filename;
234 /* A NULL-terminated list of the file-arguments from the command line. */
235 static char const *const *file_list;
237 /* Initializer for file_list if no file-arguments
238 were specified on the command line. */
239 static char const *const default_file_list[] = {"-", NULL};
241 /* The input stream associated with the current file. */
242 static FILE *in_stream;
244 /* If nonzero, at least one of the files we read was standard input. */
245 static int have_read_stdin;
247 #define MAX_INTEGRAL_TYPE_SIZE sizeof (ulonglong_t)
248 static enum size_spec integral_type_size[MAX_INTEGRAL_TYPE_SIZE + 1];
250 #define MAX_FP_TYPE_SIZE sizeof(LONG_DOUBLE)
251 static enum size_spec fp_type_size[MAX_FP_TYPE_SIZE + 1];
253 #define COMMON_SHORT_OPTIONS "A:N:abcdfhij:lot:vx"
255 /* For long options that have no equivalent short option, use a
256 non-character as a pseudo short option, starting with CHAR_MAX + 1. */
259 TRADITIONAL_OPTION = CHAR_MAX + 1
262 static struct option const long_options[] =
264 {"skip-bytes", required_argument, NULL, 'j'},
265 {"address-radix", required_argument, NULL, 'A'},
266 {"read-bytes", required_argument, NULL, 'N'},
267 {"format", required_argument, NULL, 't'},
268 {"output-duplicates", no_argument, NULL, 'v'},
269 {"strings", optional_argument, NULL, 's'},
270 {"traditional", no_argument, NULL, TRADITIONAL_OPTION},
271 {"width", optional_argument, NULL, 'w'},
273 {GETOPT_HELP_OPTION_DECL},
274 {GETOPT_VERSION_OPTION_DECL},
282 fprintf (stderr, _("Try `%s --help' for more information.\n"),
287 Usage: %s [OPTION]... [FILE]...\n\
288 or: %s --traditional [FILE] [[+]OFFSET [[+]LABEL]]\n\
290 program_name, program_name);
292 Write an unambiguous representation, octal bytes by default,\n\
293 of FILE to standard output. With more than one FILE argument,\n\
294 concatenate them in the listed order to form the input.\n\
295 With no FILE, or when FILE is -, read standard input.\n\
299 All arguments to long options are mandatory for short options.\n\
302 -A, --address-radix=RADIX decide how file offsets are printed\n\
303 -j, --skip-bytes=BYTES skip BYTES input bytes first\n\
306 -N, --read-bytes=BYTES limit dump to BYTES input bytes\n\
307 -s, --strings[=BYTES] output strings of at least BYTES graphic chars\n\
308 -t, --format=TYPE select output format or formats\n\
309 -v, --output-duplicates do not use * to mark line suppression\n\
310 -w, --width[=BYTES] output BYTES bytes per output line\n\
311 --traditional accept arguments in traditional form\n\
313 fputs (HELP_OPTION_DESCRIPTION, stdout);
314 fputs (VERSION_OPTION_DESCRIPTION, stdout);
317 Traditional format specifications may be intermixed; they accumulate:\n\
318 -a same as -t a, select named characters\n\
319 -b same as -t oC, select octal bytes\n\
320 -c same as -t c, select ASCII characters or backslash escapes\n\
321 -d same as -t u2, select unsigned decimal shorts\n\
324 -f same as -t fF, select floats\n\
325 -h same as -t x2, select hexadecimal shorts\n\
326 -i same as -t d2, select decimal shorts\n\
327 -l same as -t d4, select decimal longs\n\
328 -o same as -t o2, select octal shorts\n\
329 -x same as -t x2, select hexadecimal shorts\n\
333 For older syntax (second call format), OFFSET means -j OFFSET. LABEL\n\
334 is the pseudo-address at first byte printed, incremented when dump is\n\
335 progressing. For OFFSET and LABEL, a 0x or 0X prefix indicates\n\
336 hexadecimal, suffixes may be . for octal and b for multiply by 512.\n\
338 TYPE is made up of one or more of these specifications:\n\
341 c ASCII character or backslash escape\n\
344 d[SIZE] signed decimal, SIZE bytes per integer\n\
345 f[SIZE] floating point, SIZE bytes per integer\n\
346 o[SIZE] octal, SIZE bytes per integer\n\
347 u[SIZE] unsigned decimal, SIZE bytes per integer\n\
348 x[SIZE] hexadecimal, SIZE bytes per integer\n\
352 SIZE is a number. For TYPE in doux, SIZE may also be C for\n\
353 sizeof(char), S for sizeof(short), I for sizeof(int) or L for\n\
354 sizeof(long). If TYPE is f, SIZE may also be F for sizeof(float), D\n\
355 for sizeof(double) or L for sizeof(long double).\n\
359 RADIX is d for decimal, o for octal, x for hexadecimal or n for none.\n\
360 BYTES is hexadecimal with 0x or 0X prefix, it is multiplied by 512\n\
361 with b suffix, by 1024 with k and by 1048576 with m. Adding a z suffix to\n\
362 any type adds a display of printable characters to the end of each line\n\
366 --string without a number implies 3. --width without a number\n\
367 implies 32. By default, od uses -A o -t d2 -w 16.\n\
369 printf (_("\nReport bugs to <%s>.\n"), PACKAGE_BUGREPORT);
371 exit (status == 0 ? EXIT_SUCCESS : EXIT_FAILURE);
374 /* Compute the greatest common denominator of U and V
375 using Euclid's algorithm. */
378 gcd (unsigned int u, unsigned int v)
390 /* Compute the least common multiple of U and V. */
393 lcm (unsigned int u, unsigned int v)
395 unsigned int t = gcd (u, v);
402 print_s_char (size_t n_bytes, const char *block, const char *fmt_string)
405 for (i = n_bytes; i > 0; i--)
407 int tmp = (unsigned) *(const unsigned char *) block;
409 tmp -= SCHAR_MAX - SCHAR_MIN + 1;
410 assert (tmp <= SCHAR_MAX);
411 printf (fmt_string, tmp);
412 block += sizeof (unsigned char);
417 print_char (size_t n_bytes, const char *block, const char *fmt_string)
420 for (i = n_bytes; i > 0; i--)
422 unsigned int tmp = *(const unsigned char *) block;
423 printf (fmt_string, tmp);
424 block += sizeof (unsigned char);
429 print_s_short (size_t n_bytes, const char *block, const char *fmt_string)
432 for (i = n_bytes / sizeof (unsigned short); i > 0; i--)
434 int tmp = (unsigned) *(const unsigned short *) block;
436 tmp -= SHRT_MAX - SHRT_MIN + 1;
437 assert (tmp <= SHRT_MAX);
438 printf (fmt_string, tmp);
439 block += sizeof (unsigned short);
444 print_short (size_t n_bytes, const char *block, const char *fmt_string)
447 for (i = n_bytes / sizeof (unsigned short); i > 0; i--)
449 unsigned int tmp = *(const unsigned short *) block;
450 printf (fmt_string, tmp);
451 block += sizeof (unsigned short);
456 print_int (size_t n_bytes, const char *block, const char *fmt_string)
459 for (i = n_bytes / sizeof (unsigned int); i > 0; i--)
461 unsigned int tmp = *(const unsigned int *) block;
462 printf (fmt_string, tmp);
463 block += sizeof (unsigned int);
468 print_long (size_t n_bytes, const char *block, const char *fmt_string)
471 for (i = n_bytes / sizeof (unsigned long); i > 0; i--)
473 unsigned long tmp = *(const unsigned long *) block;
474 printf (fmt_string, tmp);
475 block += sizeof (unsigned long);
480 print_long_long (size_t n_bytes, const char *block, const char *fmt_string)
483 for (i = n_bytes / sizeof (ulonglong_t); i > 0; i--)
485 ulonglong_t tmp = *(const ulonglong_t *) block;
486 printf (fmt_string, tmp);
487 block += sizeof (ulonglong_t);
492 print_float (size_t n_bytes, const char *block, const char *fmt_string)
495 for (i = n_bytes / sizeof (float); i > 0; i--)
497 float tmp = *(const float *) block;
498 printf (fmt_string, tmp);
499 block += sizeof (float);
504 print_double (size_t n_bytes, const char *block, const char *fmt_string)
507 for (i = n_bytes / sizeof (double); i > 0; i--)
509 double tmp = *(const double *) block;
510 printf (fmt_string, tmp);
511 block += sizeof (double);
515 #ifdef HAVE_LONG_DOUBLE
517 print_long_double (size_t n_bytes, const char *block, const char *fmt_string)
520 for (i = n_bytes / sizeof (LONG_DOUBLE); i > 0; i--)
522 LONG_DOUBLE tmp = *(const LONG_DOUBLE *) block;
523 printf (fmt_string, tmp);
524 block += sizeof (LONG_DOUBLE);
531 dump_hexl_mode_trailer (size_t n_bytes, const char *block)
534 fputs (" >", stdout);
535 for (i = n_bytes; i > 0; i--)
537 unsigned int c = *(const unsigned char *) block;
538 unsigned int c2 = (ISPRINT(c) ? c : '.');
540 block += sizeof (unsigned char);
546 print_named_ascii (size_t n_bytes, const char *block,
547 const char *unused_fmt_string ATTRIBUTE_UNUSED)
550 for (i = n_bytes; i > 0; i--)
552 unsigned int c = *(const unsigned char *) block;
553 unsigned int masked_c = (0x7f & c);
559 else if (masked_c <= 040)
560 s = charname[masked_c];
563 sprintf (buf, " %c", masked_c);
568 block += sizeof (unsigned char);
573 print_ascii (size_t n_bytes, const char *block,
574 const char *unused_fmt_string ATTRIBUTE_UNUSED)
577 for (i = n_bytes; i > 0; i--)
579 unsigned int c = *(const unsigned char *) block;
618 sprintf (buf, (ISPRINT (c) ? " %c" : "%03o"), c);
619 s = (const char *) buf;
623 block += sizeof (unsigned char);
627 /* Convert a null-terminated (possibly zero-length) string S to an
628 unsigned long integer value. If S points to a non-digit set *P to S,
629 *VAL to 0, and return 0. Otherwise, accumulate the integer value of
630 the string of digits. If the string of digits represents a value
631 larger than ULONG_MAX, don't modify *VAL or *P and return nonzero.
632 Otherwise, advance *P to the first non-digit after S, set *VAL to
633 the result of the conversion and return zero. */
636 simple_strtoul (const char *s, const char **p, long unsigned int *val)
638 unsigned long int sum;
643 unsigned int c = *s++ - '0';
644 if (sum > (ULONG_MAX - c) / 10)
653 /* If S points to a single valid modern od format string, put
654 a description of that format in *TSPEC, make *NEXT point at the
655 character following the just-decoded format (if *NEXT is non-NULL),
656 and return zero. If S is not valid, don't modify *NEXT or *TSPEC,
657 give a diagnostic, and return nonzero. For example, if S were
658 "d4afL" *NEXT would be set to "afL" and *TSPEC would be
660 fmt = SIGNED_DECIMAL;
661 size = INT or LONG; (whichever integral_type_size[4] resolves to)
662 print_function = print_int; (assuming size == INT)
663 fmt_string = "%011d%c";
665 S_ORIG is solely for reporting errors. It should be the full format
670 decode_one_format (const char *s_orig, const char *s, const char **next,
673 enum size_spec size_spec;
674 unsigned long int size;
675 enum output_format fmt;
676 const char *pre_fmt_string;
678 void (*print_function) (size_t, const char *, const char *);
681 unsigned int field_width = 0;
683 assert (tspec != NULL);
697 size = sizeof (char);
702 size = sizeof (short);
712 size = sizeof (long int);
716 if (simple_strtoul (s, &p, &size) != 0)
718 /* The integer at P in S would overflow an unsigned long.
719 A digit string that long is sufficiently odd looking
720 that the following diagnostic is sufficient. */
721 error (0, 0, _("invalid type string `%s'"), s_orig);
728 if (MAX_INTEGRAL_TYPE_SIZE < size
729 || integral_type_size[size] == NO_SIZE)
731 error (0, 0, _("invalid type string `%s';\n\
732 this system doesn't provide a %lu-byte integral type"), s_orig, size);
740 #define ISPEC_TO_FORMAT(Spec, Min_format, Long_format, Max_format) \
741 ((Spec) == LONG_LONG ? (Max_format) \
742 : ((Spec) == LONG ? (Long_format) \
745 #define FMT_BYTES_ALLOCATED 9
746 fmt_string = xmalloc (FMT_BYTES_ALLOCATED);
748 size_spec = integral_type_size[size];
753 fmt = SIGNED_DECIMAL;
754 sprintf (fmt_string, " %%%u%s",
755 (field_width = bytes_to_signed_dec_digits[size]),
756 ISPEC_TO_FORMAT (size_spec, "d", "ld", PRIdMAX));
761 sprintf (fmt_string, " %%0%u%s",
762 (field_width = bytes_to_oct_digits[size]),
763 ISPEC_TO_FORMAT (size_spec, "o", "lo", PRIoMAX));
767 fmt = UNSIGNED_DECIMAL;
768 sprintf (fmt_string, " %%%u%s",
769 (field_width = bytes_to_unsigned_dec_digits[size]),
770 ISPEC_TO_FORMAT (size_spec, "u", "lu", PRIuMAX));
775 sprintf (fmt_string, " %%0%u%s",
776 (field_width = bytes_to_hex_digits[size]),
777 ISPEC_TO_FORMAT (size_spec, "x", "lx", PRIxMAX));
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 = xrealloc (spec, (n_specs_allocated * sizeof (struct tspec)));
1046 memcpy ((char *) &spec[n_specs], (char *) &tspec,
1047 sizeof (struct tspec));
1054 /* Given a list of one or more input filenames FILE_LIST, set the global
1055 file pointer IN_STREAM to position N_SKIP in the concatenation of
1056 those files. If any file operation fails or if there are fewer than
1057 N_SKIP bytes in the combined input, give an error message and return
1058 nonzero. When possible, use seek rather than read operations to
1059 advance IN_STREAM. */
1062 skip (uintmax_t n_skip)
1069 while (in_stream != NULL) /* EOF. */
1071 struct stat file_stats;
1073 /* First try seeking. For large offsets, this extra work is
1074 worthwhile. If the offset is below some threshold it may be
1075 more efficient to move the pointer by reading. There are two
1076 issues when trying to seek:
1077 - the file must be seekable.
1078 - before seeking to the specified position, make sure
1079 that the new position is in the current file.
1080 Try to do that by getting file's size using fstat.
1081 But that will work only for regular files. */
1083 if (fstat (fileno (in_stream), &file_stats) == 0)
1085 /* The st_size field is valid only for regular files
1086 (and for symbolic links, which cannot occur here).
1087 If the number of bytes left to skip is at least
1088 as large as the size of the current file, we can
1089 decrement n_skip and go on to the next file. */
1091 if (S_ISREG (file_stats.st_mode) && 0 <= file_stats.st_size)
1093 if ((uintmax_t) file_stats.st_size <= n_skip)
1094 n_skip -= file_stats.st_size;
1097 if (fseeko (in_stream, n_skip, SEEK_CUR) != 0)
1099 error (0, errno, "%s", input_filename);
1106 /* If it's not a regular file with nonnegative size,
1107 position the file pointer by reading. */
1112 size_t n_bytes_read, n_bytes_to_read = BUFSIZ;
1116 if (n_skip < n_bytes_to_read)
1117 n_bytes_to_read = n_skip;
1118 n_bytes_read = fread (buf, 1, n_bytes_to_read, in_stream);
1119 n_skip -= n_bytes_read;
1120 if (n_bytes_read != n_bytes_to_read)
1129 else /* cannot fstat() file */
1131 error (0, errno, "%s", input_filename);
1135 err |= check_and_close ();
1137 err |= open_next_file ();
1141 error (EXIT_FAILURE, 0, _("cannot skip past end of combined input"));
1147 format_address_none (uintmax_t address ATTRIBUTE_UNUSED, char c ATTRIBUTE_UNUSED)
1152 format_address_std (uintmax_t address, char c)
1154 char buf[MAX_ADDRESS_LENGTH + 2];
1155 char *p = buf + sizeof buf;
1160 pbound = p - address_pad_len;
1162 /* Use a special case of the code for each base. This is measurably
1163 faster than generic code. */
1164 switch (address_base)
1168 *--p = '0' + (address & 7);
1169 while ((address >>= 3) != 0);
1174 *--p = '0' + (address % 10);
1175 while ((address /= 10) != 0);
1180 *--p = "0123456789abcdef"[address & 15];
1181 while ((address >>= 4) != 0);
1192 format_address_paren (uintmax_t address, char c)
1195 format_address_std (address, ')');
1200 format_address_label (uintmax_t address, char c)
1202 format_address_std (address, ' ');
1203 format_address_paren (address + pseudo_offset, c);
1206 /* Write N_BYTES bytes from CURR_BLOCK to standard output once for each
1207 of the N_SPEC format specs. CURRENT_OFFSET is the byte address of
1208 CURR_BLOCK in the concatenation of input files, and it is printed
1209 (optionally) only before the output line associated with the first
1210 format spec. When duplicate blocks are being abbreviated, the output
1211 for a sequence of identical input blocks is the output for the first
1212 block followed by an asterisk alone on a line. It is valid to compare
1213 the blocks PREV_BLOCK and CURR_BLOCK only when N_BYTES == BYTES_PER_BLOCK.
1214 That condition may be false only for the last input block -- and then
1215 only when it has not been padded to length BYTES_PER_BLOCK. */
1218 write_block (uintmax_t current_offset, size_t n_bytes,
1219 const char *prev_block, const char *curr_block)
1221 static int first = 1;
1222 static int prev_pair_equal = 0;
1224 #define EQUAL_BLOCKS(b1, b2) (memcmp ((b1), (b2), bytes_per_block) == 0)
1226 if (abbreviate_duplicate_blocks
1227 && !first && n_bytes == bytes_per_block
1228 && EQUAL_BLOCKS (prev_block, curr_block))
1230 if (prev_pair_equal)
1232 /* The two preceding blocks were equal, and the current
1233 block is the same as the last one, so print nothing. */
1238 prev_pair_equal = 1;
1245 prev_pair_equal = 0;
1246 for (i = 0; i < n_specs; i++)
1249 format_address (current_offset, '\0');
1251 printf ("%*s", address_pad_len, "");
1252 (*spec[i].print_function) (n_bytes, curr_block, spec[i].fmt_string);
1253 if (spec[i].hexl_mode_trailer)
1255 /* space-pad out to full line width, then dump the trailer */
1256 int datum_width = width_bytes[spec[i].size];
1257 int blank_fields = (bytes_per_block - n_bytes) / datum_width;
1258 int field_width = spec[i].field_width + 1;
1259 printf ("%*s", blank_fields * field_width, "");
1260 dump_hexl_mode_trailer (n_bytes, curr_block);
1268 /* Read a single byte into *C from the concatenation of the input files
1269 named in the global array FILE_LIST. On the first call to this
1270 function, the global variable IN_STREAM is expected to be an open
1271 stream associated with the input file INPUT_FILENAME. If IN_STREAM
1272 is at end-of-file, close it and update the global variables IN_STREAM
1273 and INPUT_FILENAME so they correspond to the next file in the list.
1274 Then try to read a byte from the newly opened file. Repeat if
1275 necessary until EOF is reached for the last file in FILE_LIST, then
1276 set *C to EOF and return. Subsequent calls do likewise. The return
1277 value is nonzero if any errors occured, zero otherwise. */
1286 while (in_stream != NULL) /* EOF. */
1288 *c = fgetc (in_stream);
1293 err |= check_and_close ();
1295 err |= open_next_file ();
1301 /* Read N bytes into BLOCK from the concatenation of the input files
1302 named in the global array FILE_LIST. On the first call to this
1303 function, the global variable IN_STREAM is expected to be an open
1304 stream associated with the input file INPUT_FILENAME. If all N
1305 bytes cannot be read from IN_STREAM, close IN_STREAM and update
1306 the global variables IN_STREAM and INPUT_FILENAME. Then try to
1307 read the remaining bytes from the newly opened file. Repeat if
1308 necessary until EOF is reached for the last file in FILE_LIST.
1309 On subsequent calls, don't modify BLOCK and return zero. Set
1310 *N_BYTES_IN_BUFFER to the number of bytes read. If an error occurs,
1311 it will be detected through ferror when the stream is about to be
1312 closed. If there is an error, give a message but continue reading
1313 as usual and return nonzero. Otherwise return zero. */
1316 read_block (size_t n, char *block, size_t *n_bytes_in_buffer)
1320 assert (0 < n && n <= bytes_per_block);
1322 *n_bytes_in_buffer = 0;
1327 while (in_stream != NULL) /* EOF. */
1332 n_needed = n - *n_bytes_in_buffer;
1333 n_read = fread (block + *n_bytes_in_buffer, 1, n_needed, in_stream);
1335 *n_bytes_in_buffer += n_read;
1337 if (n_read == n_needed)
1340 err |= check_and_close ();
1342 err |= open_next_file ();
1348 /* Return the least common multiple of the sizes associated
1349 with the format specs. */
1357 for (i = 0; i < n_specs; i++)
1358 l_c_m = lcm (l_c_m, width_bytes[(int) spec[i].size]);
1362 /* If S is a valid traditional offset specification with an optional
1363 leading '+' return nonzero and set *OFFSET to the offset it denotes. */
1366 parse_old_offset (const char *s, uintmax_t *offset)
1369 enum strtol_error s_err;
1374 /* Skip over any leading '+'. */
1378 /* Determine the radix we'll use to interpret S. If there is a `.',
1379 it's decimal, otherwise, if the string begins with `0X'or `0x',
1380 it's hexadecimal, else octal. */
1381 if (strchr (s, '.') != NULL)
1385 if (s[0] == '0' && (s[1] == 'x' || s[1] == 'X'))
1391 s_err = xstrtoumax (s, NULL, radix, offset, "Bb");
1392 if (s_err != LONGINT_OK)
1394 STRTOL_FAIL_WARN (s, _("old-style offset"), s_err);
1400 /* Read a chunk of size BYTES_PER_BLOCK from the input files, write the
1401 formatted block to standard output, and repeat until the specified
1402 maximum number of bytes has been read or until all input has been
1403 processed. If the last block read is smaller than BYTES_PER_BLOCK
1404 and its size is not a multiple of the size associated with a format
1405 spec, extend the input block with zero bytes until its length is a
1406 multiple of all format spec sizes. Write the final block. Finally,
1407 write on a line by itself the offset of the byte after the last byte
1408 read. Accumulate return values from calls to read_block and
1409 check_and_close, and if any was nonzero, return nonzero.
1410 Otherwise, return zero. */
1416 uintmax_t current_offset;
1419 size_t n_bytes_read;
1421 block[0] = (char *) alloca (bytes_per_block);
1422 block[1] = (char *) alloca (bytes_per_block);
1424 current_offset = n_bytes_to_skip;
1428 if (limit_bytes_to_format)
1433 if (current_offset >= end_offset)
1438 n_needed = MIN (end_offset - current_offset,
1439 (uintmax_t) bytes_per_block);
1440 err |= read_block (n_needed, block[idx], &n_bytes_read);
1441 if (n_bytes_read < bytes_per_block)
1443 assert (n_bytes_read == bytes_per_block);
1444 write_block (current_offset, n_bytes_read,
1445 block[!idx], block[idx]);
1446 current_offset += n_bytes_read;
1454 err |= read_block (bytes_per_block, block[idx], &n_bytes_read);
1455 if (n_bytes_read < bytes_per_block)
1457 assert (n_bytes_read == bytes_per_block);
1458 write_block (current_offset, n_bytes_read,
1459 block[!idx], block[idx]);
1460 current_offset += n_bytes_read;
1465 if (n_bytes_read > 0)
1468 size_t bytes_to_write;
1472 /* Make bytes_to_write the smallest multiple of l_c_m that
1473 is at least as large as n_bytes_read. */
1474 bytes_to_write = l_c_m * ((n_bytes_read + l_c_m - 1) / l_c_m);
1476 memset (block[idx] + n_bytes_read, 0, bytes_to_write - n_bytes_read);
1477 write_block (current_offset, bytes_to_write,
1478 block[!idx], block[idx]);
1479 current_offset += n_bytes_read;
1482 format_address (current_offset, '\n');
1484 if (limit_bytes_to_format && current_offset >= end_offset)
1485 err |= check_and_close ();
1490 /* STRINGS mode. Find each "string constant" in the input.
1491 A string constant is a run of at least `string_min' ASCII
1492 graphic (or formatting) characters terminated by a null.
1493 Based on a function written by Richard Stallman for a
1494 traditional version of od. Return nonzero if an error
1495 occurs. Otherwise, return zero. */
1500 size_t bufsize = MAX (100, string_min);
1501 char *buf = xmalloc (bufsize);
1502 uintmax_t address = n_bytes_to_skip;
1511 /* See if the next `string_min' chars are all printing chars. */
1514 if (limit_bytes_to_format
1515 && (end_offset < string_min || end_offset - string_min <= address))
1518 for (i = 0; i < string_min; i++)
1520 err |= read_char (&c);
1528 /* Found a non-printing. Try again starting with next char. */
1533 /* We found a run of `string_min' printable characters.
1534 Now see if it is terminated with a null byte. */
1535 while (!limit_bytes_to_format || address < end_offset)
1539 bufsize = 1 + 3 * bufsize / 2;
1540 buf = xrealloc (buf, bufsize);
1542 err |= read_char (&c);
1550 break; /* It is; print this string. */
1552 goto tryline; /* It isn't; give up on this string. */
1553 buf[i++] = c; /* String continues; store it all. */
1556 /* If we get here, the string is all printable and null-terminated,
1557 so print it. It is all in `buf' and `i' is its length. */
1559 format_address (address - i - 1, ' ');
1561 for (i = 0; (c = buf[i]); i++)
1566 fputs ("\\a", stdout);
1570 fputs ("\\b", stdout);
1574 fputs ("\\f", stdout);
1578 fputs ("\\n", stdout);
1582 fputs ("\\r", stdout);
1586 fputs ("\\t", stdout);
1590 fputs ("\\v", stdout);
1600 /* We reach this point only if we search through
1601 (max_bytes_to_format - string_min) bytes before reaching EOF. */
1605 err |= check_and_close ();
1610 main (int argc, char **argv)
1616 size_t desired_width IF_LINT (= 0);
1617 int width_specified = 0;
1618 int n_failed_decodes = 0;
1620 char const *short_options = (posix2_version () < 200112
1621 ? COMMON_SHORT_OPTIONS "s::w::"
1622 : COMMON_SHORT_OPTIONS "s:w:");
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 initialize_main (&argc, &argv);
1629 program_name = argv[0];
1630 setlocale (LC_ALL, "");
1631 bindtextdomain (PACKAGE, LOCALEDIR);
1632 textdomain (PACKAGE);
1634 atexit (close_stdout);
1638 for (i = 0; i <= MAX_INTEGRAL_TYPE_SIZE; i++)
1639 integral_type_size[i] = NO_SIZE;
1641 integral_type_size[sizeof (char)] = CHAR;
1642 integral_type_size[sizeof (short int)] = SHORT;
1643 integral_type_size[sizeof (int)] = INT;
1644 integral_type_size[sizeof (long int)] = LONG;
1645 #if HAVE_UNSIGNED_LONG_LONG
1646 /* If `long' and `long long' have the same size, it's fine
1647 to overwrite the entry for `long' with this one. */
1648 integral_type_size[sizeof (ulonglong_t)] = LONG_LONG;
1651 for (i = 0; i <= MAX_FP_TYPE_SIZE; i++)
1652 fp_type_size[i] = NO_SIZE;
1654 fp_type_size[sizeof (float)] = FLOAT_SINGLE;
1655 /* The array entry for `double' is filled in after that for LONG_DOUBLE
1656 so that if `long double' is the same type or if long double isn't
1657 supported FLOAT_LONG_DOUBLE will never be used. */
1658 fp_type_size[sizeof (LONG_DOUBLE)] = FLOAT_LONG_DOUBLE;
1659 fp_type_size[sizeof (double)] = FLOAT_DOUBLE;
1662 n_specs_allocated = 5;
1663 spec = xmalloc (n_specs_allocated * sizeof (struct tspec));
1665 format_address = format_address_std;
1667 address_pad_len = 7;
1668 flag_dump_strings = 0;
1670 while ((c = getopt_long (argc, argv, short_options, long_options, NULL))
1674 enum strtol_error s_err;
1685 format_address = format_address_std;
1687 address_pad_len = 7;
1690 format_address = format_address_std;
1692 address_pad_len = 7;
1695 format_address = format_address_std;
1697 address_pad_len = 6;
1700 format_address = format_address_none;
1701 address_pad_len = 0;
1704 error (EXIT_FAILURE, 0,
1705 _("invalid output address radix `%c'; \
1706 it must be one character from [doxn]"),
1713 s_err = xstrtoumax (optarg, NULL, 0, &n_bytes_to_skip, "bkm");
1714 if (s_err != LONGINT_OK)
1715 STRTOL_FATAL_ERROR (optarg, _("skip argument"), s_err);
1719 limit_bytes_to_format = 1;
1721 s_err = xstrtoumax (optarg, NULL, 0, &max_bytes_to_format, "bkm");
1722 if (s_err != LONGINT_OK)
1723 STRTOL_FATAL_ERROR (optarg, _("limit argument"), s_err);
1731 s_err = xstrtoumax (optarg, NULL, 0, &tmp, "bkm");
1732 if (s_err != LONGINT_OK)
1733 STRTOL_FATAL_ERROR (optarg, _("minimum string length"), s_err);
1735 /* The minimum string length may be no larger than SIZE_MAX,
1736 since we may allocate a buffer of this size. */
1738 error (EXIT_FAILURE, 0, _("%s is too large"), optarg);
1742 flag_dump_strings = 1;
1746 if (decode_format_string (optarg))
1751 abbreviate_duplicate_blocks = 0;
1754 case TRADITIONAL_OPTION:
1758 /* The next several cases map the traditional format
1759 specification options to the corresponding modern format
1760 specs. GNU od accepts any combination of old- and
1761 new-style options. Format specification options accumulate. */
1763 #define CASE_OLD_ARG(old_char,new_string) \
1766 if (decode_format_string (new_string)) \
1767 ++n_failed_decodes; \
1771 CASE_OLD_ARG ('a', "a");
1772 CASE_OLD_ARG ('b', "oC");
1773 CASE_OLD_ARG ('c', "c");
1774 CASE_OLD_ARG ('d', "u2");
1775 CASE_OLD_ARG ('f', "fF");
1776 CASE_OLD_ARG ('h', "x2");
1777 CASE_OLD_ARG ('i', "d2");
1778 CASE_OLD_ARG ('l', "d4");
1779 CASE_OLD_ARG ('o', "o2");
1780 CASE_OLD_ARG ('x', "x2");
1782 /* FIXME: POSIX 1003.1-2001 with XSI requires this:
1784 CASE_OLD_ARG ('s', "d2");
1786 for the traditional syntax, but this conflicts with case
1792 width_specified = 1;
1800 s_err = xstrtoumax (optarg, NULL, 10, &w_tmp, "");
1801 if (s_err != LONGINT_OK)
1802 STRTOL_FATAL_ERROR (optarg, _("width specification"), s_err);
1803 if (SIZE_MAX < w_tmp)
1804 error (EXIT_FAILURE, 0, _("%s is too large"), optarg);
1805 desired_width = w_tmp;
1809 case_GETOPT_HELP_CHAR;
1811 case_GETOPT_VERSION_CHAR (PROGRAM_NAME, AUTHORS);
1814 usage (EXIT_FAILURE);
1819 if (n_failed_decodes > 0)
1820 exit (EXIT_FAILURE);
1822 if (flag_dump_strings && n_specs > 0)
1823 error (EXIT_FAILURE, 0,
1824 _("no type may be specified when dumping strings"));
1826 n_files = argc - optind;
1828 /* If the --traditional option is used, there may be from
1829 0 to 3 remaining command line arguments; handle each case
1831 od [file] [[+]offset[.][b] [[+]label[.][b]]]
1832 The offset and pseudo_start have the same syntax.
1834 FIXME: POSIX 1003.1-2001 with XSI requires support for the
1835 traditional syntax even if --traditional is not given. */
1843 if (parse_old_offset (argv[optind], &offset))
1845 n_bytes_to_skip = offset;
1850 else if (n_files == 2)
1853 if (parse_old_offset (argv[optind], &o1)
1854 && parse_old_offset (argv[optind + 1], &o2))
1856 n_bytes_to_skip = o1;
1857 flag_pseudo_start = 1;
1862 else if (parse_old_offset (argv[optind + 1], &o2))
1864 n_bytes_to_skip = o2;
1866 argv[optind + 1] = argv[optind];
1872 _("invalid second operand in compatibility mode `%s'"),
1874 usage (EXIT_FAILURE);
1877 else if (n_files == 3)
1880 if (parse_old_offset (argv[optind + 1], &o1)
1881 && parse_old_offset (argv[optind + 2], &o2))
1883 n_bytes_to_skip = o1;
1884 flag_pseudo_start = 1;
1886 argv[optind + 2] = argv[optind];
1893 _("in compatibility mode, the last two arguments must be offsets"));
1894 usage (EXIT_FAILURE);
1897 else if (n_files > 3)
1900 _("compatibility mode supports at most three arguments"));
1901 usage (EXIT_FAILURE);
1904 if (flag_pseudo_start)
1906 if (format_address == format_address_none)
1909 address_pad_len = 7;
1910 format_address = format_address_paren;
1913 format_address = format_address_label;
1917 if (limit_bytes_to_format)
1919 end_offset = n_bytes_to_skip + max_bytes_to_format;
1920 if (end_offset < n_bytes_to_skip)
1921 error (EXIT_FAILURE, 0, _("skip-bytes + read-bytes is too large"));
1926 if (decode_one_format ("o2", "o2", NULL, &(spec[0])))
1928 /* This happens on Cray systems that don't have a 2-byte
1930 exit (EXIT_FAILURE);
1938 /* Set the global pointer FILE_LIST so that it
1939 references the first file-argument on the command-line. */
1941 file_list = (char const *const *) &argv[optind];
1945 /* No files were listed on the command line.
1946 Set the global pointer FILE_LIST so that it
1947 references the null-terminated list of one name: "-". */
1949 file_list = default_file_list;
1952 /* open the first input file */
1953 err |= open_next_file ();
1954 if (in_stream == NULL)
1957 /* skip over any unwanted header bytes */
1958 err |= skip (n_bytes_to_skip);
1959 if (in_stream == NULL)
1962 pseudo_offset = (flag_pseudo_start ? pseudo_start - n_bytes_to_skip : 0);
1964 /* Compute output block length. */
1967 if (width_specified)
1969 if (desired_width != 0 && desired_width % l_c_m == 0)
1970 bytes_per_block = desired_width;
1973 error (0, 0, _("warning: invalid width %lu; using %d instead"),
1974 (unsigned long) desired_width, l_c_m);
1975 bytes_per_block = l_c_m;
1980 if (l_c_m < DEFAULT_BYTES_PER_BLOCK)
1981 bytes_per_block = l_c_m * (DEFAULT_BYTES_PER_BLOCK / l_c_m);
1983 bytes_per_block = l_c_m;
1987 for (i = 0; i < n_specs; i++)
1989 printf (_("%d: fmt=\"%s\" width=%d\n"),
1990 i, spec[i].fmt_string, width_bytes[spec[i].size]);
1994 err |= (flag_dump_strings ? dump_strings () : dump ());
1998 if (have_read_stdin && fclose (stdin) == EOF)
1999 error (EXIT_FAILURE, errno, _("standard input"));
2001 exit (err == 0 ? EXIT_SUCCESS : EXIT_FAILURE);