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>
32 /* The official name of this program (e.g., no `g' prefix). */
33 #define PROGRAM_NAME "od"
35 #define AUTHORS "Jim Meyering"
37 #if defined(__GNUC__) || defined(STDC_HEADERS)
41 #ifdef HAVE_LONG_DOUBLE
42 typedef long double LONG_DOUBLE;
44 typedef double LONG_DOUBLE;
47 /* The default number of input bytes per output line. */
48 #define DEFAULT_BYTES_PER_BLOCK 16
50 /* The number of decimal digits of precision in a float. */
55 /* The number of decimal digits of precision in a double. */
60 /* The number of decimal digits of precision in a long double. */
62 # define LDBL_DIG DBL_DIG
65 #if HAVE_UNSIGNED_LONG_LONG
66 typedef unsigned long long ulonglong_t;
68 /* This is just a place-holder to avoid a few `#if' directives.
69 In this case, the type isn't actually used. */
70 typedef unsigned long int ulonglong_t;
81 /* FIXME: add INTMAX support, too */
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, const char *, const char *);
107 int hexl_mode_trailer;
111 /* The name this program was run with. */
114 /* Convert the number of 8-bit bytes of a binary representation to
115 the number of characters (digits + sign if the type is signed)
116 required to represent the same quantity in the specified base/type.
117 For example, a 32-bit (4-byte) quantity may require a field width
118 as wide as the following for these types:
122 8 unsigned hexadecimal */
124 static const unsigned int bytes_to_oct_digits[] =
125 {0, 3, 6, 8, 11, 14, 16, 19, 22, 25, 27, 30, 32, 35, 38, 41, 43};
127 static const unsigned int bytes_to_signed_dec_digits[] =
128 {1, 4, 6, 8, 11, 13, 16, 18, 20, 23, 25, 28, 30, 33, 35, 37, 40};
130 static const unsigned int bytes_to_unsigned_dec_digits[] =
131 {0, 3, 5, 8, 10, 13, 15, 17, 20, 22, 25, 27, 29, 32, 34, 37, 39};
133 static const unsigned int bytes_to_hex_digits[] =
134 {0, 2, 4, 6, 8, 10, 12, 14, 16, 18, 20, 22, 24, 26, 28, 30, 32};
136 /* Convert enum size_spec to the size of the named type. */
137 static const int width_bytes[] =
144 sizeof (ulonglong_t),
150 /* Ensure that for each member of `enum size_spec' there is an
151 initializer in the width_bytes array. */
154 int assert_width_bytes_matches_size_spec_decl
155 [sizeof width_bytes / sizeof width_bytes[0] == N_SIZE_SPECS ? 1 : -1];
158 /* Names for some non-printing characters. */
159 static const char *const charname[33] =
161 "nul", "soh", "stx", "etx", "eot", "enq", "ack", "bel",
162 "bs", "ht", "nl", "vt", "ff", "cr", "so", "si",
163 "dle", "dc1", "dc2", "dc3", "dc4", "nak", "syn", "etb",
164 "can", "em", "sub", "esc", "fs", "gs", "rs", "us",
168 /* Address base (8, 10 or 16). */
169 static int address_base;
171 /* The number of octal digits required to represent the largest
173 #define MAX_ADDRESS_LENGTH \
174 ((sizeof (uintmax_t) * CHAR_BIT + CHAR_BIT - 1) / 3)
176 /* Width of a normal address. */
177 static int address_pad_len;
179 static size_t string_min;
180 static int flag_dump_strings;
182 /* Non-zero if we should recognize the older non-option arguments
183 that specified at most one file and optional arguments specifying
184 offset and pseudo-start address. */
185 static int traditional;
187 /* Non-zero if an old-style `pseudo-address' was specified. */
188 static int flag_pseudo_start;
190 /* The difference between the old-style pseudo starting address and
191 the number of bytes to skip. */
192 static uintmax_t pseudo_offset;
194 /* Function that accepts an address and an optional following char,
195 and prints the address and char to stdout. */
196 static void (*format_address) (uintmax_t, char);
198 /* The number of input bytes to skip before formatting and writing. */
199 static uintmax_t n_bytes_to_skip = 0;
201 /* When zero, MAX_BYTES_TO_FORMAT and END_OFFSET are ignored, and all
202 input is formatted. */
203 static int limit_bytes_to_format = 0;
205 /* The maximum number of bytes that will be formatted. */
206 static uintmax_t max_bytes_to_format;
208 /* The offset of the first byte after the last byte to be formatted. */
209 static uintmax_t end_offset;
211 /* When nonzero and two or more consecutive blocks are equal, format
212 only the first block and output an asterisk alone on the following
213 line to indicate that identical blocks have been elided. */
214 static int abbreviate_duplicate_blocks = 1;
216 /* An array of specs describing how to format each input block. */
217 static struct tspec *spec;
219 /* The number of format specs. */
220 static size_t n_specs;
222 /* The allocated length of SPEC. */
223 static size_t n_specs_allocated;
225 /* The number of input bytes formatted per output line. It must be
226 a multiple of the least common multiple of the sizes associated with
227 the specified output types. It should be as large as possible, but
228 no larger than 16 -- unless specified with the -w option. */
229 static size_t bytes_per_block;
231 /* Human-readable representation of *file_list (for error messages).
232 It differs from *file_list only when *file_list is "-". */
233 static char const *input_filename;
235 /* A NULL-terminated list of the file-arguments from the command line. */
236 static char const *const *file_list;
238 /* Initializer for file_list if no file-arguments
239 were specified on the command line. */
240 static char const *const default_file_list[] = {"-", NULL};
242 /* The input stream associated with the current file. */
243 static FILE *in_stream;
245 /* If nonzero, at least one of the files we read was standard input. */
246 static int have_read_stdin;
248 #define MAX_INTEGRAL_TYPE_SIZE sizeof (ulonglong_t)
249 static enum size_spec integral_type_size[MAX_INTEGRAL_TYPE_SIZE + 1];
251 #define MAX_FP_TYPE_SIZE sizeof(LONG_DOUBLE)
252 static enum size_spec fp_type_size[MAX_FP_TYPE_SIZE + 1];
254 #define COMMON_SHORT_OPTIONS "A:N:abcdfhij:lot:vx"
256 /* For long options that have no equivalent short option, use a
257 non-character as a pseudo short option, starting with CHAR_MAX + 1. */
260 TRADITIONAL_OPTION = CHAR_MAX + 1
263 static struct option const long_options[] =
265 {"skip-bytes", required_argument, NULL, 'j'},
266 {"address-radix", required_argument, NULL, 'A'},
267 {"read-bytes", required_argument, NULL, 'N'},
268 {"format", required_argument, NULL, 't'},
269 {"output-duplicates", no_argument, NULL, 'v'},
270 {"strings", optional_argument, NULL, 's'},
271 {"traditional", no_argument, NULL, TRADITIONAL_OPTION},
272 {"width", optional_argument, NULL, 'w'},
274 {GETOPT_HELP_OPTION_DECL},
275 {GETOPT_VERSION_OPTION_DECL},
283 fprintf (stderr, _("Try `%s --help' for more information.\n"),
288 Usage: %s [OPTION]... [FILE]...\n\
289 or: %s --traditional [FILE] [[+]OFFSET [[+]LABEL]]\n\
291 program_name, program_name);
293 Write an unambiguous representation, octal bytes by default,\n\
294 of FILE to standard output. With more than one FILE argument,\n\
295 concatenate them in the listed order to form the input.\n\
296 With no FILE, or when FILE is -, read standard input.\n\
300 All arguments to long options are mandatory for short options.\n\
303 -A, --address-radix=RADIX decide how file offsets are printed\n\
304 -j, --skip-bytes=BYTES skip BYTES input bytes first\n\
307 -N, --read-bytes=BYTES limit dump to BYTES input bytes\n\
308 -s, --strings[=BYTES] output strings of at least BYTES graphic chars\n\
309 -t, --format=TYPE select output format or formats\n\
310 -v, --output-duplicates do not use * to mark line suppression\n\
311 -w, --width[=BYTES] output BYTES bytes per output line\n\
312 --traditional accept arguments in traditional form\n\
314 fputs (HELP_OPTION_DESCRIPTION, stdout);
315 fputs (VERSION_OPTION_DESCRIPTION, stdout);
318 Traditional format specifications may be intermixed; they accumulate:\n\
319 -a same as -t a, select named characters\n\
320 -b same as -t oC, select octal bytes\n\
321 -c same as -t c, select ASCII characters or backslash escapes\n\
322 -d same as -t u2, select unsigned decimal shorts\n\
325 -f same as -t fF, select floats\n\
326 -h same as -t x2, select hexadecimal shorts\n\
327 -i same as -t d2, select decimal shorts\n\
328 -l same as -t d4, select decimal longs\n\
329 -o same as -t o2, select octal shorts\n\
330 -x same as -t x2, select hexadecimal shorts\n\
334 For older syntax (second call format), OFFSET means -j OFFSET. LABEL\n\
335 is the pseudo-address at first byte printed, incremented when dump is\n\
336 progressing. For OFFSET and LABEL, a 0x or 0X prefix indicates\n\
337 hexadecimal, suffixes may be . for octal and b for multiply by 512.\n\
339 TYPE is made up of one or more of these specifications:\n\
342 c ASCII character or backslash escape\n\
345 d[SIZE] signed decimal, SIZE bytes per integer\n\
346 f[SIZE] floating point, SIZE bytes per integer\n\
347 o[SIZE] octal, SIZE bytes per integer\n\
348 u[SIZE] unsigned decimal, SIZE bytes per integer\n\
349 x[SIZE] hexadecimal, SIZE bytes per integer\n\
353 SIZE is a number. For TYPE in doux, SIZE may also be C for\n\
354 sizeof(char), S for sizeof(short), I for sizeof(int) or L for\n\
355 sizeof(long). If TYPE is f, SIZE may also be F for sizeof(float), D\n\
356 for sizeof(double) or L for sizeof(long double).\n\
360 RADIX is d for decimal, o for octal, x for hexadecimal or n for none.\n\
361 BYTES is hexadecimal with 0x or 0X prefix, it is multiplied by 512\n\
362 with b suffix, by 1024 with k and by 1048576 with m. Adding a z suffix to\n\
363 any type adds a display of printable characters to the end of each line\n\
367 --string without a number implies 3. --width without a number\n\
368 implies 32. By default, od uses -A o -t d2 -w 16.\n\
370 printf (_("\nReport bugs to <%s>.\n"), PACKAGE_BUGREPORT);
372 exit (status == 0 ? EXIT_SUCCESS : EXIT_FAILURE);
375 /* Compute the greatest common denominator of U and V
376 using Euclid's algorithm. */
379 gcd (unsigned int u, unsigned int v)
391 /* Compute the least common multiple of U and V. */
394 lcm (unsigned int u, unsigned int v)
396 unsigned int t = gcd (u, v);
403 print_s_char (size_t n_bytes, const char *block, const char *fmt_string)
406 for (i = n_bytes; i > 0; i--)
408 int tmp = (unsigned) *(const unsigned char *) block;
410 tmp -= SCHAR_MAX - SCHAR_MIN + 1;
411 assert (tmp <= SCHAR_MAX);
412 printf (fmt_string, tmp);
413 block += sizeof (unsigned char);
418 print_char (size_t n_bytes, const char *block, const char *fmt_string)
421 for (i = n_bytes; i > 0; i--)
423 unsigned int tmp = *(const unsigned char *) block;
424 printf (fmt_string, tmp);
425 block += sizeof (unsigned char);
430 print_s_short (size_t n_bytes, const char *block, const char *fmt_string)
433 for (i = n_bytes / sizeof (unsigned short); i > 0; i--)
435 int tmp = (unsigned) *(const unsigned short *) block;
437 tmp -= SHRT_MAX - SHRT_MIN + 1;
438 assert (tmp <= SHRT_MAX);
439 printf (fmt_string, tmp);
440 block += sizeof (unsigned short);
445 print_short (size_t n_bytes, const char *block, const char *fmt_string)
448 for (i = n_bytes / sizeof (unsigned short); i > 0; i--)
450 unsigned int tmp = *(const unsigned short *) block;
451 printf (fmt_string, tmp);
452 block += sizeof (unsigned short);
457 print_int (size_t n_bytes, const char *block, const char *fmt_string)
460 for (i = n_bytes / sizeof (unsigned int); i > 0; i--)
462 unsigned int tmp = *(const unsigned int *) block;
463 printf (fmt_string, tmp);
464 block += sizeof (unsigned int);
469 print_long (size_t n_bytes, const char *block, const char *fmt_string)
472 for (i = n_bytes / sizeof (unsigned long); i > 0; i--)
474 unsigned long tmp = *(const unsigned long *) block;
475 printf (fmt_string, tmp);
476 block += sizeof (unsigned long);
481 print_long_long (size_t n_bytes, const char *block, const char *fmt_string)
484 for (i = n_bytes / sizeof (ulonglong_t); i > 0; i--)
486 ulonglong_t tmp = *(const ulonglong_t *) block;
487 printf (fmt_string, tmp);
488 block += sizeof (ulonglong_t);
493 print_float (size_t n_bytes, const char *block, const char *fmt_string)
496 for (i = n_bytes / sizeof (float); i > 0; i--)
498 float tmp = *(const float *) block;
499 printf (fmt_string, tmp);
500 block += sizeof (float);
505 print_double (size_t n_bytes, const char *block, const char *fmt_string)
508 for (i = n_bytes / sizeof (double); i > 0; i--)
510 double tmp = *(const double *) block;
511 printf (fmt_string, tmp);
512 block += sizeof (double);
516 #ifdef HAVE_LONG_DOUBLE
518 print_long_double (size_t n_bytes, const char *block, const char *fmt_string)
521 for (i = n_bytes / sizeof (LONG_DOUBLE); i > 0; i--)
523 LONG_DOUBLE tmp = *(const LONG_DOUBLE *) block;
524 printf (fmt_string, tmp);
525 block += sizeof (LONG_DOUBLE);
532 dump_hexl_mode_trailer (size_t n_bytes, const char *block)
535 fputs (" >", stdout);
536 for (i = n_bytes; i > 0; i--)
538 unsigned int c = *(const unsigned char *) block;
539 unsigned int c2 = (ISPRINT(c) ? c : '.');
541 block += sizeof (unsigned char);
547 print_named_ascii (size_t n_bytes, const char *block,
548 const char *unused_fmt_string ATTRIBUTE_UNUSED)
551 for (i = n_bytes; i > 0; i--)
553 unsigned int c = *(const unsigned char *) block;
554 unsigned int masked_c = (0x7f & c);
560 else if (masked_c <= 040)
561 s = charname[masked_c];
564 sprintf (buf, " %c", masked_c);
569 block += sizeof (unsigned char);
574 print_ascii (size_t n_bytes, const char *block,
575 const char *unused_fmt_string ATTRIBUTE_UNUSED)
578 for (i = n_bytes; i > 0; i--)
580 unsigned int c = *(const unsigned char *) block;
619 sprintf (buf, (ISPRINT (c) ? " %c" : "%03o"), c);
620 s = (const char *) buf;
624 block += sizeof (unsigned char);
628 /* Convert a null-terminated (possibly zero-length) string S to an
629 unsigned long integer value. If S points to a non-digit set *P to S,
630 *VAL to 0, and return 0. Otherwise, accumulate the integer value of
631 the string of digits. If the string of digits represents a value
632 larger than ULONG_MAX, don't modify *VAL or *P and return nonzero.
633 Otherwise, advance *P to the first non-digit after S, set *VAL to
634 the result of the conversion and return zero. */
637 simple_strtoul (const char *s, const char **p, long unsigned int *val)
639 unsigned long int sum;
644 unsigned int c = *s++ - '0';
645 if (sum > (ULONG_MAX - c) / 10)
654 /* If S points to a single valid modern od format string, put
655 a description of that format in *TSPEC, make *NEXT point at the
656 character following the just-decoded format (if *NEXT is non-NULL),
657 and return zero. If S is not valid, don't modify *NEXT or *TSPEC,
658 give a diagnostic, and return nonzero. For example, if S were
659 "d4afL" *NEXT would be set to "afL" and *TSPEC would be
661 fmt = SIGNED_DECIMAL;
662 size = INT or LONG; (whichever integral_type_size[4] resolves to)
663 print_function = print_int; (assuming size == INT)
664 fmt_string = "%011d%c";
666 S_ORIG is solely for reporting errors. It should be the full format
671 decode_one_format (const char *s_orig, const char *s, const char **next,
674 enum size_spec size_spec;
675 unsigned long int size;
676 enum output_format fmt;
677 const char *pre_fmt_string;
679 void (*print_function) (size_t, const char *, const char *);
682 unsigned int field_width = 0;
684 assert (tspec != NULL);
698 size = sizeof (char);
703 size = sizeof (short);
713 size = sizeof (long int);
717 if (simple_strtoul (s, &p, &size) != 0)
719 /* The integer at P in S would overflow an unsigned long.
720 A digit string that long is sufficiently odd looking
721 that the following diagnostic is sufficient. */
722 error (0, 0, _("invalid type string `%s'"), s_orig);
729 if (MAX_INTEGRAL_TYPE_SIZE < size
730 || integral_type_size[size] == NO_SIZE)
732 error (0, 0, _("invalid type string `%s';\n\
733 this system doesn't provide a %lu-byte integral type"), s_orig, size);
741 #define ISPEC_TO_FORMAT(Spec, Min_format, Long_format, Max_format) \
742 ((Spec) == LONG_LONG ? (Max_format) \
743 : ((Spec) == LONG ? (Long_format) \
746 #define FMT_BYTES_ALLOCATED 9
747 fmt_string = xmalloc (FMT_BYTES_ALLOCATED);
749 size_spec = integral_type_size[size];
754 fmt = SIGNED_DECIMAL;
755 sprintf (fmt_string, " %%%u%s",
756 (field_width = bytes_to_signed_dec_digits[size]),
757 ISPEC_TO_FORMAT (size_spec, "d", "ld", PRIdMAX));
762 sprintf (fmt_string, " %%0%u%s",
763 (field_width = bytes_to_oct_digits[size]),
764 ISPEC_TO_FORMAT (size_spec, "o", "lo", PRIoMAX));
768 fmt = UNSIGNED_DECIMAL;
769 sprintf (fmt_string, " %%%u%s",
770 (field_width = bytes_to_unsigned_dec_digits[size]),
771 ISPEC_TO_FORMAT (size_spec, "u", "lu", PRIuMAX));
776 sprintf (fmt_string, " %%0%u%s",
777 (field_width = bytes_to_hex_digits[size]),
778 ISPEC_TO_FORMAT (size_spec, "x", "lx", PRIxMAX));
785 assert (strlen (fmt_string) < FMT_BYTES_ALLOCATED);
790 print_function = (fmt == SIGNED_DECIMAL
796 print_function = (fmt == SIGNED_DECIMAL
802 print_function = print_int;
806 print_function = print_long;
810 print_function = print_long_long;
819 fmt = FLOATING_POINT;
825 size = sizeof (float);
830 size = sizeof (double);
835 size = sizeof (LONG_DOUBLE);
839 if (simple_strtoul (s, &p, &size) != 0)
841 /* The integer at P in S would overflow an unsigned long.
842 A digit string that long is sufficiently odd looking
843 that the following diagnostic is sufficient. */
844 error (0, 0, _("invalid type string `%s'"), s_orig);
848 size = sizeof (double);
851 if (size > MAX_FP_TYPE_SIZE
852 || fp_type_size[size] == NO_SIZE)
854 error (0, 0, _("invalid type string `%s';\n\
855 this system doesn't provide a %lu-byte floating point type"), s_orig, size);
862 size_spec = fp_type_size[size];
867 print_function = print_float;
868 /* Don't use %#e; not all systems support it. */
869 pre_fmt_string = " %%%d.%de";
870 fmt_string = xmalloc (strlen (pre_fmt_string));
871 sprintf (fmt_string, pre_fmt_string,
872 (field_width = FLT_DIG + 8), FLT_DIG);
876 print_function = print_double;
877 pre_fmt_string = " %%%d.%de";
878 fmt_string = xmalloc (strlen (pre_fmt_string));
879 sprintf (fmt_string, pre_fmt_string,
880 (field_width = DBL_DIG + 8), DBL_DIG);
883 #ifdef HAVE_LONG_DOUBLE
884 case FLOAT_LONG_DOUBLE:
885 print_function = print_long_double;
886 pre_fmt_string = " %%%d.%dLe";
887 fmt_string = xmalloc (strlen (pre_fmt_string));
888 sprintf (fmt_string, pre_fmt_string,
889 (field_width = LDBL_DIG + 8), LDBL_DIG);
900 fmt = NAMED_CHARACTER;
903 print_function = print_named_ascii;
912 print_function = print_ascii;
917 error (0, 0, _("invalid character `%c' in type string `%s'"),
922 tspec->size = size_spec;
924 tspec->print_function = print_function;
925 tspec->fmt_string = fmt_string;
927 tspec->field_width = field_width;
928 tspec->hexl_mode_trailer = (*s == 'z');
929 if (tspec->hexl_mode_trailer)
938 /* Given a list of one or more input filenames FILE_LIST, set the global
939 file pointer IN_STREAM and the global string INPUT_FILENAME to the
940 first one that can be successfully opened. Modify FILE_LIST to
941 reference the next filename in the list. A file name of "-" is
942 interpreted as standard input. If any file open fails, give an error
943 message and return nonzero. */
946 open_next_file (void)
952 input_filename = *file_list;
953 if (input_filename == NULL)
957 if (STREQ (input_filename, "-"))
959 input_filename = _("standard input");
965 in_stream = fopen (input_filename, "r");
966 if (in_stream == NULL)
968 error (0, errno, "%s", input_filename);
973 while (in_stream == NULL);
975 if (limit_bytes_to_format && !flag_dump_strings)
976 SETVBUF (in_stream, NULL, _IONBF, 0);
977 SET_BINARY (fileno (in_stream));
982 /* Test whether there have been errors on in_stream, and close it if
983 it is not standard input. Return nonzero if there has been an error
984 on in_stream or stdout; return zero otherwise. This function will
985 report more than one error only if both a read and a write error
989 check_and_close (void)
993 if (in_stream != NULL)
995 if (ferror (in_stream))
997 error (0, errno, "%s", input_filename);
998 if (in_stream != stdin)
1002 else if (in_stream != stdin && fclose (in_stream) == EOF)
1004 error (0, errno, "%s", input_filename);
1011 if (ferror (stdout))
1013 error (0, errno, _("standard output"));
1020 /* Decode the modern od format string S. Append the decoded
1021 representation to the global array SPEC, reallocating SPEC if
1022 necessary. Return zero if S is valid, nonzero otherwise. */
1025 decode_format_string (const char *s)
1027 const char *s_orig = s;
1035 if (decode_one_format (s_orig, s, &next, &tspec))
1041 if (n_specs >= n_specs_allocated)
1043 n_specs_allocated = 1 + (3 * n_specs_allocated) / 2;
1044 spec = xrealloc (spec, (n_specs_allocated * sizeof (struct tspec)));
1047 memcpy ((char *) &spec[n_specs], (char *) &tspec,
1048 sizeof (struct tspec));
1055 /* Given a list of one or more input filenames FILE_LIST, set the global
1056 file pointer IN_STREAM to position N_SKIP in the concatenation of
1057 those files. If any file operation fails or if there are fewer than
1058 N_SKIP bytes in the combined input, give an error message and return
1059 nonzero. When possible, use seek rather than read operations to
1060 advance IN_STREAM. */
1063 skip (uintmax_t n_skip)
1070 while (in_stream != NULL) /* EOF. */
1072 struct stat file_stats;
1074 /* First try seeking. For large offsets, this extra work is
1075 worthwhile. If the offset is below some threshold it may be
1076 more efficient to move the pointer by reading. There are two
1077 issues when trying to seek:
1078 - the file must be seekable.
1079 - before seeking to the specified position, make sure
1080 that the new position is in the current file.
1081 Try to do that by getting file's size using fstat.
1082 But that will work only for regular files. */
1084 if (fstat (fileno (in_stream), &file_stats) == 0)
1086 /* The st_size field is valid only for regular files
1087 (and for symbolic links, which cannot occur here).
1088 If the number of bytes left to skip is at least
1089 as large as the size of the current file, we can
1090 decrement n_skip and go on to the next file. */
1092 if (S_ISREG (file_stats.st_mode) && 0 <= file_stats.st_size)
1094 if ((uintmax_t) file_stats.st_size <= n_skip)
1095 n_skip -= file_stats.st_size;
1098 if (fseeko (in_stream, n_skip, SEEK_CUR) != 0)
1100 error (0, errno, "%s", input_filename);
1107 /* If it's not a regular file with nonnegative size,
1108 position the file pointer by reading. */
1113 size_t n_bytes_read, n_bytes_to_read = BUFSIZ;
1117 if (n_skip < n_bytes_to_read)
1118 n_bytes_to_read = n_skip;
1119 n_bytes_read = fread (buf, 1, n_bytes_to_read, in_stream);
1120 n_skip -= n_bytes_read;
1121 if (n_bytes_read != n_bytes_to_read)
1130 else /* cannot fstat() file */
1132 error (0, errno, "%s", input_filename);
1136 err |= check_and_close ();
1138 err |= open_next_file ();
1142 error (EXIT_FAILURE, 0, _("cannot skip past end of combined input"));
1148 format_address_none (uintmax_t address ATTRIBUTE_UNUSED, char c ATTRIBUTE_UNUSED)
1153 format_address_std (uintmax_t address, char c)
1155 char buf[MAX_ADDRESS_LENGTH + 2];
1156 char *p = buf + sizeof buf;
1161 pbound = p - address_pad_len;
1163 /* Use a special case of the code for each base. This is measurably
1164 faster than generic code. */
1165 switch (address_base)
1169 *--p = '0' + (address & 7);
1170 while ((address >>= 3) != 0);
1175 *--p = '0' + (address % 10);
1176 while ((address /= 10) != 0);
1181 *--p = "0123456789abcdef"[address & 15];
1182 while ((address >>= 4) != 0);
1193 format_address_paren (uintmax_t address, char c)
1196 format_address_std (address, ')');
1201 format_address_label (uintmax_t address, char c)
1203 format_address_std (address, ' ');
1204 format_address_paren (address + pseudo_offset, c);
1207 /* Write N_BYTES bytes from CURR_BLOCK to standard output once for each
1208 of the N_SPEC format specs. CURRENT_OFFSET is the byte address of
1209 CURR_BLOCK in the concatenation of input files, and it is printed
1210 (optionally) only before the output line associated with the first
1211 format spec. When duplicate blocks are being abbreviated, the output
1212 for a sequence of identical input blocks is the output for the first
1213 block followed by an asterisk alone on a line. It is valid to compare
1214 the blocks PREV_BLOCK and CURR_BLOCK only when N_BYTES == BYTES_PER_BLOCK.
1215 That condition may be false only for the last input block -- and then
1216 only when it has not been padded to length BYTES_PER_BLOCK. */
1219 write_block (uintmax_t current_offset, size_t n_bytes,
1220 const char *prev_block, const char *curr_block)
1222 static int first = 1;
1223 static int prev_pair_equal = 0;
1225 #define EQUAL_BLOCKS(b1, b2) (memcmp ((b1), (b2), bytes_per_block) == 0)
1227 if (abbreviate_duplicate_blocks
1228 && !first && n_bytes == bytes_per_block
1229 && EQUAL_BLOCKS (prev_block, curr_block))
1231 if (prev_pair_equal)
1233 /* The two preceding blocks were equal, and the current
1234 block is the same as the last one, so print nothing. */
1239 prev_pair_equal = 1;
1246 prev_pair_equal = 0;
1247 for (i = 0; i < n_specs; i++)
1250 format_address (current_offset, '\0');
1252 printf ("%*s", address_pad_len, "");
1253 (*spec[i].print_function) (n_bytes, curr_block, spec[i].fmt_string);
1254 if (spec[i].hexl_mode_trailer)
1256 /* space-pad out to full line width, then dump the trailer */
1257 int datum_width = width_bytes[spec[i].size];
1258 int blank_fields = (bytes_per_block - n_bytes) / datum_width;
1259 int field_width = spec[i].field_width + 1;
1260 printf ("%*s", blank_fields * field_width, "");
1261 dump_hexl_mode_trailer (n_bytes, curr_block);
1269 /* Read a single byte into *C from the concatenation of the input files
1270 named in the global array FILE_LIST. On the first call to this
1271 function, the global variable IN_STREAM is expected to be an open
1272 stream associated with the input file INPUT_FILENAME. If IN_STREAM
1273 is at end-of-file, close it and update the global variables IN_STREAM
1274 and INPUT_FILENAME so they correspond to the next file in the list.
1275 Then try to read a byte from the newly opened file. Repeat if
1276 necessary until EOF is reached for the last file in FILE_LIST, then
1277 set *C to EOF and return. Subsequent calls do likewise. The return
1278 value is nonzero if any errors occured, zero otherwise. */
1287 while (in_stream != NULL) /* EOF. */
1289 *c = fgetc (in_stream);
1294 err |= check_and_close ();
1296 err |= open_next_file ();
1302 /* Read N bytes into BLOCK from the concatenation of the input files
1303 named in the global array FILE_LIST. On the first call to this
1304 function, the global variable IN_STREAM is expected to be an open
1305 stream associated with the input file INPUT_FILENAME. If all N
1306 bytes cannot be read from IN_STREAM, close IN_STREAM and update
1307 the global variables IN_STREAM and INPUT_FILENAME. Then try to
1308 read the remaining bytes from the newly opened file. Repeat if
1309 necessary until EOF is reached for the last file in FILE_LIST.
1310 On subsequent calls, don't modify BLOCK and return zero. Set
1311 *N_BYTES_IN_BUFFER to the number of bytes read. If an error occurs,
1312 it will be detected through ferror when the stream is about to be
1313 closed. If there is an error, give a message but continue reading
1314 as usual and return nonzero. Otherwise return zero. */
1317 read_block (size_t n, char *block, size_t *n_bytes_in_buffer)
1321 assert (0 < n && n <= bytes_per_block);
1323 *n_bytes_in_buffer = 0;
1328 while (in_stream != NULL) /* EOF. */
1333 n_needed = n - *n_bytes_in_buffer;
1334 n_read = fread (block + *n_bytes_in_buffer, 1, n_needed, in_stream);
1336 *n_bytes_in_buffer += n_read;
1338 if (n_read == n_needed)
1341 err |= check_and_close ();
1343 err |= open_next_file ();
1349 /* Return the least common multiple of the sizes associated
1350 with the format specs. */
1358 for (i = 0; i < n_specs; i++)
1359 l_c_m = lcm (l_c_m, width_bytes[(int) spec[i].size]);
1363 /* If S is a valid traditional offset specification with an optional
1364 leading '+' return nonzero and set *OFFSET to the offset it denotes. */
1367 parse_old_offset (const char *s, uintmax_t *offset)
1370 enum strtol_error s_err;
1375 /* Skip over any leading '+'. */
1379 /* Determine the radix we'll use to interpret S. If there is a `.',
1380 it's decimal, otherwise, if the string begins with `0X'or `0x',
1381 it's hexadecimal, else octal. */
1382 if (strchr (s, '.') != NULL)
1386 if (s[0] == '0' && (s[1] == 'x' || s[1] == 'X'))
1392 s_err = xstrtoumax (s, NULL, radix, offset, "Bb");
1393 if (s_err != LONGINT_OK)
1395 STRTOL_FAIL_WARN (s, _("old-style offset"), s_err);
1401 /* Read a chunk of size BYTES_PER_BLOCK from the input files, write the
1402 formatted block to standard output, and repeat until the specified
1403 maximum number of bytes has been read or until all input has been
1404 processed. If the last block read is smaller than BYTES_PER_BLOCK
1405 and its size is not a multiple of the size associated with a format
1406 spec, extend the input block with zero bytes until its length is a
1407 multiple of all format spec sizes. Write the final block. Finally,
1408 write on a line by itself the offset of the byte after the last byte
1409 read. Accumulate return values from calls to read_block and
1410 check_and_close, and if any was nonzero, return nonzero.
1411 Otherwise, return zero. */
1417 uintmax_t current_offset;
1420 size_t n_bytes_read;
1422 block[0] = (char *) alloca (bytes_per_block);
1423 block[1] = (char *) alloca (bytes_per_block);
1425 current_offset = n_bytes_to_skip;
1429 if (limit_bytes_to_format)
1434 if (current_offset >= end_offset)
1439 n_needed = MIN (end_offset - current_offset,
1440 (uintmax_t) bytes_per_block);
1441 err |= read_block (n_needed, block[idx], &n_bytes_read);
1442 if (n_bytes_read < bytes_per_block)
1444 assert (n_bytes_read == bytes_per_block);
1445 write_block (current_offset, n_bytes_read,
1446 block[!idx], block[idx]);
1447 current_offset += n_bytes_read;
1455 err |= read_block (bytes_per_block, block[idx], &n_bytes_read);
1456 if (n_bytes_read < bytes_per_block)
1458 assert (n_bytes_read == bytes_per_block);
1459 write_block (current_offset, n_bytes_read,
1460 block[!idx], block[idx]);
1461 current_offset += n_bytes_read;
1466 if (n_bytes_read > 0)
1469 size_t bytes_to_write;
1473 /* Make bytes_to_write the smallest multiple of l_c_m that
1474 is at least as large as n_bytes_read. */
1475 bytes_to_write = l_c_m * ((n_bytes_read + l_c_m - 1) / l_c_m);
1477 memset (block[idx] + n_bytes_read, 0, bytes_to_write - n_bytes_read);
1478 write_block (current_offset, bytes_to_write,
1479 block[!idx], block[idx]);
1480 current_offset += n_bytes_read;
1483 format_address (current_offset, '\n');
1485 if (limit_bytes_to_format && current_offset >= end_offset)
1486 err |= check_and_close ();
1491 /* STRINGS mode. Find each "string constant" in the input.
1492 A string constant is a run of at least `string_min' ASCII
1493 graphic (or formatting) characters terminated by a null.
1494 Based on a function written by Richard Stallman for a
1495 traditional version of od. Return nonzero if an error
1496 occurs. Otherwise, return zero. */
1501 size_t bufsize = MAX (100, string_min);
1502 char *buf = xmalloc (bufsize);
1503 uintmax_t address = n_bytes_to_skip;
1512 /* See if the next `string_min' chars are all printing chars. */
1515 if (limit_bytes_to_format
1516 && (end_offset < string_min || end_offset - string_min <= address))
1519 for (i = 0; i < string_min; i++)
1521 err |= read_char (&c);
1529 /* Found a non-printing. Try again starting with next char. */
1534 /* We found a run of `string_min' printable characters.
1535 Now see if it is terminated with a null byte. */
1536 while (!limit_bytes_to_format || address < end_offset)
1540 bufsize = 1 + 3 * bufsize / 2;
1541 buf = xrealloc (buf, bufsize);
1543 err |= read_char (&c);
1551 break; /* It is; print this string. */
1553 goto tryline; /* It isn't; give up on this string. */
1554 buf[i++] = c; /* String continues; store it all. */
1557 /* If we get here, the string is all printable and null-terminated,
1558 so print it. It is all in `buf' and `i' is its length. */
1560 format_address (address - i - 1, ' ');
1562 for (i = 0; (c = buf[i]); i++)
1567 fputs ("\\a", stdout);
1571 fputs ("\\b", stdout);
1575 fputs ("\\f", stdout);
1579 fputs ("\\n", stdout);
1583 fputs ("\\r", stdout);
1587 fputs ("\\t", stdout);
1591 fputs ("\\v", stdout);
1601 /* We reach this point only if we search through
1602 (max_bytes_to_format - string_min) bytes before reaching EOF. */
1606 err |= check_and_close ();
1611 main (int argc, char **argv)
1617 size_t desired_width IF_LINT (= 0);
1618 int width_specified = 0;
1619 int n_failed_decodes = 0;
1621 char const *short_options = (posix2_version () < 200112
1622 ? COMMON_SHORT_OPTIONS "s::w::"
1623 : COMMON_SHORT_OPTIONS "s:w:");
1625 /* The old-style `pseudo starting address' to be printed in parentheses
1626 after any true address. */
1627 uintmax_t pseudo_start IF_LINT (= 0);
1629 initialize_main (&argc, &argv);
1630 program_name = argv[0];
1631 setlocale (LC_ALL, "");
1632 bindtextdomain (PACKAGE, LOCALEDIR);
1633 textdomain (PACKAGE);
1635 atexit (close_stdout);
1639 for (i = 0; i <= MAX_INTEGRAL_TYPE_SIZE; i++)
1640 integral_type_size[i] = NO_SIZE;
1642 integral_type_size[sizeof (char)] = CHAR;
1643 integral_type_size[sizeof (short int)] = SHORT;
1644 integral_type_size[sizeof (int)] = INT;
1645 integral_type_size[sizeof (long int)] = LONG;
1646 #if HAVE_UNSIGNED_LONG_LONG
1647 /* If `long' and `long long' have the same size, it's fine
1648 to overwrite the entry for `long' with this one. */
1649 integral_type_size[sizeof (ulonglong_t)] = LONG_LONG;
1652 for (i = 0; i <= MAX_FP_TYPE_SIZE; i++)
1653 fp_type_size[i] = NO_SIZE;
1655 fp_type_size[sizeof (float)] = FLOAT_SINGLE;
1656 /* The array entry for `double' is filled in after that for LONG_DOUBLE
1657 so that if `long double' is the same type or if long double isn't
1658 supported FLOAT_LONG_DOUBLE will never be used. */
1659 fp_type_size[sizeof (LONG_DOUBLE)] = FLOAT_LONG_DOUBLE;
1660 fp_type_size[sizeof (double)] = FLOAT_DOUBLE;
1663 n_specs_allocated = 5;
1664 spec = xmalloc (n_specs_allocated * sizeof (struct tspec));
1666 format_address = format_address_std;
1668 address_pad_len = 7;
1669 flag_dump_strings = 0;
1671 while ((c = getopt_long (argc, argv, short_options, long_options, NULL))
1675 enum strtol_error s_err;
1686 format_address = format_address_std;
1688 address_pad_len = 7;
1691 format_address = format_address_std;
1693 address_pad_len = 7;
1696 format_address = format_address_std;
1698 address_pad_len = 6;
1701 format_address = format_address_none;
1702 address_pad_len = 0;
1705 error (EXIT_FAILURE, 0,
1706 _("invalid output address radix `%c'; \
1707 it must be one character from [doxn]"),
1714 s_err = xstrtoumax (optarg, NULL, 0, &n_bytes_to_skip, "bkm");
1715 if (s_err != LONGINT_OK)
1716 STRTOL_FATAL_ERROR (optarg, _("skip argument"), s_err);
1720 limit_bytes_to_format = 1;
1722 s_err = xstrtoumax (optarg, NULL, 0, &max_bytes_to_format, "bkm");
1723 if (s_err != LONGINT_OK)
1724 STRTOL_FATAL_ERROR (optarg, _("limit argument"), s_err);
1732 s_err = xstrtoumax (optarg, NULL, 0, &tmp, "bkm");
1733 if (s_err != LONGINT_OK)
1734 STRTOL_FATAL_ERROR (optarg, _("minimum string length"), s_err);
1736 /* The minimum string length may be no larger than SIZE_MAX,
1737 since we may allocate a buffer of this size. */
1739 error (EXIT_FAILURE, 0, _("%s is too large"), optarg);
1743 flag_dump_strings = 1;
1747 if (decode_format_string (optarg))
1752 abbreviate_duplicate_blocks = 0;
1755 case TRADITIONAL_OPTION:
1759 /* The next several cases map the traditional format
1760 specification options to the corresponding modern format
1761 specs. GNU od accepts any combination of old- and
1762 new-style options. Format specification options accumulate. */
1764 #define CASE_OLD_ARG(old_char,new_string) \
1767 if (decode_format_string (new_string)) \
1768 ++n_failed_decodes; \
1772 CASE_OLD_ARG ('a', "a");
1773 CASE_OLD_ARG ('b', "oC");
1774 CASE_OLD_ARG ('c', "c");
1775 CASE_OLD_ARG ('d', "u2");
1776 CASE_OLD_ARG ('f', "fF");
1777 CASE_OLD_ARG ('h', "x2");
1778 CASE_OLD_ARG ('i', "d2");
1779 CASE_OLD_ARG ('l', "d4");
1780 CASE_OLD_ARG ('o', "o2");
1781 CASE_OLD_ARG ('x', "x2");
1783 /* FIXME: POSIX 1003.1-2001 with XSI requires this:
1785 CASE_OLD_ARG ('s', "d2");
1787 for the traditional syntax, but this conflicts with case
1793 width_specified = 1;
1801 s_err = xstrtoumax (optarg, NULL, 10, &w_tmp, "");
1802 if (s_err != LONGINT_OK)
1803 STRTOL_FATAL_ERROR (optarg, _("width specification"), s_err);
1804 if (SIZE_MAX < w_tmp)
1805 error (EXIT_FAILURE, 0, _("%s is too large"), optarg);
1806 desired_width = w_tmp;
1810 case_GETOPT_HELP_CHAR;
1812 case_GETOPT_VERSION_CHAR (PROGRAM_NAME, AUTHORS);
1815 usage (EXIT_FAILURE);
1820 if (n_failed_decodes > 0)
1821 exit (EXIT_FAILURE);
1823 if (flag_dump_strings && n_specs > 0)
1824 error (EXIT_FAILURE, 0,
1825 _("no type may be specified when dumping strings"));
1827 n_files = argc - optind;
1829 /* If the --traditional option is used, there may be from
1830 0 to 3 remaining command line arguments; handle each case
1832 od [file] [[+]offset[.][b] [[+]label[.][b]]]
1833 The offset and pseudo_start have the same syntax.
1835 FIXME: POSIX 1003.1-2001 with XSI requires support for the
1836 traditional syntax even if --traditional is not given. */
1844 if (parse_old_offset (argv[optind], &offset))
1846 n_bytes_to_skip = offset;
1851 else if (n_files == 2)
1854 if (parse_old_offset (argv[optind], &o1)
1855 && parse_old_offset (argv[optind + 1], &o2))
1857 n_bytes_to_skip = o1;
1858 flag_pseudo_start = 1;
1863 else if (parse_old_offset (argv[optind + 1], &o2))
1865 n_bytes_to_skip = o2;
1867 argv[optind + 1] = argv[optind];
1873 _("invalid second operand in compatibility mode `%s'"),
1875 usage (EXIT_FAILURE);
1878 else if (n_files == 3)
1881 if (parse_old_offset (argv[optind + 1], &o1)
1882 && parse_old_offset (argv[optind + 2], &o2))
1884 n_bytes_to_skip = o1;
1885 flag_pseudo_start = 1;
1887 argv[optind + 2] = argv[optind];
1894 _("in compatibility mode, the last two arguments must be offsets"));
1895 usage (EXIT_FAILURE);
1898 else if (n_files > 3)
1901 _("compatibility mode supports at most three arguments"));
1902 usage (EXIT_FAILURE);
1905 if (flag_pseudo_start)
1907 if (format_address == format_address_none)
1910 address_pad_len = 7;
1911 format_address = format_address_paren;
1914 format_address = format_address_label;
1918 if (limit_bytes_to_format)
1920 end_offset = n_bytes_to_skip + max_bytes_to_format;
1921 if (end_offset < n_bytes_to_skip)
1922 error (EXIT_FAILURE, 0, "skip-bytes + read-bytes is too large");
1927 if (decode_one_format ("o2", "o2", NULL, &(spec[0])))
1929 /* This happens on Cray systems that don't have a 2-byte
1931 exit (EXIT_FAILURE);
1939 /* Set the global pointer FILE_LIST so that it
1940 references the first file-argument on the command-line. */
1942 file_list = (char const *const *) &argv[optind];
1946 /* No files were listed on the command line.
1947 Set the global pointer FILE_LIST so that it
1948 references the null-terminated list of one name: "-". */
1950 file_list = default_file_list;
1953 /* open the first input file */
1954 err |= open_next_file ();
1955 if (in_stream == NULL)
1958 /* skip over any unwanted header bytes */
1959 err |= skip (n_bytes_to_skip);
1960 if (in_stream == NULL)
1963 pseudo_offset = (flag_pseudo_start ? pseudo_start - n_bytes_to_skip : 0);
1965 /* Compute output block length. */
1968 if (width_specified)
1970 if (desired_width != 0 && desired_width % l_c_m == 0)
1971 bytes_per_block = desired_width;
1974 error (0, 0, _("warning: invalid width %lu; using %d instead"),
1975 (unsigned long) desired_width, l_c_m);
1976 bytes_per_block = l_c_m;
1981 if (l_c_m < DEFAULT_BYTES_PER_BLOCK)
1982 bytes_per_block = l_c_m * (DEFAULT_BYTES_PER_BLOCK / l_c_m);
1984 bytes_per_block = l_c_m;
1988 for (i = 0; i < n_specs; i++)
1990 printf (_("%d: fmt=\"%s\" width=%d\n"),
1991 i, spec[i].fmt_string, width_bytes[spec[i].size]);
1995 err |= (flag_dump_strings ? dump_strings () : dump ());
1999 if (have_read_stdin && fclose (stdin) == EOF)
2000 error (EXIT_FAILURE, errno, _("standard input"));
2002 exit (err == 0 ? EXIT_SUCCESS : EXIT_FAILURE);