1 /* od -- dump files in octal and other formats
2 Copyright (C) 92, 1995-2002 Free Software Foundation, Inc.
4 This program is free software; you can redistribute it and/or modify
5 it under the terms of the GNU General Public License as published by
6 the Free Software Foundation; either version 2, or (at your option)
9 This program is distributed in the hope that it will be useful,
10 but WITHOUT ANY WARRANTY; without even the implied warranty of
11 MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
12 GNU General Public License for more details.
14 You should have received a copy of the GNU General Public License
15 along with this program; if not, write to the Free Software Foundation,
16 Inc., 59 Temple Place - Suite 330, Boston, MA 02111-1307, USA. */
18 /* Written by Jim Meyering. */
25 #include <sys/types.h>
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;
51 /* The default number of input bytes per output line. */
52 #define DEFAULT_BYTES_PER_BLOCK 16
54 /* The number of decimal digits of precision in a float. */
59 /* The number of decimal digits of precision in a double. */
64 /* The number of decimal digits of precision in a long double. */
66 # define LDBL_DIG DBL_DIG
77 /* FIXME: add INTMAX support, too */
94 /* Each output format specification (from `-t spec' or from
95 old-style options) is represented by one of these structures. */
98 enum output_format fmt;
100 void (*print_function) PARAMS ((size_t, const char *, const char *));
102 int hexl_mode_trailer;
106 /* The name this program was run with. */
109 /* Convert the number of 8-bit bytes of a binary representation to
110 the number of characters (digits + sign if the type is signed)
111 required to represent the same quantity in the specified base/type.
112 For example, a 32-bit (4-byte) quantity may require a field width
113 as wide as the following for these types:
117 8 unsigned hexadecimal */
119 static const unsigned int bytes_to_oct_digits[] =
120 {0, 3, 6, 8, 11, 14, 16, 19, 22, 25, 27, 30, 32, 35, 38, 41, 43};
122 static const unsigned int bytes_to_signed_dec_digits[] =
123 {1, 4, 6, 8, 11, 13, 16, 18, 20, 23, 25, 28, 30, 33, 35, 37, 40};
125 static const unsigned int bytes_to_unsigned_dec_digits[] =
126 {0, 3, 5, 8, 10, 13, 15, 17, 20, 22, 25, 27, 29, 32, 34, 37, 39};
128 static const unsigned int bytes_to_hex_digits[] =
129 {0, 2, 4, 6, 8, 10, 12, 14, 16, 18, 20, 22, 24, 26, 28, 30, 32};
131 /* Convert enum size_spec to the size of the named type. */
132 static const int width_bytes[] =
144 /* Names for some non-printing characters. */
145 static const char *const charname[33] =
147 "nul", "soh", "stx", "etx", "eot", "enq", "ack", "bel",
148 "bs", "ht", "nl", "vt", "ff", "cr", "so", "si",
149 "dle", "dc1", "dc2", "dc3", "dc4", "nak", "syn", "etb",
150 "can", "em", "sub", "esc", "fs", "gs", "rs", "us",
154 /* Address base (8, 10 or 16). */
155 static int address_base;
157 /* The number of octal digits required to represent the largest
159 #define MAX_ADDRESS_LENGTH \
160 ((sizeof (uintmax_t) * CHAR_BIT + CHAR_BIT - 1) / 3)
162 /* Width of a normal address. */
163 static int address_pad_len;
165 static size_t string_min;
166 static int flag_dump_strings;
168 /* Non-zero if we should recognize the older non-option arguments
169 that specified at most one file and optional arguments specifying
170 offset and pseudo-start address. */
171 static int traditional;
173 /* Non-zero if an old-style `pseudo-address' was specified. */
174 static int flag_pseudo_start;
176 /* The difference between the old-style pseudo starting address and
177 the number of bytes to skip. */
178 static uintmax_t pseudo_offset;
180 /* Function that accepts an address and an optional following char,
181 and prints the address and char to stdout. */
182 static void (*format_address) PARAMS ((uintmax_t, char));
184 /* The number of input bytes to skip before formatting and writing. */
185 static uintmax_t n_bytes_to_skip = 0;
187 /* When zero, MAX_BYTES_TO_FORMAT and END_OFFSET are ignored, and all
188 input is formatted. */
189 static int limit_bytes_to_format = 0;
191 /* The maximum number of bytes that will be formatted. */
192 static uintmax_t max_bytes_to_format;
194 /* The offset of the first byte after the last byte to be formatted. */
195 static uintmax_t end_offset;
197 /* When nonzero and two or more consecutive blocks are equal, format
198 only the first block and output an asterisk alone on the following
199 line to indicate that identical blocks have been elided. */
200 static int abbreviate_duplicate_blocks = 1;
202 /* An array of specs describing how to format each input block. */
203 static struct tspec *spec;
205 /* The number of format specs. */
206 static size_t n_specs;
208 /* The allocated length of SPEC. */
209 static size_t n_specs_allocated;
211 /* The number of input bytes formatted per output line. It must be
212 a multiple of the least common multiple of the sizes associated with
213 the specified output types. It should be as large as possible, but
214 no larger than 16 -- unless specified with the -w option. */
215 static size_t bytes_per_block;
217 /* Human-readable representation of *file_list (for error messages).
218 It differs from *file_list only when *file_list is "-". */
219 static char const *input_filename;
221 /* A NULL-terminated list of the file-arguments from the command line. */
222 static char const *const *file_list;
224 /* Initializer for file_list if no file-arguments
225 were specified on the command line. */
226 static char const *const default_file_list[] = {"-", NULL};
228 /* The input stream associated with the current file. */
229 static FILE *in_stream;
231 /* If nonzero, at least one of the files we read was standard input. */
232 static int have_read_stdin;
234 #if HAVE_UNSIGNED_LONG_LONG
235 typedef unsigned long long ulonglong_t;
237 /* This is just a place-holder to avoid a few `#if' directives.
238 In this case, the type isn't actually used. */
239 typedef unsigned long int ulonglong_t;
242 #define MAX_INTEGRAL_TYPE_SIZE sizeof (ulonglong_t)
243 static enum size_spec integral_type_size[MAX_INTEGRAL_TYPE_SIZE + 1];
245 #define MAX_FP_TYPE_SIZE sizeof(LONG_DOUBLE)
246 static enum size_spec fp_type_size[MAX_FP_TYPE_SIZE + 1];
248 #define COMMON_SHORT_OPTIONS "A:N:abcdfhij:lot:vx"
250 /* For long options that have no equivalent short option, use a
251 non-character as a pseudo short option, starting with CHAR_MAX + 1. */
254 TRADITIONAL_OPTION = CHAR_MAX + 1
257 static struct option const long_options[] =
259 {"skip-bytes", required_argument, NULL, 'j'},
260 {"address-radix", required_argument, NULL, 'A'},
261 {"read-bytes", required_argument, NULL, 'N'},
262 {"format", required_argument, NULL, 't'},
263 {"output-duplicates", no_argument, NULL, 'v'},
264 {"strings", optional_argument, NULL, 's'},
265 {"traditional", no_argument, NULL, TRADITIONAL_OPTION},
266 {"width", optional_argument, NULL, 'w'},
268 {GETOPT_HELP_OPTION_DECL},
269 {GETOPT_VERSION_OPTION_DECL},
277 fprintf (stderr, _("Try `%s --help' for more information.\n"),
282 Usage: %s [OPTION]... [FILE]...\n\
283 or: %s --traditional [FILE] [[+]OFFSET [[+]LABEL]]\n\
285 program_name, program_name);
287 Write an unambiguous representation, octal bytes by default,\n\
288 of FILE to standard output. With more than one FILE argument,\n\
289 concatenate them in the listed order to form the input.\n\
290 With no FILE, or when FILE is -, read standard input.\n\
294 All arguments to long options are mandatory for short options.\n\
297 -A, --address-radix=RADIX decide how file offsets are printed\n\
298 -j, --skip-bytes=BYTES skip BYTES input bytes first\n\
301 -N, --read-bytes=BYTES limit dump to BYTES input bytes\n\
302 -s, --strings[=BYTES] output strings of at least BYTES graphic chars\n\
303 -t, --format=TYPE select output format or formats\n\
304 -v, --output-duplicates do not use * to mark line suppression\n\
305 -w, --width[=BYTES] output BYTES bytes per output line\n\
306 --traditional accept arguments in traditional form\n\
308 fputs (HELP_OPTION_DESCRIPTION, stdout);
309 fputs (VERSION_OPTION_DESCRIPTION, stdout);
312 Traditional format specifications may be intermixed; they accumulate:\n\
313 -a same as -t a, select named characters\n\
314 -b same as -t oC, select octal bytes\n\
315 -c same as -t c, select ASCII characters or backslash escapes\n\
316 -d same as -t u2, select unsigned decimal shorts\n\
319 -f same as -t fF, select floats\n\
320 -h same as -t x2, select hexadecimal shorts\n\
321 -i same as -t d2, select decimal shorts\n\
322 -l same as -t d4, select decimal longs\n\
323 -o same as -t o2, select octal shorts\n\
324 -x same as -t x2, select hexadecimal shorts\n\
328 For older syntax (second call format), OFFSET means -j OFFSET. LABEL\n\
329 is the pseudo-address at first byte printed, incremented when dump is\n\
330 progressing. For OFFSET and LABEL, a 0x or 0X prefix indicates\n\
331 hexadecimal, suffixes may be . for octal and b for multiply by 512.\n\
333 TYPE is made up of one or more of these specifications:\n\
336 c ASCII character or backslash escape\n\
339 d[SIZE] signed decimal, SIZE bytes per integer\n\
340 f[SIZE] floating point, SIZE bytes per integer\n\
341 o[SIZE] octal, SIZE bytes per integer\n\
342 u[SIZE] unsigned decimal, SIZE bytes per integer\n\
343 x[SIZE] hexadecimal, SIZE bytes per integer\n\
347 SIZE is a number. For TYPE in doux, SIZE may also be C for\n\
348 sizeof(char), S for sizeof(short), I for sizeof(int) or L for\n\
349 sizeof(long). If TYPE is f, SIZE may also be F for sizeof(float), D\n\
350 for sizeof(double) or L for sizeof(long double).\n\
354 RADIX is d for decimal, o for octal, x for hexadecimal or n for none.\n\
355 BYTES is hexadecimal with 0x or 0X prefix, it is multiplied by 512\n\
356 with b suffix, by 1024 with k and by 1048576 with m. Adding a z suffix to\n\
357 any type adds a display of printable characters to the end of each line\n\
361 --string without a number implies 3. --width without a number\n\
362 implies 32. By default, od uses -A o -t d2 -w 16.\n\
364 puts (_("\nReport bugs to <bug-textutils@gnu.org>."));
366 exit (status == 0 ? EXIT_SUCCESS : EXIT_FAILURE);
369 /* Compute the greatest common denominator of U and V
370 using Euclid's algorithm. */
373 gcd (unsigned int u, unsigned int v)
385 /* Compute the least common multiple of U and V. */
388 lcm (unsigned int u, unsigned int v)
390 unsigned int t = gcd (u, v);
397 print_s_char (size_t n_bytes, const char *block, const char *fmt_string)
400 for (i = n_bytes; i > 0; i--)
402 int tmp = (unsigned) *(const unsigned char *) block;
404 tmp -= SCHAR_MAX - SCHAR_MIN + 1;
405 assert (tmp <= SCHAR_MAX);
406 printf (fmt_string, tmp);
407 block += sizeof (unsigned char);
412 print_char (size_t n_bytes, const char *block, const char *fmt_string)
415 for (i = n_bytes; i > 0; i--)
417 unsigned int tmp = *(const unsigned char *) block;
418 printf (fmt_string, tmp);
419 block += sizeof (unsigned char);
424 print_s_short (size_t n_bytes, const char *block, const char *fmt_string)
427 for (i = n_bytes / sizeof (unsigned short); i > 0; i--)
429 int tmp = (unsigned) *(const unsigned short *) block;
431 tmp -= SHRT_MAX - SHRT_MIN + 1;
432 assert (tmp <= SHRT_MAX);
433 printf (fmt_string, tmp);
434 block += sizeof (unsigned short);
439 print_short (size_t n_bytes, const char *block, const char *fmt_string)
442 for (i = n_bytes / sizeof (unsigned short); i > 0; i--)
444 unsigned int tmp = *(const unsigned short *) block;
445 printf (fmt_string, tmp);
446 block += sizeof (unsigned short);
451 print_int (size_t n_bytes, const char *block, const char *fmt_string)
454 for (i = n_bytes / sizeof (unsigned int); i > 0; i--)
456 unsigned int tmp = *(const unsigned int *) block;
457 printf (fmt_string, tmp);
458 block += sizeof (unsigned int);
463 print_long (size_t n_bytes, const char *block, const char *fmt_string)
466 for (i = n_bytes / sizeof (unsigned long); i > 0; i--)
468 unsigned long tmp = *(const unsigned long *) block;
469 printf (fmt_string, tmp);
470 block += sizeof (unsigned long);
475 print_long_long (size_t n_bytes, const char *block, const char *fmt_string)
478 for (i = n_bytes / sizeof (ulonglong_t); i > 0; i--)
480 ulonglong_t tmp = *(const ulonglong_t *) block;
481 printf (fmt_string, tmp);
482 block += sizeof (ulonglong_t);
487 print_float (size_t n_bytes, const char *block, const char *fmt_string)
490 for (i = n_bytes / sizeof (float); i > 0; i--)
492 float tmp = *(const float *) block;
493 printf (fmt_string, tmp);
494 block += sizeof (float);
499 print_double (size_t n_bytes, const char *block, const char *fmt_string)
502 for (i = n_bytes / sizeof (double); i > 0; i--)
504 double tmp = *(const double *) block;
505 printf (fmt_string, tmp);
506 block += sizeof (double);
510 #ifdef HAVE_LONG_DOUBLE
512 print_long_double (size_t n_bytes, const char *block, const char *fmt_string)
515 for (i = n_bytes / sizeof (LONG_DOUBLE); i > 0; i--)
517 LONG_DOUBLE tmp = *(const LONG_DOUBLE *) block;
518 printf (fmt_string, tmp);
519 block += sizeof (LONG_DOUBLE);
526 dump_hexl_mode_trailer (size_t n_bytes, const char *block)
529 fputs (" >", stdout);
530 for (i = n_bytes; i > 0; i--)
532 unsigned int c = *(const unsigned char *) block;
533 unsigned int c2 = (ISPRINT(c) ? c : '.');
535 block += sizeof (unsigned char);
541 print_named_ascii (size_t n_bytes, const char *block,
542 const char *unused_fmt_string ATTRIBUTE_UNUSED)
545 for (i = n_bytes; i > 0; i--)
547 unsigned int c = *(const unsigned char *) block;
548 unsigned int masked_c = (0x7f & c);
554 else if (masked_c <= 040)
555 s = charname[masked_c];
558 sprintf (buf, " %c", masked_c);
563 block += sizeof (unsigned char);
568 print_ascii (size_t n_bytes, const char *block,
569 const char *unused_fmt_string ATTRIBUTE_UNUSED)
572 for (i = n_bytes; i > 0; i--)
574 unsigned int c = *(const unsigned char *) block;
613 sprintf (buf, (ISPRINT (c) ? " %c" : "%03o"), c);
614 s = (const char *) buf;
618 block += sizeof (unsigned char);
622 /* Convert a null-terminated (possibly zero-length) string S to an
623 unsigned long integer value. If S points to a non-digit set *P to S,
624 *VAL to 0, and return 0. Otherwise, accumulate the integer value of
625 the string of digits. If the string of digits represents a value
626 larger than ULONG_MAX, don't modify *VAL or *P and return nonzero.
627 Otherwise, advance *P to the first non-digit after S, set *VAL to
628 the result of the conversion and return zero. */
631 simple_strtoul (const char *s, const char **p, long unsigned int *val)
633 unsigned long int sum;
638 unsigned int c = *s++ - '0';
639 if (sum > (ULONG_MAX - c) / 10)
648 /* If S points to a single valid modern od format string, put
649 a description of that format in *TSPEC, make *NEXT point at the
650 character following the just-decoded format (if *NEXT is non-NULL),
651 and return zero. If S is not valid, don't modify *NEXT or *TSPEC,
652 give a diagnostic, and return nonzero. For example, if S were
653 "d4afL" *NEXT would be set to "afL" and *TSPEC would be
655 fmt = SIGNED_DECIMAL;
656 size = INT or LONG; (whichever integral_type_size[4] resolves to)
657 print_function = print_int; (assuming size == INT)
658 fmt_string = "%011d%c";
660 S_ORIG is solely for reporting errors. It should be the full format
665 decode_one_format (const char *s_orig, const char *s, const char **next,
668 enum size_spec size_spec;
669 unsigned long int size;
670 enum output_format fmt;
671 const char *pre_fmt_string;
673 void (*print_function) PARAMS ((size_t, const char *, const char *));
676 unsigned int field_width = 0;
678 assert (tspec != NULL);
692 size = sizeof (char);
697 size = sizeof (short);
707 size = sizeof (long int);
711 if (simple_strtoul (s, &p, &size) != 0)
713 /* The integer at P in S would overflow an unsigned long.
714 A digit string that long is sufficiently odd looking
715 that the following diagnostic is sufficient. */
716 error (0, 0, _("invalid type string `%s'"), s_orig);
723 if (MAX_INTEGRAL_TYPE_SIZE < size
724 || integral_type_size[size] == NO_SIZE)
726 error (0, 0, _("invalid type string `%s';\n\
727 this system doesn't provide a %lu-byte integral type"), s_orig, size);
735 #define FMT_BYTES_ALLOCATED 9
736 fmt_string = xmalloc (FMT_BYTES_ALLOCATED);
738 size_spec = integral_type_size[size];
743 fmt = SIGNED_DECIMAL;
744 sprintf (fmt_string, " %%%u%sd",
745 (field_width = bytes_to_signed_dec_digits[size]),
746 (size_spec == LONG ? "l"
747 : (size_spec == LONG_LONG ? "ll"
753 sprintf (fmt_string, " %%0%u%so",
754 (field_width = bytes_to_oct_digits[size]),
755 (size_spec == LONG ? "l" : ""));
759 fmt = UNSIGNED_DECIMAL;
760 sprintf (fmt_string, " %%%u%su",
761 (field_width = bytes_to_unsigned_dec_digits[size]),
762 (size_spec == LONG ? "l" : ""));
767 sprintf (fmt_string, " %%0%u%sx",
768 (field_width = bytes_to_hex_digits[size]),
769 (size_spec == LONG ? "l" : ""));
776 assert (strlen (fmt_string) < FMT_BYTES_ALLOCATED);
781 print_function = (fmt == SIGNED_DECIMAL
787 print_function = (fmt == SIGNED_DECIMAL
793 print_function = print_int;
797 print_function = print_long;
801 print_function = print_long_long;
810 fmt = FLOATING_POINT;
816 size = sizeof (float);
821 size = sizeof (double);
826 size = sizeof (LONG_DOUBLE);
830 if (simple_strtoul (s, &p, &size) != 0)
832 /* The integer at P in S would overflow an unsigned long.
833 A digit string that long is sufficiently odd looking
834 that the following diagnostic is sufficient. */
835 error (0, 0, _("invalid type string `%s'"), s_orig);
839 size = sizeof (double);
842 if (size > MAX_FP_TYPE_SIZE
843 || fp_type_size[size] == NO_SIZE)
845 error (0, 0, _("invalid type string `%s';\n\
846 this system doesn't provide a %lu-byte floating point type"), s_orig, size);
853 size_spec = fp_type_size[size];
858 print_function = print_float;
859 /* Don't use %#e; not all systems support it. */
860 pre_fmt_string = " %%%d.%de";
861 fmt_string = xmalloc (strlen (pre_fmt_string));
862 sprintf (fmt_string, pre_fmt_string,
863 (field_width = FLT_DIG + 8), FLT_DIG);
867 print_function = print_double;
868 pre_fmt_string = " %%%d.%de";
869 fmt_string = xmalloc (strlen (pre_fmt_string));
870 sprintf (fmt_string, pre_fmt_string,
871 (field_width = DBL_DIG + 8), DBL_DIG);
874 #ifdef HAVE_LONG_DOUBLE
875 case FLOAT_LONG_DOUBLE:
876 print_function = print_long_double;
877 pre_fmt_string = " %%%d.%dLe";
878 fmt_string = xmalloc (strlen (pre_fmt_string));
879 sprintf (fmt_string, pre_fmt_string,
880 (field_width = LDBL_DIG + 8), LDBL_DIG);
891 fmt = NAMED_CHARACTER;
894 print_function = print_named_ascii;
903 print_function = print_ascii;
908 error (0, 0, _("invalid character `%c' in type string `%s'"),
913 tspec->size = size_spec;
915 tspec->print_function = print_function;
916 tspec->fmt_string = fmt_string;
918 tspec->field_width = field_width;
919 tspec->hexl_mode_trailer = (*s == 'z');
920 if (tspec->hexl_mode_trailer)
929 /* Given a list of one or more input filenames FILE_LIST, set the global
930 file pointer IN_STREAM and the global string INPUT_FILENAME to the
931 first one that can be successfully opened. Modify FILE_LIST to
932 reference the next filename in the list. A file name of "-" is
933 interpreted as standard input. If any file open fails, give an error
934 message and return nonzero. */
937 open_next_file (void)
943 input_filename = *file_list;
944 if (input_filename == NULL)
948 if (STREQ (input_filename, "-"))
950 input_filename = _("standard input");
956 in_stream = fopen (input_filename, "r");
957 if (in_stream == NULL)
959 error (0, errno, "%s", input_filename);
964 while (in_stream == NULL);
966 if (limit_bytes_to_format && !flag_dump_strings)
967 SETVBUF (in_stream, NULL, _IONBF, 0);
968 SET_BINARY (fileno (in_stream));
973 /* Test whether there have been errors on in_stream, and close it if
974 it is not standard input. Return nonzero if there has been an error
975 on in_stream or stdout; return zero otherwise. This function will
976 report more than one error only if both a read and a write error
980 check_and_close (void)
984 if (in_stream != NULL)
986 if (ferror (in_stream))
988 error (0, errno, "%s", input_filename);
989 if (in_stream != stdin)
993 else if (in_stream != stdin && fclose (in_stream) == EOF)
995 error (0, errno, "%s", input_filename);
1002 if (ferror (stdout))
1004 error (0, errno, _("standard output"));
1011 /* Decode the modern od format string S. Append the decoded
1012 representation to the global array SPEC, reallocating SPEC if
1013 necessary. Return zero if S is valid, nonzero otherwise. */
1016 decode_format_string (const char *s)
1018 const char *s_orig = s;
1026 if (decode_one_format (s_orig, s, &next, &tspec))
1032 if (n_specs >= n_specs_allocated)
1034 n_specs_allocated = 1 + (3 * n_specs_allocated) / 2;
1035 spec = (struct tspec *) xrealloc ((char *) spec,
1037 * sizeof (struct tspec)));
1040 memcpy ((char *) &spec[n_specs], (char *) &tspec,
1041 sizeof (struct tspec));
1048 /* Given a list of one or more input filenames FILE_LIST, set the global
1049 file pointer IN_STREAM to position N_SKIP in the concatenation of
1050 those files. If any file operation fails or if there are fewer than
1051 N_SKIP bytes in the combined input, give an error message and return
1052 nonzero. When possible, use seek rather than read operations to
1053 advance IN_STREAM. */
1056 skip (uintmax_t n_skip)
1063 while (in_stream != NULL) /* EOF. */
1065 struct stat file_stats;
1067 /* First try seeking. For large offsets, this extra work is
1068 worthwhile. If the offset is below some threshold it may be
1069 more efficient to move the pointer by reading. There are two
1070 issues when trying to seek:
1071 - the file must be seekable.
1072 - before seeking to the specified position, make sure
1073 that the new position is in the current file.
1074 Try to do that by getting file's size using fstat.
1075 But that will work only for regular files. */
1077 if (fstat (fileno (in_stream), &file_stats) == 0)
1079 /* The st_size field is valid only for regular files
1080 (and for symbolic links, which cannot occur here).
1081 If the number of bytes left to skip is at least
1082 as large as the size of the current file, we can
1083 decrement n_skip and go on to the next file. */
1085 if (S_ISREG (file_stats.st_mode) && 0 <= file_stats.st_size)
1087 if (file_stats.st_size <= n_skip)
1088 n_skip -= file_stats.st_size;
1091 if (fseeko (in_stream, n_skip, SEEK_CUR) != 0)
1093 error (0, errno, "%s", input_filename);
1100 /* If it's not a regular file with nonnegative size,
1101 position the file pointer by reading. */
1106 size_t n_bytes_read, n_bytes_to_read = BUFSIZ;
1110 if (n_skip < n_bytes_to_read)
1111 n_bytes_to_read = n_skip;
1112 n_bytes_read = fread (buf, 1, n_bytes_to_read, in_stream);
1113 n_skip -= n_bytes_read;
1114 if (n_bytes_read != n_bytes_to_read)
1123 else /* cannot fstat() file */
1125 error (0, errno, "%s", input_filename);
1129 err |= check_and_close ();
1131 err |= open_next_file ();
1135 error (EXIT_FAILURE, 0, _("cannot skip past end of combined input"));
1141 format_address_none (uintmax_t address ATTRIBUTE_UNUSED, char c ATTRIBUTE_UNUSED)
1146 format_address_std (uintmax_t address, char c)
1148 char buf[MAX_ADDRESS_LENGTH + 2];
1149 char *p = buf + sizeof buf;
1154 pbound = p - address_pad_len;
1156 /* Use a special case of the code for each base. This is measurably
1157 faster than generic code. */
1158 switch (address_base)
1162 *--p = '0' + (address & 7);
1163 while ((address >>= 3) != 0);
1168 *--p = '0' + (address % 10);
1169 while ((address /= 10) != 0);
1174 *--p = "0123456789abcdef"[address & 15];
1175 while ((address >>= 4) != 0);
1186 format_address_paren (uintmax_t address, char c)
1189 format_address_std (address, ')');
1194 format_address_label (uintmax_t address, char c)
1196 format_address_std (address, ' ');
1197 format_address_paren (address + pseudo_offset, c);
1200 /* Write N_BYTES bytes from CURR_BLOCK to standard output once for each
1201 of the N_SPEC format specs. CURRENT_OFFSET is the byte address of
1202 CURR_BLOCK in the concatenation of input files, and it is printed
1203 (optionally) only before the output line associated with the first
1204 format spec. When duplicate blocks are being abbreviated, the output
1205 for a sequence of identical input blocks is the output for the first
1206 block followed by an asterisk alone on a line. It is valid to compare
1207 the blocks PREV_BLOCK and CURR_BLOCK only when N_BYTES == BYTES_PER_BLOCK.
1208 That condition may be false only for the last input block -- and then
1209 only when it has not been padded to length BYTES_PER_BLOCK. */
1212 write_block (uintmax_t current_offset, size_t n_bytes,
1213 const char *prev_block, const char *curr_block)
1215 static int first = 1;
1216 static int prev_pair_equal = 0;
1218 #define EQUAL_BLOCKS(b1, b2) (memcmp ((b1), (b2), bytes_per_block) == 0)
1220 if (abbreviate_duplicate_blocks
1221 && !first && n_bytes == bytes_per_block
1222 && EQUAL_BLOCKS (prev_block, curr_block))
1224 if (prev_pair_equal)
1226 /* The two preceding blocks were equal, and the current
1227 block is the same as the last one, so print nothing. */
1232 prev_pair_equal = 1;
1239 prev_pair_equal = 0;
1240 for (i = 0; i < n_specs; i++)
1243 format_address (current_offset, '\0');
1245 printf ("%*s", address_pad_len, "");
1246 (*spec[i].print_function) (n_bytes, curr_block, spec[i].fmt_string);
1247 if (spec[i].hexl_mode_trailer)
1249 /* space-pad out to full line width, then dump the trailer */
1250 int datum_width = width_bytes[spec[i].size];
1251 int blank_fields = (bytes_per_block - n_bytes) / datum_width;
1252 int field_width = spec[i].field_width + 1;
1253 printf ("%*s", blank_fields * field_width, "");
1254 dump_hexl_mode_trailer (n_bytes, curr_block);
1262 /* Read a single byte into *C from the concatenation of the input files
1263 named in the global array FILE_LIST. On the first call to this
1264 function, the global variable IN_STREAM is expected to be an open
1265 stream associated with the input file INPUT_FILENAME. If IN_STREAM
1266 is at end-of-file, close it and update the global variables IN_STREAM
1267 and INPUT_FILENAME so they correspond to the next file in the list.
1268 Then try to read a byte from the newly opened file. Repeat if
1269 necessary until EOF is reached for the last file in FILE_LIST, then
1270 set *C to EOF and return. Subsequent calls do likewise. The return
1271 value is nonzero if any errors occured, zero otherwise. */
1280 while (in_stream != NULL) /* EOF. */
1282 *c = fgetc (in_stream);
1287 err |= check_and_close ();
1289 err |= open_next_file ();
1295 /* Read N bytes into BLOCK from the concatenation of the input files
1296 named in the global array FILE_LIST. On the first call to this
1297 function, the global variable IN_STREAM is expected to be an open
1298 stream associated with the input file INPUT_FILENAME. If all N
1299 bytes cannot be read from IN_STREAM, close IN_STREAM and update
1300 the global variables IN_STREAM and INPUT_FILENAME. Then try to
1301 read the remaining bytes from the newly opened file. Repeat if
1302 necessary until EOF is reached for the last file in FILE_LIST.
1303 On subsequent calls, don't modify BLOCK and return zero. Set
1304 *N_BYTES_IN_BUFFER to the number of bytes read. If an error occurs,
1305 it will be detected through ferror when the stream is about to be
1306 closed. If there is an error, give a message but continue reading
1307 as usual and return nonzero. Otherwise return zero. */
1310 read_block (size_t n, char *block, size_t *n_bytes_in_buffer)
1314 assert (0 < n && n <= bytes_per_block);
1316 *n_bytes_in_buffer = 0;
1321 while (in_stream != NULL) /* EOF. */
1326 n_needed = n - *n_bytes_in_buffer;
1327 n_read = fread (block + *n_bytes_in_buffer, 1, n_needed, in_stream);
1329 *n_bytes_in_buffer += n_read;
1331 if (n_read == n_needed)
1334 err |= check_and_close ();
1336 err |= open_next_file ();
1342 /* Return the least common multiple of the sizes associated
1343 with the format specs. */
1351 for (i = 0; i < n_specs; i++)
1352 l_c_m = lcm (l_c_m, width_bytes[(int) spec[i].size]);
1356 /* If S is a valid traditional offset specification with an optional
1357 leading '+' return nonzero and set *OFFSET to the offset it denotes. */
1360 parse_old_offset (const char *s, uintmax_t *offset)
1363 enum strtol_error s_err;
1368 /* Skip over any leading '+'. */
1372 /* Determine the radix we'll use to interpret S. If there is a `.',
1373 it's decimal, otherwise, if the string begins with `0X'or `0x',
1374 it's hexadecimal, else octal. */
1375 if (strchr (s, '.') != NULL)
1379 if (s[0] == '0' && (s[1] == 'x' || s[1] == 'X'))
1385 s_err = xstrtoumax (s, NULL, radix, offset, "Bb");
1386 if (s_err != LONGINT_OK)
1388 STRTOL_FAIL_WARN (s, _("old-style offset"), s_err);
1394 /* Read a chunk of size BYTES_PER_BLOCK from the input files, write the
1395 formatted block to standard output, and repeat until the specified
1396 maximum number of bytes has been read or until all input has been
1397 processed. If the last block read is smaller than BYTES_PER_BLOCK
1398 and its size is not a multiple of the size associated with a format
1399 spec, extend the input block with zero bytes until its length is a
1400 multiple of all format spec sizes. Write the final block. Finally,
1401 write on a line by itself the offset of the byte after the last byte
1402 read. Accumulate return values from calls to read_block and
1403 check_and_close, and if any was nonzero, return nonzero.
1404 Otherwise, return zero. */
1410 uintmax_t current_offset;
1413 size_t n_bytes_read;
1415 block[0] = (char *) alloca (bytes_per_block);
1416 block[1] = (char *) alloca (bytes_per_block);
1418 current_offset = n_bytes_to_skip;
1422 if (limit_bytes_to_format)
1427 if (current_offset >= end_offset)
1432 n_needed = MIN (end_offset - current_offset,
1433 (uintmax_t) bytes_per_block);
1434 err |= read_block (n_needed, block[idx], &n_bytes_read);
1435 if (n_bytes_read < bytes_per_block)
1437 assert (n_bytes_read == bytes_per_block);
1438 write_block (current_offset, n_bytes_read,
1439 block[!idx], block[idx]);
1440 current_offset += n_bytes_read;
1448 err |= read_block (bytes_per_block, block[idx], &n_bytes_read);
1449 if (n_bytes_read < bytes_per_block)
1451 assert (n_bytes_read == bytes_per_block);
1452 write_block (current_offset, n_bytes_read,
1453 block[!idx], block[idx]);
1454 current_offset += n_bytes_read;
1459 if (n_bytes_read > 0)
1462 size_t bytes_to_write;
1466 /* Make bytes_to_write the smallest multiple of l_c_m that
1467 is at least as large as n_bytes_read. */
1468 bytes_to_write = l_c_m * ((n_bytes_read + l_c_m - 1) / l_c_m);
1470 memset (block[idx] + n_bytes_read, 0, bytes_to_write - n_bytes_read);
1471 write_block (current_offset, bytes_to_write,
1472 block[!idx], block[idx]);
1473 current_offset += n_bytes_read;
1476 format_address (current_offset, '\n');
1478 if (limit_bytes_to_format && current_offset >= end_offset)
1479 err |= check_and_close ();
1484 /* STRINGS mode. Find each "string constant" in the input.
1485 A string constant is a run of at least `string_min' ASCII
1486 graphic (or formatting) characters terminated by a null.
1487 Based on a function written by Richard Stallman for a
1488 traditional version of od. Return nonzero if an error
1489 occurs. Otherwise, return zero. */
1494 size_t bufsize = MAX (100, string_min);
1495 char *buf = xmalloc (bufsize);
1496 uintmax_t address = n_bytes_to_skip;
1505 /* See if the next `string_min' chars are all printing chars. */
1508 if (limit_bytes_to_format
1509 && (end_offset < string_min || end_offset - string_min <= address))
1512 for (i = 0; i < string_min; i++)
1514 err |= read_char (&c);
1522 /* Found a non-printing. Try again starting with next char. */
1527 /* We found a run of `string_min' printable characters.
1528 Now see if it is terminated with a null byte. */
1529 while (!limit_bytes_to_format || address < end_offset)
1533 bufsize = 1 + 3 * bufsize / 2;
1534 buf = xrealloc (buf, bufsize);
1536 err |= read_char (&c);
1544 break; /* It is; print this string. */
1546 goto tryline; /* It isn't; give up on this string. */
1547 buf[i++] = c; /* String continues; store it all. */
1550 /* If we get here, the string is all printable and null-terminated,
1551 so print it. It is all in `buf' and `i' is its length. */
1553 format_address (address - i - 1, ' ');
1555 for (i = 0; (c = buf[i]); i++)
1560 fputs ("\\a", stdout);
1564 fputs ("\\b", stdout);
1568 fputs ("\\f", stdout);
1572 fputs ("\\n", stdout);
1576 fputs ("\\r", stdout);
1580 fputs ("\\t", stdout);
1584 fputs ("\\v", stdout);
1594 /* We reach this point only if we search through
1595 (max_bytes_to_format - string_min) bytes before reaching EOF. */
1599 err |= check_and_close ();
1604 main (int argc, char **argv)
1610 size_t desired_width IF_LINT (= 0);
1611 int width_specified = 0;
1612 int n_failed_decodes = 0;
1614 char const *short_options = (posix2_version () < 200112
1615 ? COMMON_SHORT_OPTIONS "s::w::"
1616 : COMMON_SHORT_OPTIONS "s:w:");
1618 /* The old-style `pseudo starting address' to be printed in parentheses
1619 after any true address. */
1620 uintmax_t pseudo_start IF_LINT (= 0);
1622 program_name = argv[0];
1623 setlocale (LC_ALL, "");
1624 bindtextdomain (PACKAGE, LOCALEDIR);
1625 textdomain (PACKAGE);
1627 atexit (close_stdout);
1631 for (i = 0; i <= MAX_INTEGRAL_TYPE_SIZE; i++)
1632 integral_type_size[i] = NO_SIZE;
1634 integral_type_size[sizeof (char)] = CHAR;
1635 integral_type_size[sizeof (short int)] = SHORT;
1636 integral_type_size[sizeof (int)] = INT;
1637 integral_type_size[sizeof (long int)] = LONG;
1638 #if HAVE_UNSIGNED_LONG_LONG
1639 integral_type_size[sizeof (ulonglong_t)] = LONG_LONG;
1642 for (i = 0; i <= MAX_FP_TYPE_SIZE; i++)
1643 fp_type_size[i] = NO_SIZE;
1645 fp_type_size[sizeof (float)] = FLOAT_SINGLE;
1646 /* The array entry for `double' is filled in after that for LONG_DOUBLE
1647 so that if `long double' is the same type or if long double isn't
1648 supported FLOAT_LONG_DOUBLE will never be used. */
1649 fp_type_size[sizeof (LONG_DOUBLE)] = FLOAT_LONG_DOUBLE;
1650 fp_type_size[sizeof (double)] = FLOAT_DOUBLE;
1653 n_specs_allocated = 5;
1654 spec = (struct tspec *) xmalloc (n_specs_allocated * sizeof (struct tspec));
1656 format_address = format_address_std;
1658 address_pad_len = 7;
1659 flag_dump_strings = 0;
1661 while ((c = getopt_long (argc, argv, short_options, long_options, NULL))
1665 enum strtol_error s_err;
1676 format_address = format_address_std;
1678 address_pad_len = 7;
1681 format_address = format_address_std;
1683 address_pad_len = 7;
1686 format_address = format_address_std;
1688 address_pad_len = 6;
1691 format_address = format_address_none;
1692 address_pad_len = 0;
1695 error (EXIT_FAILURE, 0,
1696 _("invalid output address radix `%c'; \
1697 it must be one character from [doxn]"),
1704 s_err = xstrtoumax (optarg, NULL, 0, &n_bytes_to_skip, "bkm");
1705 if (s_err != LONGINT_OK)
1706 STRTOL_FATAL_ERROR (optarg, _("skip argument"), s_err);
1710 limit_bytes_to_format = 1;
1712 s_err = xstrtoumax (optarg, NULL, 0, &max_bytes_to_format, "bkm");
1713 if (s_err != LONGINT_OK)
1714 STRTOL_FATAL_ERROR (optarg, _("limit argument"), s_err);
1722 s_err = xstrtoumax (optarg, NULL, 0, &tmp, "bkm");
1723 if (s_err != LONGINT_OK)
1724 STRTOL_FATAL_ERROR (optarg, _("minimum string length"), s_err);
1726 /* The minimum string length may be no larger than SIZE_MAX,
1727 since we may allocate a buffer of this size. */
1729 error (EXIT_FAILURE, 0, _("%s is too large"), optarg);
1733 flag_dump_strings = 1;
1737 if (decode_format_string (optarg))
1742 abbreviate_duplicate_blocks = 0;
1745 case TRADITIONAL_OPTION:
1749 /* The next several cases map the traditional format
1750 specification options to the corresponding modern format
1751 specs. GNU od accepts any combination of old- and
1752 new-style options. Format specification options accumulate. */
1754 #define CASE_OLD_ARG(old_char,new_string) \
1757 if (decode_format_string (new_string)) \
1758 ++n_failed_decodes; \
1762 CASE_OLD_ARG ('a', "a");
1763 CASE_OLD_ARG ('b', "oC");
1764 CASE_OLD_ARG ('c', "c");
1765 CASE_OLD_ARG ('d', "u2");
1766 CASE_OLD_ARG ('f', "fF");
1767 CASE_OLD_ARG ('h', "x2");
1768 CASE_OLD_ARG ('i', "d2");
1769 CASE_OLD_ARG ('l', "d4");
1770 CASE_OLD_ARG ('o', "o2");
1771 CASE_OLD_ARG ('x', "x2");
1773 /* FIXME: POSIX 1003.1-2001 with XSI requires this:
1775 CASE_OLD_ARG ('s', "d2");
1777 for the traditional syntax, but this conflicts with case
1783 width_specified = 1;
1791 s_err = xstrtoumax (optarg, NULL, 10, &w_tmp, "");
1792 if (s_err != LONGINT_OK)
1793 STRTOL_FATAL_ERROR (optarg, _("width specification"), s_err);
1794 if (SIZE_MAX < w_tmp)
1795 error (EXIT_FAILURE, 0, _("%s is too large"), optarg);
1796 desired_width = w_tmp;
1800 case_GETOPT_HELP_CHAR;
1802 case_GETOPT_VERSION_CHAR (PROGRAM_NAME, AUTHORS);
1810 if (n_failed_decodes > 0)
1811 exit (EXIT_FAILURE);
1813 if (flag_dump_strings && n_specs > 0)
1814 error (EXIT_FAILURE, 0,
1815 _("no type may be specified when dumping strings"));
1817 n_files = argc - optind;
1819 /* If the --traditional option is used, there may be from
1820 0 to 3 remaining command line arguments; handle each case
1822 od [file] [[+]offset[.][b] [[+]label[.][b]]]
1823 The offset and pseudo_start have the same syntax.
1825 FIXME: POSIX 1003.1-2001 with XSI requires support for the
1826 traditional syntax even if --traditional is not given. */
1834 if (parse_old_offset (argv[optind], &offset))
1836 n_bytes_to_skip = offset;
1841 else if (n_files == 2)
1844 if (parse_old_offset (argv[optind], &o1)
1845 && parse_old_offset (argv[optind + 1], &o2))
1847 n_bytes_to_skip = o1;
1848 flag_pseudo_start = 1;
1853 else if (parse_old_offset (argv[optind + 1], &o2))
1855 n_bytes_to_skip = o2;
1857 argv[optind + 1] = argv[optind];
1863 _("invalid second operand in compatibility mode `%s'"),
1868 else if (n_files == 3)
1871 if (parse_old_offset (argv[optind + 1], &o1)
1872 && parse_old_offset (argv[optind + 2], &o2))
1874 n_bytes_to_skip = o1;
1875 flag_pseudo_start = 1;
1877 argv[optind + 2] = argv[optind];
1884 _("in compatibility mode, the last two arguments must be offsets"));
1888 else if (n_files > 3)
1891 _("compatibility mode supports at most three arguments"));
1895 if (flag_pseudo_start)
1897 if (format_address == format_address_none)
1900 address_pad_len = 7;
1901 format_address = format_address_paren;
1904 format_address = format_address_label;
1908 if (limit_bytes_to_format)
1910 end_offset = n_bytes_to_skip + max_bytes_to_format;
1911 if (end_offset < n_bytes_to_skip)
1912 error (EXIT_FAILURE, 0, "skip-bytes + read-bytes is too large");
1917 if (decode_one_format ("o2", "o2", NULL, &(spec[0])))
1919 /* This happens on Cray systems that don't have a 2-byte
1921 exit (EXIT_FAILURE);
1929 /* Set the global pointer FILE_LIST so that it
1930 references the first file-argument on the command-line. */
1932 file_list = (char const *const *) &argv[optind];
1936 /* No files were listed on the command line.
1937 Set the global pointer FILE_LIST so that it
1938 references the null-terminated list of one name: "-". */
1940 file_list = default_file_list;
1943 /* open the first input file */
1944 err |= open_next_file ();
1945 if (in_stream == NULL)
1948 /* skip over any unwanted header bytes */
1949 err |= skip (n_bytes_to_skip);
1950 if (in_stream == NULL)
1953 pseudo_offset = (flag_pseudo_start ? pseudo_start - n_bytes_to_skip : 0);
1955 /* Compute output block length. */
1958 if (width_specified)
1960 if (desired_width != 0 && desired_width % l_c_m == 0)
1961 bytes_per_block = desired_width;
1964 error (0, 0, _("warning: invalid width %lu; using %d instead"),
1965 (unsigned long) desired_width, l_c_m);
1966 bytes_per_block = l_c_m;
1971 if (l_c_m < DEFAULT_BYTES_PER_BLOCK)
1972 bytes_per_block = l_c_m * (DEFAULT_BYTES_PER_BLOCK / l_c_m);
1974 bytes_per_block = l_c_m;
1978 for (i = 0; i < n_specs; i++)
1980 printf (_("%d: fmt=\"%s\" width=%d\n"),
1981 i, spec[i].fmt_string, width_bytes[spec[i].size]);
1985 err |= (flag_dump_strings ? dump_strings () : dump ());
1989 if (have_read_stdin && fclose (stdin) == EOF)
1990 error (EXIT_FAILURE, errno, _("standard input"));
1992 exit (err == 0 ? EXIT_SUCCESS : EXIT_FAILURE);