1 /* od -- dump files in octal and other formats
2 Copyright (C) 92, 1995-2004 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},
282 if (status != EXIT_SUCCESS)
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);
376 print_s_char (size_t n_bytes, const char *block, const char *fmt_string)
379 for (i = n_bytes; i > 0; i--)
381 int tmp = (unsigned) *(const unsigned char *) block;
383 tmp -= SCHAR_MAX - SCHAR_MIN + 1;
384 assert (tmp <= SCHAR_MAX);
385 printf (fmt_string, tmp);
386 block += sizeof (unsigned char);
391 print_char (size_t n_bytes, const char *block, const char *fmt_string)
394 for (i = n_bytes; i > 0; i--)
396 unsigned int tmp = *(const unsigned char *) block;
397 printf (fmt_string, tmp);
398 block += sizeof (unsigned char);
403 print_s_short (size_t n_bytes, const char *block, const char *fmt_string)
406 for (i = n_bytes / sizeof (unsigned short); i > 0; i--)
408 int tmp = (unsigned) *(const unsigned short *) block;
410 tmp -= SHRT_MAX - SHRT_MIN + 1;
411 assert (tmp <= SHRT_MAX);
412 printf (fmt_string, tmp);
413 block += sizeof (unsigned short);
418 print_short (size_t n_bytes, const char *block, const char *fmt_string)
421 for (i = n_bytes / sizeof (unsigned short); i > 0; i--)
423 unsigned int tmp = *(const unsigned short *) block;
424 printf (fmt_string, tmp);
425 block += sizeof (unsigned short);
430 print_int (size_t n_bytes, const char *block, const char *fmt_string)
433 for (i = n_bytes / sizeof (unsigned int); i > 0; i--)
435 unsigned int tmp = *(const unsigned int *) block;
436 printf (fmt_string, tmp);
437 block += sizeof (unsigned int);
442 print_long (size_t n_bytes, const char *block, const char *fmt_string)
445 for (i = n_bytes / sizeof (unsigned long); i > 0; i--)
447 unsigned long tmp = *(const unsigned long *) block;
448 printf (fmt_string, tmp);
449 block += sizeof (unsigned long);
454 print_long_long (size_t n_bytes, const char *block, const char *fmt_string)
457 for (i = n_bytes / sizeof (ulonglong_t); i > 0; i--)
459 ulonglong_t tmp = *(const ulonglong_t *) block;
460 printf (fmt_string, tmp);
461 block += sizeof (ulonglong_t);
466 print_float (size_t n_bytes, const char *block, const char *fmt_string)
469 for (i = n_bytes / sizeof (float); i > 0; i--)
471 float tmp = *(const float *) block;
472 printf (fmt_string, tmp);
473 block += sizeof (float);
478 print_double (size_t n_bytes, const char *block, const char *fmt_string)
481 for (i = n_bytes / sizeof (double); i > 0; i--)
483 double tmp = *(const double *) block;
484 printf (fmt_string, tmp);
485 block += sizeof (double);
489 #ifdef HAVE_LONG_DOUBLE
491 print_long_double (size_t n_bytes, const char *block, const char *fmt_string)
494 for (i = n_bytes / sizeof (LONG_DOUBLE); i > 0; i--)
496 LONG_DOUBLE tmp = *(const LONG_DOUBLE *) block;
497 printf (fmt_string, tmp);
498 block += sizeof (LONG_DOUBLE);
505 dump_hexl_mode_trailer (size_t n_bytes, const char *block)
508 fputs (" >", stdout);
509 for (i = n_bytes; i > 0; i--)
511 unsigned int c = *(const unsigned char *) block;
512 unsigned int c2 = (ISPRINT(c) ? c : '.');
514 block += sizeof (unsigned char);
520 print_named_ascii (size_t n_bytes, const char *block,
521 const char *unused_fmt_string ATTRIBUTE_UNUSED)
524 for (i = n_bytes; i > 0; i--)
526 unsigned int c = *(const unsigned char *) block;
527 unsigned int masked_c = (0x7f & c);
533 else if (masked_c <= 040)
534 s = charname[masked_c];
537 sprintf (buf, " %c", masked_c);
542 block += sizeof (unsigned char);
547 print_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;
592 sprintf (buf, (ISPRINT (c) ? " %c" : "%03o"), c);
593 s = (const char *) buf;
597 block += sizeof (unsigned char);
601 /* Convert a null-terminated (possibly zero-length) string S to an
602 unsigned long integer value. If S points to a non-digit set *P to S,
603 *VAL to 0, and return 0. Otherwise, accumulate the integer value of
604 the string of digits. If the string of digits represents a value
605 larger than ULONG_MAX, don't modify *VAL or *P and return nonzero.
606 Otherwise, advance *P to the first non-digit after S, set *VAL to
607 the result of the conversion and return zero. */
610 simple_strtoul (const char *s, const char **p, long unsigned int *val)
612 unsigned long int sum;
617 unsigned int c = *s++ - '0';
618 if (sum > (ULONG_MAX - c) / 10)
627 /* If S points to a single valid modern od format string, put
628 a description of that format in *TSPEC, make *NEXT point at the
629 character following the just-decoded format (if *NEXT is non-NULL),
630 and return zero. If S is not valid, don't modify *NEXT or *TSPEC,
631 give a diagnostic, and return nonzero. For example, if S were
632 "d4afL" *NEXT would be set to "afL" and *TSPEC would be
634 fmt = SIGNED_DECIMAL;
635 size = INT or LONG; (whichever integral_type_size[4] resolves to)
636 print_function = print_int; (assuming size == INT)
637 fmt_string = "%011d%c";
639 S_ORIG is solely for reporting errors. It should be the full format
644 decode_one_format (const char *s_orig, const char *s, const char **next,
647 enum size_spec size_spec;
648 unsigned long int size;
649 enum output_format fmt;
650 const char *pre_fmt_string;
652 void (*print_function) (size_t, const char *, const char *);
655 unsigned int field_width = 0;
657 assert (tspec != NULL);
671 size = sizeof (char);
676 size = sizeof (short);
686 size = sizeof (long int);
690 if (simple_strtoul (s, &p, &size) != 0)
692 /* The integer at P in S would overflow an unsigned long.
693 A digit string that long is sufficiently odd looking
694 that the following diagnostic is sufficient. */
695 error (0, 0, _("invalid type string `%s'"), s_orig);
702 if (MAX_INTEGRAL_TYPE_SIZE < size
703 || integral_type_size[size] == NO_SIZE)
705 error (0, 0, _("invalid type string `%s';\n\
706 this system doesn't provide a %lu-byte integral type"), s_orig, size);
714 #define ISPEC_TO_FORMAT(Spec, Min_format, Long_format, Max_format) \
715 ((Spec) == LONG_LONG ? (Max_format) \
716 : ((Spec) == LONG ? (Long_format) \
719 #define FMT_BYTES_ALLOCATED 9
720 fmt_string = xmalloc (FMT_BYTES_ALLOCATED);
722 size_spec = integral_type_size[size];
727 fmt = SIGNED_DECIMAL;
728 sprintf (fmt_string, " %%%u%s",
729 (field_width = bytes_to_signed_dec_digits[size]),
730 ISPEC_TO_FORMAT (size_spec, "d", "ld", PRIdMAX));
735 sprintf (fmt_string, " %%0%u%s",
736 (field_width = bytes_to_oct_digits[size]),
737 ISPEC_TO_FORMAT (size_spec, "o", "lo", PRIoMAX));
741 fmt = UNSIGNED_DECIMAL;
742 sprintf (fmt_string, " %%%u%s",
743 (field_width = bytes_to_unsigned_dec_digits[size]),
744 ISPEC_TO_FORMAT (size_spec, "u", "lu", PRIuMAX));
749 sprintf (fmt_string, " %%0%u%s",
750 (field_width = bytes_to_hex_digits[size]),
751 ISPEC_TO_FORMAT (size_spec, "x", "lx", PRIxMAX));
758 assert (strlen (fmt_string) < FMT_BYTES_ALLOCATED);
763 print_function = (fmt == SIGNED_DECIMAL
769 print_function = (fmt == SIGNED_DECIMAL
775 print_function = print_int;
779 print_function = print_long;
783 print_function = print_long_long;
792 fmt = FLOATING_POINT;
798 size = sizeof (float);
803 size = sizeof (double);
808 size = sizeof (LONG_DOUBLE);
812 if (simple_strtoul (s, &p, &size) != 0)
814 /* The integer at P in S would overflow an unsigned long.
815 A digit string that long is sufficiently odd looking
816 that the following diagnostic is sufficient. */
817 error (0, 0, _("invalid type string `%s'"), s_orig);
821 size = sizeof (double);
824 if (size > MAX_FP_TYPE_SIZE
825 || fp_type_size[size] == NO_SIZE)
827 error (0, 0, _("invalid type string `%s';\n\
828 this system doesn't provide a %lu-byte floating point type"), s_orig, size);
835 size_spec = fp_type_size[size];
840 print_function = print_float;
841 /* Don't use %#e; not all systems support it. */
842 pre_fmt_string = " %%%d.%de";
843 fmt_string = xmalloc (strlen (pre_fmt_string));
844 sprintf (fmt_string, pre_fmt_string,
845 (field_width = FLT_DIG + 8), FLT_DIG);
849 print_function = print_double;
850 pre_fmt_string = " %%%d.%de";
851 fmt_string = xmalloc (strlen (pre_fmt_string));
852 sprintf (fmt_string, pre_fmt_string,
853 (field_width = DBL_DIG + 8), DBL_DIG);
856 #ifdef HAVE_LONG_DOUBLE
857 case FLOAT_LONG_DOUBLE:
858 print_function = print_long_double;
859 pre_fmt_string = " %%%d.%dLe";
860 fmt_string = xmalloc (strlen (pre_fmt_string));
861 sprintf (fmt_string, pre_fmt_string,
862 (field_width = LDBL_DIG + 8), LDBL_DIG);
873 fmt = NAMED_CHARACTER;
876 print_function = print_named_ascii;
885 print_function = print_ascii;
890 error (0, 0, _("invalid character `%c' in type string `%s'"),
895 tspec->size = size_spec;
897 tspec->print_function = print_function;
898 tspec->fmt_string = fmt_string;
900 tspec->field_width = field_width;
901 tspec->hexl_mode_trailer = (*s == 'z');
902 if (tspec->hexl_mode_trailer)
911 /* Given a list of one or more input filenames FILE_LIST, set the global
912 file pointer IN_STREAM and the global string INPUT_FILENAME to the
913 first one that can be successfully opened. Modify FILE_LIST to
914 reference the next filename in the list. A file name of "-" is
915 interpreted as standard input. If any file open fails, give an error
916 message and return nonzero. */
919 open_next_file (void)
925 input_filename = *file_list;
926 if (input_filename == NULL)
930 if (STREQ (input_filename, "-"))
932 input_filename = _("standard input");
938 in_stream = fopen (input_filename, "r");
939 if (in_stream == NULL)
941 error (0, errno, "%s", input_filename);
946 while (in_stream == NULL);
948 if (limit_bytes_to_format && !flag_dump_strings)
949 SETVBUF (in_stream, NULL, _IONBF, 0);
950 SET_BINARY (fileno (in_stream));
955 /* Test whether there have been errors on in_stream, and close it if
956 it is not standard input. Return nonzero if there has been an error
957 on in_stream or stdout; return zero otherwise. This function will
958 report more than one error only if both a read and a write error
959 have occurred. IN_ERRNO, if nonzero, is the error number
960 corresponding to the most recent action for IN_STREAM. */
963 check_and_close (int in_errno)
967 if (in_stream != NULL)
969 if (ferror (in_stream))
971 error (0, in_errno, _("%s: read error"), input_filename);
972 if (in_stream != stdin)
976 else if (in_stream != stdin && fclose (in_stream) == EOF)
978 error (0, errno, "%s", input_filename);
987 error (0, 0, _("write error"));
994 /* Decode the modern od format string S. Append the decoded
995 representation to the global array SPEC, reallocating SPEC if
996 necessary. Return zero if S is valid, nonzero otherwise. */
999 decode_format_string (const char *s)
1001 const char *s_orig = s;
1009 if (decode_one_format (s_orig, s, &next, &tspec))
1015 if (n_specs_allocated <= n_specs)
1016 spec = x2nrealloc (spec, &n_specs_allocated, sizeof *spec);
1018 memcpy (&spec[n_specs], &tspec, sizeof *spec);
1025 /* Given a list of one or more input filenames FILE_LIST, set the global
1026 file pointer IN_STREAM to position N_SKIP in the concatenation of
1027 those files. If any file operation fails or if there are fewer than
1028 N_SKIP bytes in the combined input, give an error message and return
1029 nonzero. When possible, use seek rather than read operations to
1030 advance IN_STREAM. */
1033 skip (uintmax_t n_skip)
1041 while (in_stream != NULL) /* EOF. */
1043 struct stat file_stats;
1045 /* First try seeking. For large offsets, this extra work is
1046 worthwhile. If the offset is below some threshold it may be
1047 more efficient to move the pointer by reading. There are two
1048 issues when trying to seek:
1049 - the file must be seekable.
1050 - before seeking to the specified position, make sure
1051 that the new position is in the current file.
1052 Try to do that by getting file's size using fstat.
1053 But that will work only for regular files. */
1055 if (fstat (fileno (in_stream), &file_stats) == 0)
1057 /* The st_size field is valid only for regular files
1058 (and for symbolic links, which cannot occur here).
1059 If the number of bytes left to skip is at least
1060 as large as the size of the current file, we can
1061 decrement n_skip and go on to the next file. */
1063 if (S_ISREG (file_stats.st_mode) && 0 <= file_stats.st_size)
1065 if ((uintmax_t) file_stats.st_size <= n_skip)
1066 n_skip -= file_stats.st_size;
1069 if (fseeko (in_stream, n_skip, SEEK_CUR) != 0)
1078 /* If it's not a regular file with nonnegative size,
1079 position the file pointer by reading. */
1084 size_t n_bytes_read, n_bytes_to_read = BUFSIZ;
1088 if (n_skip < n_bytes_to_read)
1089 n_bytes_to_read = n_skip;
1090 n_bytes_read = fread (buf, 1, n_bytes_to_read, in_stream);
1091 n_skip -= n_bytes_read;
1092 if (n_bytes_read != n_bytes_to_read)
1106 else /* cannot fstat() file */
1108 error (0, errno, "%s", input_filename);
1112 err |= check_and_close (in_errno);
1114 err |= open_next_file ();
1118 error (EXIT_FAILURE, 0, _("cannot skip past end of combined input"));
1124 format_address_none (uintmax_t address ATTRIBUTE_UNUSED, char c ATTRIBUTE_UNUSED)
1129 format_address_std (uintmax_t address, char c)
1131 char buf[MAX_ADDRESS_LENGTH + 2];
1132 char *p = buf + sizeof buf;
1137 pbound = p - address_pad_len;
1139 /* Use a special case of the code for each base. This is measurably
1140 faster than generic code. */
1141 switch (address_base)
1145 *--p = '0' + (address & 7);
1146 while ((address >>= 3) != 0);
1151 *--p = '0' + (address % 10);
1152 while ((address /= 10) != 0);
1157 *--p = "0123456789abcdef"[address & 15];
1158 while ((address >>= 4) != 0);
1169 format_address_paren (uintmax_t address, char c)
1172 format_address_std (address, ')');
1177 format_address_label (uintmax_t address, char c)
1179 format_address_std (address, ' ');
1180 format_address_paren (address + pseudo_offset, c);
1183 /* Write N_BYTES bytes from CURR_BLOCK to standard output once for each
1184 of the N_SPEC format specs. CURRENT_OFFSET is the byte address of
1185 CURR_BLOCK in the concatenation of input files, and it is printed
1186 (optionally) only before the output line associated with the first
1187 format spec. When duplicate blocks are being abbreviated, the output
1188 for a sequence of identical input blocks is the output for the first
1189 block followed by an asterisk alone on a line. It is valid to compare
1190 the blocks PREV_BLOCK and CURR_BLOCK only when N_BYTES == BYTES_PER_BLOCK.
1191 That condition may be false only for the last input block -- and then
1192 only when it has not been padded to length BYTES_PER_BLOCK. */
1195 write_block (uintmax_t current_offset, size_t n_bytes,
1196 const char *prev_block, const char *curr_block)
1198 static int first = 1;
1199 static int prev_pair_equal = 0;
1201 #define EQUAL_BLOCKS(b1, b2) (memcmp ((b1), (b2), bytes_per_block) == 0)
1203 if (abbreviate_duplicate_blocks
1204 && !first && n_bytes == bytes_per_block
1205 && EQUAL_BLOCKS (prev_block, curr_block))
1207 if (prev_pair_equal)
1209 /* The two preceding blocks were equal, and the current
1210 block is the same as the last one, so print nothing. */
1215 prev_pair_equal = 1;
1222 prev_pair_equal = 0;
1223 for (i = 0; i < n_specs; i++)
1226 format_address (current_offset, '\0');
1228 printf ("%*s", address_pad_len, "");
1229 (*spec[i].print_function) (n_bytes, curr_block, spec[i].fmt_string);
1230 if (spec[i].hexl_mode_trailer)
1232 /* space-pad out to full line width, then dump the trailer */
1233 int datum_width = width_bytes[spec[i].size];
1234 int blank_fields = (bytes_per_block - n_bytes) / datum_width;
1235 int field_width = spec[i].field_width + 1;
1236 printf ("%*s", blank_fields * field_width, "");
1237 dump_hexl_mode_trailer (n_bytes, curr_block);
1245 /* Read a single byte into *C from the concatenation of the input files
1246 named in the global array FILE_LIST. On the first call to this
1247 function, the global variable IN_STREAM is expected to be an open
1248 stream associated with the input file INPUT_FILENAME. If IN_STREAM
1249 is at end-of-file, close it and update the global variables IN_STREAM
1250 and INPUT_FILENAME so they correspond to the next file in the list.
1251 Then try to read a byte from the newly opened file. Repeat if
1252 necessary until EOF is reached for the last file in FILE_LIST, then
1253 set *C to EOF and return. Subsequent calls do likewise. The return
1254 value is nonzero if any errors occured, zero otherwise. */
1263 while (in_stream != NULL) /* EOF. */
1265 *c = fgetc (in_stream);
1270 err |= check_and_close (errno);
1272 err |= open_next_file ();
1278 /* Read N bytes into BLOCK from the concatenation of the input files
1279 named in the global array FILE_LIST. On the first call to this
1280 function, the global variable IN_STREAM is expected to be an open
1281 stream associated with the input file INPUT_FILENAME. If all N
1282 bytes cannot be read from IN_STREAM, close IN_STREAM and update
1283 the global variables IN_STREAM and INPUT_FILENAME. Then try to
1284 read the remaining bytes from the newly opened file. Repeat if
1285 necessary until EOF is reached for the last file in FILE_LIST.
1286 On subsequent calls, don't modify BLOCK and return zero. Set
1287 *N_BYTES_IN_BUFFER to the number of bytes read. If an error occurs,
1288 it will be detected through ferror when the stream is about to be
1289 closed. If there is an error, give a message but continue reading
1290 as usual and return nonzero. Otherwise return zero. */
1293 read_block (size_t n, char *block, size_t *n_bytes_in_buffer)
1297 assert (0 < n && n <= bytes_per_block);
1299 *n_bytes_in_buffer = 0;
1304 while (in_stream != NULL) /* EOF. */
1309 n_needed = n - *n_bytes_in_buffer;
1310 n_read = fread (block + *n_bytes_in_buffer, 1, n_needed, in_stream);
1312 *n_bytes_in_buffer += n_read;
1314 if (n_read == n_needed)
1317 err |= check_and_close (errno);
1319 err |= open_next_file ();
1325 /* Return the least common multiple of the sizes associated
1326 with the format specs. */
1334 for (i = 0; i < n_specs; i++)
1335 l_c_m = lcm (l_c_m, width_bytes[(int) spec[i].size]);
1339 /* If S is a valid traditional offset specification with an optional
1340 leading '+' return nonzero and set *OFFSET to the offset it denotes. */
1343 parse_old_offset (const char *s, uintmax_t *offset)
1346 enum strtol_error s_err;
1351 /* Skip over any leading '+'. */
1355 /* Determine the radix we'll use to interpret S. If there is a `.',
1356 it's decimal, otherwise, if the string begins with `0X'or `0x',
1357 it's hexadecimal, else octal. */
1358 if (strchr (s, '.') != NULL)
1362 if (s[0] == '0' && (s[1] == 'x' || s[1] == 'X'))
1368 s_err = xstrtoumax (s, NULL, radix, offset, "Bb");
1369 if (s_err != LONGINT_OK)
1371 STRTOL_FAIL_WARN (s, _("old-style offset"), s_err);
1377 /* Read a chunk of size BYTES_PER_BLOCK from the input files, write the
1378 formatted block to standard output, and repeat until the specified
1379 maximum number of bytes has been read or until all input has been
1380 processed. If the last block read is smaller than BYTES_PER_BLOCK
1381 and its size is not a multiple of the size associated with a format
1382 spec, extend the input block with zero bytes until its length is a
1383 multiple of all format spec sizes. Write the final block. Finally,
1384 write on a line by itself the offset of the byte after the last byte
1385 read. Accumulate return values from calls to read_block and
1386 check_and_close, and if any was nonzero, return nonzero.
1387 Otherwise, return zero. */
1393 uintmax_t current_offset;
1396 size_t n_bytes_read;
1398 block[0] = xnmalloc (2, bytes_per_block);
1399 block[1] = block[0] + bytes_per_block;
1401 current_offset = n_bytes_to_skip;
1405 if (limit_bytes_to_format)
1410 if (current_offset >= end_offset)
1415 n_needed = MIN (end_offset - current_offset,
1416 (uintmax_t) bytes_per_block);
1417 err |= read_block (n_needed, block[idx], &n_bytes_read);
1418 if (n_bytes_read < bytes_per_block)
1420 assert (n_bytes_read == bytes_per_block);
1421 write_block (current_offset, n_bytes_read,
1422 block[!idx], block[idx]);
1423 current_offset += n_bytes_read;
1431 err |= read_block (bytes_per_block, block[idx], &n_bytes_read);
1432 if (n_bytes_read < bytes_per_block)
1434 assert (n_bytes_read == bytes_per_block);
1435 write_block (current_offset, n_bytes_read,
1436 block[!idx], block[idx]);
1437 current_offset += n_bytes_read;
1442 if (n_bytes_read > 0)
1445 size_t bytes_to_write;
1449 /* Make bytes_to_write the smallest multiple of l_c_m that
1450 is at least as large as n_bytes_read. */
1451 bytes_to_write = l_c_m * ((n_bytes_read + l_c_m - 1) / l_c_m);
1453 memset (block[idx] + n_bytes_read, 0, bytes_to_write - n_bytes_read);
1454 write_block (current_offset, bytes_to_write,
1455 block[!idx], block[idx]);
1456 current_offset += n_bytes_read;
1459 format_address (current_offset, '\n');
1461 if (limit_bytes_to_format && current_offset >= end_offset)
1462 err |= check_and_close (0);
1469 /* STRINGS mode. Find each "string constant" in the input.
1470 A string constant is a run of at least `string_min' ASCII
1471 graphic (or formatting) characters terminated by a null.
1472 Based on a function written by Richard Stallman for a
1473 traditional version of od. Return nonzero if an error
1474 occurs. Otherwise, return zero. */
1479 size_t bufsize = MAX (100, string_min);
1480 char *buf = xmalloc (bufsize);
1481 uintmax_t address = n_bytes_to_skip;
1490 /* See if the next `string_min' chars are all printing chars. */
1493 if (limit_bytes_to_format
1494 && (end_offset < string_min || end_offset - string_min <= address))
1497 for (i = 0; i < string_min; i++)
1499 err |= read_char (&c);
1507 /* Found a non-printing. Try again starting with next char. */
1512 /* We found a run of `string_min' printable characters.
1513 Now see if it is terminated with a null byte. */
1514 while (!limit_bytes_to_format || address < end_offset)
1518 buf = x2nrealloc (buf, &bufsize, sizeof *buf);
1520 err |= read_char (&c);
1528 break; /* It is; print this string. */
1530 goto tryline; /* It isn't; give up on this string. */
1531 buf[i++] = c; /* String continues; store it all. */
1534 /* If we get here, the string is all printable and null-terminated,
1535 so print it. It is all in `buf' and `i' is its length. */
1537 format_address (address - i - 1, ' ');
1539 for (i = 0; (c = buf[i]); i++)
1544 fputs ("\\a", stdout);
1548 fputs ("\\b", stdout);
1552 fputs ("\\f", stdout);
1556 fputs ("\\n", stdout);
1560 fputs ("\\r", stdout);
1564 fputs ("\\t", stdout);
1568 fputs ("\\v", stdout);
1578 /* We reach this point only if we search through
1579 (max_bytes_to_format - string_min) bytes before reaching EOF. */
1583 err |= check_and_close (0);
1588 main (int argc, char **argv)
1594 size_t desired_width IF_LINT (= 0);
1595 int width_specified = 0;
1596 int n_failed_decodes = 0;
1598 char const *short_options = (posix2_version () < 200112
1599 ? COMMON_SHORT_OPTIONS "s::w::"
1600 : COMMON_SHORT_OPTIONS "s:w:");
1602 /* The old-style `pseudo starting address' to be printed in parentheses
1603 after any true address. */
1604 uintmax_t pseudo_start IF_LINT (= 0);
1606 initialize_main (&argc, &argv);
1607 program_name = argv[0];
1608 setlocale (LC_ALL, "");
1609 bindtextdomain (PACKAGE, LOCALEDIR);
1610 textdomain (PACKAGE);
1612 atexit (close_stdout);
1616 for (i = 0; i <= MAX_INTEGRAL_TYPE_SIZE; i++)
1617 integral_type_size[i] = NO_SIZE;
1619 integral_type_size[sizeof (char)] = CHAR;
1620 integral_type_size[sizeof (short int)] = SHORT;
1621 integral_type_size[sizeof (int)] = INT;
1622 integral_type_size[sizeof (long int)] = LONG;
1623 #if HAVE_UNSIGNED_LONG_LONG
1624 /* If `long' and `long long' have the same size, it's fine
1625 to overwrite the entry for `long' with this one. */
1626 integral_type_size[sizeof (ulonglong_t)] = LONG_LONG;
1629 for (i = 0; i <= MAX_FP_TYPE_SIZE; i++)
1630 fp_type_size[i] = NO_SIZE;
1632 fp_type_size[sizeof (float)] = FLOAT_SINGLE;
1633 /* The array entry for `double' is filled in after that for LONG_DOUBLE
1634 so that if `long double' is the same type or if long double isn't
1635 supported FLOAT_LONG_DOUBLE will never be used. */
1636 fp_type_size[sizeof (LONG_DOUBLE)] = FLOAT_LONG_DOUBLE;
1637 fp_type_size[sizeof (double)] = FLOAT_DOUBLE;
1640 n_specs_allocated = 0;
1643 format_address = format_address_std;
1645 address_pad_len = 7;
1646 flag_dump_strings = 0;
1648 while ((c = getopt_long (argc, argv, short_options, long_options, NULL))
1652 enum strtol_error s_err;
1663 format_address = format_address_std;
1665 address_pad_len = 7;
1668 format_address = format_address_std;
1670 address_pad_len = 7;
1673 format_address = format_address_std;
1675 address_pad_len = 6;
1678 format_address = format_address_none;
1679 address_pad_len = 0;
1682 error (EXIT_FAILURE, 0,
1683 _("invalid output address radix `%c'; \
1684 it must be one character from [doxn]"),
1691 s_err = xstrtoumax (optarg, NULL, 0, &n_bytes_to_skip, "bkm");
1692 if (s_err != LONGINT_OK)
1693 STRTOL_FATAL_ERROR (optarg, _("skip argument"), s_err);
1697 limit_bytes_to_format = 1;
1699 s_err = xstrtoumax (optarg, NULL, 0, &max_bytes_to_format, "bkm");
1700 if (s_err != LONGINT_OK)
1701 STRTOL_FATAL_ERROR (optarg, _("limit argument"), s_err);
1709 s_err = xstrtoumax (optarg, NULL, 0, &tmp, "bkm");
1710 if (s_err != LONGINT_OK)
1711 STRTOL_FATAL_ERROR (optarg, _("minimum string length"), s_err);
1713 /* The minimum string length may be no larger than SIZE_MAX,
1714 since we may allocate a buffer of this size. */
1716 error (EXIT_FAILURE, 0, _("%s is too large"), optarg);
1720 flag_dump_strings = 1;
1724 if (decode_format_string (optarg))
1729 abbreviate_duplicate_blocks = 0;
1732 case TRADITIONAL_OPTION:
1736 /* The next several cases map the traditional format
1737 specification options to the corresponding modern format
1738 specs. GNU od accepts any combination of old- and
1739 new-style options. Format specification options accumulate. */
1741 #define CASE_OLD_ARG(old_char,new_string) \
1744 if (decode_format_string (new_string)) \
1745 ++n_failed_decodes; \
1749 CASE_OLD_ARG ('a', "a");
1750 CASE_OLD_ARG ('b', "oC");
1751 CASE_OLD_ARG ('c', "c");
1752 CASE_OLD_ARG ('d', "u2");
1753 CASE_OLD_ARG ('f', "fF");
1754 CASE_OLD_ARG ('h', "x2");
1755 CASE_OLD_ARG ('i', "d2");
1756 CASE_OLD_ARG ('l', "d4");
1757 CASE_OLD_ARG ('o', "o2");
1758 CASE_OLD_ARG ('x', "x2");
1760 /* FIXME: POSIX 1003.1-2001 with XSI requires this:
1762 CASE_OLD_ARG ('s', "d2");
1764 for the traditional syntax, but this conflicts with case
1770 width_specified = 1;
1778 s_err = xstrtoumax (optarg, NULL, 10, &w_tmp, "");
1779 if (s_err != LONGINT_OK)
1780 STRTOL_FATAL_ERROR (optarg, _("width specification"), s_err);
1781 if (SIZE_MAX < w_tmp)
1782 error (EXIT_FAILURE, 0, _("%s is too large"), optarg);
1783 desired_width = w_tmp;
1787 case_GETOPT_HELP_CHAR;
1789 case_GETOPT_VERSION_CHAR (PROGRAM_NAME, AUTHORS);
1792 usage (EXIT_FAILURE);
1797 if (n_failed_decodes > 0)
1798 exit (EXIT_FAILURE);
1800 if (flag_dump_strings && n_specs > 0)
1801 error (EXIT_FAILURE, 0,
1802 _("no type may be specified when dumping strings"));
1804 n_files = argc - optind;
1806 /* If the --traditional option is used, there may be from
1807 0 to 3 remaining command line arguments; handle each case
1809 od [file] [[+]offset[.][b] [[+]label[.][b]]]
1810 The offset and pseudo_start have the same syntax.
1812 FIXME: POSIX 1003.1-2001 with XSI requires support for the
1813 traditional syntax even if --traditional is not given. */
1821 if (parse_old_offset (argv[optind], &offset))
1823 n_bytes_to_skip = offset;
1828 else if (n_files == 2)
1831 if (parse_old_offset (argv[optind], &o1)
1832 && parse_old_offset (argv[optind + 1], &o2))
1834 n_bytes_to_skip = o1;
1835 flag_pseudo_start = 1;
1840 else if (parse_old_offset (argv[optind + 1], &o2))
1842 n_bytes_to_skip = o2;
1844 argv[optind + 1] = argv[optind];
1850 _("invalid second operand in compatibility mode `%s'"),
1852 usage (EXIT_FAILURE);
1855 else if (n_files == 3)
1858 if (parse_old_offset (argv[optind + 1], &o1)
1859 && parse_old_offset (argv[optind + 2], &o2))
1861 n_bytes_to_skip = o1;
1862 flag_pseudo_start = 1;
1864 argv[optind + 2] = argv[optind];
1871 _("in compatibility mode, the last two arguments must be offsets"));
1872 usage (EXIT_FAILURE);
1875 else if (n_files > 3)
1877 error (0, 0, _("extra operand %s"), quote (argv[optind + 3]));
1878 fprintf (stderr, "%s\n",
1879 _("Compatibility mode supports at most three operands."));
1880 usage (EXIT_FAILURE);
1883 if (flag_pseudo_start)
1885 if (format_address == format_address_none)
1888 address_pad_len = 7;
1889 format_address = format_address_paren;
1892 format_address = format_address_label;
1896 if (limit_bytes_to_format)
1898 end_offset = n_bytes_to_skip + max_bytes_to_format;
1899 if (end_offset < n_bytes_to_skip)
1900 error (EXIT_FAILURE, 0, _("skip-bytes + read-bytes is too large"));
1905 if (decode_format_string ("o2"))
1907 /* This happens on Cray systems that don't have a 2-byte
1909 exit (EXIT_FAILURE);
1917 /* Set the global pointer FILE_LIST so that it
1918 references the first file-argument on the command-line. */
1920 file_list = (char const *const *) &argv[optind];
1924 /* No files were listed on the command line.
1925 Set the global pointer FILE_LIST so that it
1926 references the null-terminated list of one name: "-". */
1928 file_list = default_file_list;
1931 /* open the first input file */
1932 err |= open_next_file ();
1933 if (in_stream == NULL)
1936 /* skip over any unwanted header bytes */
1937 err |= skip (n_bytes_to_skip);
1938 if (in_stream == NULL)
1941 pseudo_offset = (flag_pseudo_start ? pseudo_start - n_bytes_to_skip : 0);
1943 /* Compute output block length. */
1946 if (width_specified)
1948 if (desired_width != 0 && desired_width % l_c_m == 0)
1949 bytes_per_block = desired_width;
1952 error (0, 0, _("warning: invalid width %lu; using %d instead"),
1953 (unsigned long) desired_width, l_c_m);
1954 bytes_per_block = l_c_m;
1959 if (l_c_m < DEFAULT_BYTES_PER_BLOCK)
1960 bytes_per_block = l_c_m * (DEFAULT_BYTES_PER_BLOCK / l_c_m);
1962 bytes_per_block = l_c_m;
1966 for (i = 0; i < n_specs; i++)
1968 printf (_("%d: fmt=\"%s\" width=%d\n"),
1969 i, spec[i].fmt_string, width_bytes[spec[i].size]);
1973 err |= (flag_dump_strings ? dump_strings () : dump ());
1977 if (have_read_stdin && fclose (stdin) == EOF)
1978 error (EXIT_FAILURE, errno, _("standard input"));
1980 exit (err == 0 ? EXIT_SUCCESS : EXIT_FAILURE);