1 /* od -- dump files in octal and other formats
2 Copyright (C) 92, 1995-2001 Free Software Foundation, Inc.
4 This program is free software; you can redistribute it and/or modify
5 it under the terms of the GNU General Public License as published by
6 the Free Software Foundation; either version 2, or (at your option)
9 This program is distributed in the hope that it will be useful,
10 but WITHOUT ANY WARRANTY; without even the implied warranty of
11 MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
12 GNU General Public License for more details.
14 You should have received a copy of the GNU General Public License
15 along with this program; if not, write to the Free Software Foundation,
16 Inc., 59 Temple Place - Suite 330, Boston, MA 02111-1307, USA. */
18 /* Written by Jim Meyering. */
25 #include <sys/types.h>
31 /* The official name of this program (e.g., no `g' prefix). */
32 #define PROGRAM_NAME "od"
34 #define AUTHORS "Jim Meyering"
36 #if defined(__GNUC__) || defined(STDC_HEADERS)
40 #ifdef HAVE_LONG_DOUBLE
41 typedef long double LONG_DOUBLE;
43 typedef double LONG_DOUBLE;
50 /* The default number of input bytes per output line. */
51 #define DEFAULT_BYTES_PER_BLOCK 16
53 /* The number of decimal digits of precision in a float. */
58 /* The number of decimal digits of precision in a double. */
63 /* The number of decimal digits of precision in a long double. */
65 # define LDBL_DIG DBL_DIG
76 /* FIXME: add INTMAX support, too */
93 /* Each output format specification (from POSIX `-t spec' or from
94 old-style options) is represented by one of these structures. */
97 enum output_format fmt;
99 void (*print_function) ();
101 int hexl_mode_trailer;
105 /* The name this program was run with. */
108 /* Convert the number of 8-bit bytes of a binary representation to
109 the number of characters (digits + sign if the type is signed)
110 required to represent the same quantity in the specified base/type.
111 For example, a 32-bit (4-byte) quantity may require a field width
112 as wide as the following for these types:
116 8 unsigned hexadecimal */
118 static const unsigned int bytes_to_oct_digits[] =
119 {0, 3, 6, 8, 11, 14, 16, 19, 22, 25, 27, 30, 32, 35, 38, 41, 43};
121 static const unsigned int bytes_to_signed_dec_digits[] =
122 {1, 4, 6, 8, 11, 13, 16, 18, 20, 23, 25, 28, 30, 33, 35, 37, 40};
124 static const unsigned int bytes_to_unsigned_dec_digits[] =
125 {0, 3, 5, 8, 10, 13, 15, 17, 20, 22, 25, 27, 29, 32, 34, 37, 39};
127 static const unsigned int bytes_to_hex_digits[] =
128 {0, 2, 4, 6, 8, 10, 12, 14, 16, 18, 20, 22, 24, 26, 28, 30, 32};
130 /* Convert enum size_spec to the size of the named type. */
131 static const int width_bytes[] =
143 /* Names for some non-printing characters. */
144 static const char *const charname[33] =
146 "nul", "soh", "stx", "etx", "eot", "enq", "ack", "bel",
147 "bs", "ht", "nl", "vt", "ff", "cr", "so", "si",
148 "dle", "dc1", "dc2", "dc3", "dc4", "nak", "syn", "etb",
149 "can", "em", "sub", "esc", "fs", "gs", "rs", "us",
153 /* Address base (8, 10 or 16). */
154 static int address_base;
156 /* The number of octal digits required to represent the largest off_t value. */
157 #define MAX_ADDRESS_LENGTH \
158 ((sizeof (off_t) * CHAR_BIT + CHAR_BIT - 1) / 3)
160 /* Width of a normal address. */
161 static int address_pad_len;
163 static size_t string_min;
164 static int flag_dump_strings;
166 /* Non-zero if we should recognize the pre-POSIX non-option arguments
167 that specified at most one file and optional arguments specifying
168 offset and pseudo-start address. */
169 static int traditional;
171 /* Non-zero if an old-style `pseudo-address' was specified. */
172 static int flag_pseudo_start;
174 /* The difference between the old-style pseudo starting address and
175 the number of bytes to skip. */
176 static off_t pseudo_offset;
178 /* Function that accepts an address and an optional following char,
179 and prints the address and char to stdout. */
180 static void (*format_address) PARAMS ((off_t, char));
182 /* The number of input bytes to skip before formatting and writing. */
183 static off_t n_bytes_to_skip = 0;
185 /* When nonzero, MAX_BYTES_TO_FORMAT is the maximum number of bytes
186 to be read and formatted. Otherwise all input is formatted. */
187 static int limit_bytes_to_format = 0;
189 /* The maximum number of bytes that will be formatted. This
190 value is used only when LIMIT_BYTES_TO_FORMAT is nonzero. */
191 static off_t max_bytes_to_format;
193 /* When nonzero and two or more consecutive blocks are equal, format
194 only the first block and output an asterisk alone on the following
195 line to indicate that identical blocks have been elided. */
196 static int abbreviate_duplicate_blocks = 1;
198 /* An array of specs describing how to format each input block. */
199 static struct tspec *spec;
201 /* The number of format specs. */
202 static size_t n_specs;
204 /* The allocated length of SPEC. */
205 static size_t n_specs_allocated;
207 /* The number of input bytes formatted per output line. It must be
208 a multiple of the least common multiple of the sizes associated with
209 the specified output types. It should be as large as possible, but
210 no larger than 16 -- unless specified with the -w option. */
211 static size_t bytes_per_block;
213 /* Human-readable representation of *file_list (for error messages).
214 It differs from *file_list only when *file_list is "-". */
215 static char const *input_filename;
217 /* A NULL-terminated list of the file-arguments from the command line. */
218 static char const *const *file_list;
220 /* Initializer for file_list if no file-arguments
221 were specified on the command line. */
222 static char const *const default_file_list[] = {"-", NULL};
224 /* The input stream associated with the current file. */
225 static FILE *in_stream;
227 /* If nonzero, at least one of the files we read was standard input. */
228 static int have_read_stdin;
230 #if HAVE_UNSIGNED_LONG_LONG
231 typedef unsigned long long ulonglong_t;
233 /* This is just a place-holder to avoid a few `#if' directives.
234 In this case, the type isn't actually used. */
235 typedef unsigned long int ulonglong_t;
238 #define MAX_INTEGRAL_TYPE_SIZE sizeof (ulonglong_t)
239 static enum size_spec integral_type_size[MAX_INTEGRAL_TYPE_SIZE + 1];
241 #define MAX_FP_TYPE_SIZE sizeof(LONG_DOUBLE)
242 static enum size_spec fp_type_size[MAX_FP_TYPE_SIZE + 1];
244 static struct option const long_options[] =
247 {"skip-bytes", required_argument, NULL, 'j'},
248 {"address-radix", required_argument, NULL, 'A'},
249 {"read-bytes", required_argument, NULL, 'N'},
250 {"format", required_argument, NULL, 't'},
251 {"output-duplicates", no_argument, NULL, 'v'},
253 /* non-POSIX options. */
254 {"strings", optional_argument, NULL, 's'},
255 {"traditional", no_argument, NULL, 'B'},
256 {"width", optional_argument, NULL, 'w'},
258 {GETOPT_HELP_OPTION_DECL},
259 {GETOPT_VERSION_OPTION_DECL},
267 fprintf (stderr, _("Try `%s --help' for more information.\n"),
272 Usage: %s [OPTION]... [FILE]...\n\
273 or: %s --traditional [FILE] [[+]OFFSET [[+]LABEL]]\n\
275 program_name, program_name);
277 Write an unambiguous representation, octal bytes by default,\n\
278 of FILE to standard output. With more than one FILE argument,\n\
279 concatenate them in the listed order to form the input.\n\
280 With no FILE, or when FILE is -, read standard input.\n\
282 -A, --address-radix=RADIX decide how file offsets are printed\n\
283 -j, --skip-bytes=BYTES skip BYTES input bytes first\n\
284 -N, --read-bytes=BYTES limit dump to BYTES input bytes\n\
285 -s, --strings[=BYTES] output strings of at least BYTES graphic chars\n\
286 -t, --format=TYPE select output format or formats\n\
287 -v, --output-duplicates do not use * to mark line suppression\n\
288 -w, --width[=BYTES] output BYTES bytes per output line\n\
289 --traditional accept arguments in pre-POSIX form\n\
290 --help display this help and exit\n\
291 --version output version information and exit\n\
293 Pre-POSIX format specifications may be intermixed, they accumulate:\n\
294 -a same as -t a, select named characters\n\
295 -b same as -t oC, select octal bytes\n\
296 -c same as -t c, select ASCII characters or backslash escapes\n\
297 -d same as -t u2, select unsigned decimal shorts\n\
298 -f same as -t fF, select floats\n\
299 -h same as -t x2, select hexadecimal shorts\n\
300 -i same as -t d2, select decimal shorts\n\
301 -l same as -t d4, select decimal longs\n\
302 -o same as -t o2, select octal shorts\n\
303 -x same as -t x2, select hexadecimal shorts\n\
307 For older syntax (second call format), OFFSET means -j OFFSET. LABEL\n\
308 is the pseudo-address at first byte printed, incremented when dump is\n\
309 progressing. For OFFSET and LABEL, a 0x or 0X prefix indicates\n\
310 hexadecimal, suffixes maybe . for octal and b multiply by 512.\n\
312 TYPE is made up of one or more of these specifications:\n\
315 c ASCII character or backslash escape\n\
316 d[SIZE] signed decimal, SIZE bytes per integer\n\
317 f[SIZE] floating point, SIZE bytes per integer\n\
318 o[SIZE] octal, SIZE bytes per integer\n\
319 u[SIZE] unsigned decimal, SIZE bytes per integer\n\
320 x[SIZE] hexadecimal, SIZE bytes per integer\n\
322 SIZE is a number. For TYPE in doux, SIZE may also be C for\n\
323 sizeof(char), S for sizeof(short), I for sizeof(int) or L for\n\
324 sizeof(long). If TYPE is f, SIZE may also be F for sizeof(float), D\n\
325 for sizeof(double) or L for sizeof(long double).\n\
327 RADIX is d for decimal, o for octal, x for hexadecimal or n for none.\n\
328 BYTES is hexadecimal with 0x or 0X prefix, it is multiplied by 512\n\
329 with b suffix, by 1024 with k and by 1048576 with m. Adding a z suffix to\n\
330 any type adds a display of printable characters to the end of each line\n\
331 of output. -s without a number implies 3. -w without a number implies 32.\n\
332 By default, od uses -A o -t d2 -w 16.\n\
334 puts (_("\nReport bugs to <bug-textutils@gnu.org>."));
336 exit (status == 0 ? EXIT_SUCCESS : EXIT_FAILURE);
339 /* Compute the greatest common denominator of U and V
340 using Euclid's algorithm. */
343 gcd (unsigned int u, unsigned int v)
355 /* Compute the least common multiple of U and V. */
358 lcm (unsigned int u, unsigned int v)
360 unsigned int t = gcd (u, v);
367 print_s_char (off_t n_bytes, const char *block, const char *fmt_string)
370 for (i = n_bytes; i > 0; i--)
372 int tmp = (unsigned) *(const unsigned char *) block;
374 tmp -= SCHAR_MAX - SCHAR_MIN + 1;
375 assert (tmp <= SCHAR_MAX);
376 printf (fmt_string, tmp);
377 block += sizeof (unsigned char);
382 print_char (off_t n_bytes, const char *block, const char *fmt_string)
385 for (i = n_bytes; i > 0; i--)
387 unsigned int tmp = *(const unsigned char *) block;
388 printf (fmt_string, tmp);
389 block += sizeof (unsigned char);
394 print_s_short (off_t n_bytes, const char *block, const char *fmt_string)
397 for (i = n_bytes / sizeof (unsigned short); i > 0; i--)
399 int tmp = (unsigned) *(const unsigned short *) block;
401 tmp -= SHRT_MAX - SHRT_MIN + 1;
402 assert (tmp <= SHRT_MAX);
403 printf (fmt_string, tmp);
404 block += sizeof (unsigned short);
409 print_short (off_t n_bytes, const char *block, const char *fmt_string)
412 for (i = n_bytes / sizeof (unsigned short); i > 0; i--)
414 unsigned int tmp = *(const unsigned short *) block;
415 printf (fmt_string, tmp);
416 block += sizeof (unsigned short);
421 print_int (off_t n_bytes, const char *block, const char *fmt_string)
424 for (i = n_bytes / sizeof (unsigned int); i > 0; i--)
426 unsigned int tmp = *(const unsigned int *) block;
427 printf (fmt_string, tmp);
428 block += sizeof (unsigned int);
433 print_long (off_t n_bytes, const char *block, const char *fmt_string)
436 for (i = n_bytes / sizeof (unsigned long); i > 0; i--)
438 unsigned long tmp = *(const unsigned long *) block;
439 printf (fmt_string, tmp);
440 block += sizeof (unsigned long);
445 print_long_long (off_t n_bytes, const char *block, const char *fmt_string)
448 for (i = n_bytes / sizeof (ulonglong_t); i > 0; i--)
450 ulonglong_t tmp = *(const ulonglong_t *) block;
451 printf (fmt_string, tmp);
452 block += sizeof (ulonglong_t);
457 print_float (off_t n_bytes, const char *block, const char *fmt_string)
460 for (i = n_bytes / sizeof (float); i > 0; i--)
462 float tmp = *(const float *) block;
463 printf (fmt_string, tmp);
464 block += sizeof (float);
469 print_double (off_t n_bytes, const char *block, const char *fmt_string)
472 for (i = n_bytes / sizeof (double); i > 0; i--)
474 double tmp = *(const double *) block;
475 printf (fmt_string, tmp);
476 block += sizeof (double);
480 #ifdef HAVE_LONG_DOUBLE
482 print_long_double (off_t n_bytes, const char *block, const char *fmt_string)
485 for (i = n_bytes / sizeof (LONG_DOUBLE); i > 0; i--)
487 LONG_DOUBLE tmp = *(const LONG_DOUBLE *) block;
488 printf (fmt_string, tmp);
489 block += sizeof (LONG_DOUBLE);
496 dump_hexl_mode_trailer (off_t n_bytes, const char *block)
499 fputs (" >", stdout);
500 for (i = n_bytes; i > 0; i--)
502 unsigned int c = *(const unsigned char *) block;
503 unsigned int c2 = (ISPRINT(c) ? c : '.');
505 block += sizeof (unsigned char);
511 print_named_ascii (off_t n_bytes, const char *block,
512 const char *unused_fmt_string ATTRIBUTE_UNUSED)
515 for (i = n_bytes; i > 0; i--)
517 unsigned int c = *(const unsigned char *) block;
518 unsigned int masked_c = (0x7f & c);
524 else if (masked_c <= 040)
525 s = charname[masked_c];
528 sprintf (buf, " %c", masked_c);
533 block += sizeof (unsigned char);
538 print_ascii (off_t n_bytes, const char *block,
539 const char *unused_fmt_string ATTRIBUTE_UNUSED)
542 for (i = n_bytes; i > 0; i--)
544 unsigned int c = *(const unsigned char *) block;
583 sprintf (buf, (ISPRINT (c) ? " %c" : "%03o"), c);
584 s = (const char *) buf;
588 block += sizeof (unsigned char);
592 /* Convert a null-terminated (possibly zero-length) string S to an
593 unsigned long integer value. If S points to a non-digit set *P to S,
594 *VAL to 0, and return 0. Otherwise, accumulate the integer value of
595 the string of digits. If the string of digits represents a value
596 larger than ULONG_MAX, don't modify *VAL or *P and return nonzero.
597 Otherwise, advance *P to the first non-digit after S, set *VAL to
598 the result of the conversion and return zero. */
601 simple_strtoul (const char *s, const char **p, long unsigned int *val)
603 unsigned long int sum;
608 unsigned int c = *s++ - '0';
609 if (sum > (ULONG_MAX - c) / 10)
618 /* If S points to a single valid POSIX-style od format string, put
619 a description of that format in *TSPEC, make *NEXT point at the
620 character following the just-decoded format (if *NEXT is non-NULL),
621 and return zero. If S is not valid, don't modify *NEXT or *TSPEC,
622 give a diagnostic, and return nonzero. For example, if S were
623 "d4afL" *NEXT would be set to "afL" and *TSPEC would be
625 fmt = SIGNED_DECIMAL;
626 size = INT or LONG; (whichever integral_type_size[4] resolves to)
627 print_function = print_int; (assuming size == INT)
628 fmt_string = "%011d%c";
630 S_ORIG is solely for reporting errors. It should be the full format
635 decode_one_format (const char *s_orig, const char *s, const char **next,
638 enum size_spec size_spec;
639 unsigned long int size;
640 enum output_format fmt;
641 const char *pre_fmt_string;
643 void (*print_function) PARAMS ((off_t, const char *, const char *));
646 unsigned int field_width = 0;
648 assert (tspec != NULL);
662 size = sizeof (char);
667 size = sizeof (short);
677 size = sizeof (long int);
681 if (simple_strtoul (s, &p, &size) != 0)
683 /* The integer at P in S would overflow an unsigned long.
684 A digit string that long is sufficiently odd looking
685 that the following diagnostic is sufficient. */
686 error (0, 0, _("invalid type string `%s'"), s_orig);
693 if (MAX_INTEGRAL_TYPE_SIZE < size
694 || integral_type_size[size] == NO_SIZE)
696 error (0, 0, _("invalid type string `%s';\n\
697 this system doesn't provide a %lu-byte integral type"), s_orig, size);
705 #define FMT_BYTES_ALLOCATED 9
706 fmt_string = xmalloc (FMT_BYTES_ALLOCATED);
708 size_spec = integral_type_size[size];
713 fmt = SIGNED_DECIMAL;
714 sprintf (fmt_string, " %%%u%sd",
715 (field_width = bytes_to_signed_dec_digits[size]),
716 (size_spec == LONG ? "l"
717 : (size_spec == LONG_LONG ? "ll"
723 sprintf (fmt_string, " %%0%u%so",
724 (field_width = bytes_to_oct_digits[size]),
725 (size_spec == LONG ? "l" : ""));
729 fmt = UNSIGNED_DECIMAL;
730 sprintf (fmt_string, " %%%u%su",
731 (field_width = bytes_to_unsigned_dec_digits[size]),
732 (size_spec == LONG ? "l" : ""));
737 sprintf (fmt_string, " %%0%u%sx",
738 (field_width = bytes_to_hex_digits[size]),
739 (size_spec == LONG ? "l" : ""));
746 assert (strlen (fmt_string) < FMT_BYTES_ALLOCATED);
751 print_function = (fmt == SIGNED_DECIMAL
757 print_function = (fmt == SIGNED_DECIMAL
763 print_function = print_int;
767 print_function = print_long;
771 print_function = print_long_long;
780 fmt = FLOATING_POINT;
786 size = sizeof (float);
791 size = sizeof (double);
796 size = sizeof (LONG_DOUBLE);
800 if (simple_strtoul (s, &p, &size) != 0)
802 /* The integer at P in S would overflow an unsigned long.
803 A digit string that long is sufficiently odd looking
804 that the following diagnostic is sufficient. */
805 error (0, 0, _("invalid type string `%s'"), s_orig);
809 size = sizeof (double);
812 if (size > MAX_FP_TYPE_SIZE
813 || fp_type_size[size] == NO_SIZE)
815 error (0, 0, _("invalid type string `%s';\n\
816 this system doesn't provide a %lu-byte floating point type"), s_orig, size);
823 size_spec = fp_type_size[size];
828 print_function = print_float;
829 /* Don't use %#e; not all systems support it. */
830 pre_fmt_string = " %%%d.%de";
831 fmt_string = xmalloc (strlen (pre_fmt_string));
832 sprintf (fmt_string, pre_fmt_string,
833 (field_width = FLT_DIG + 8), FLT_DIG);
837 print_function = print_double;
838 pre_fmt_string = " %%%d.%de";
839 fmt_string = xmalloc (strlen (pre_fmt_string));
840 sprintf (fmt_string, pre_fmt_string,
841 (field_width = DBL_DIG + 8), DBL_DIG);
844 #ifdef HAVE_LONG_DOUBLE
845 case FLOAT_LONG_DOUBLE:
846 print_function = print_long_double;
847 pre_fmt_string = " %%%d.%dLe";
848 fmt_string = xmalloc (strlen (pre_fmt_string));
849 sprintf (fmt_string, pre_fmt_string,
850 (field_width = LDBL_DIG + 8), LDBL_DIG);
861 fmt = NAMED_CHARACTER;
864 print_function = print_named_ascii;
873 print_function = print_ascii;
878 error (0, 0, _("invalid character `%c' in type string `%s'"),
883 tspec->size = size_spec;
885 tspec->print_function = print_function;
886 tspec->fmt_string = fmt_string;
888 tspec->field_width = field_width;
889 tspec->hexl_mode_trailer = (*s == 'z');
890 if (tspec->hexl_mode_trailer)
899 /* Given a list of one or more input filenames FILE_LIST, set the global
900 file pointer IN_STREAM and the global string INPUT_FILENAME to the
901 first one that can be successfully opened. Modify FILE_LIST to
902 reference the next filename in the list. A file name of "-" is
903 interpreted as standard input. If any file open fails, give an error
904 message and return nonzero. */
907 open_next_file (void)
913 input_filename = *file_list;
914 if (input_filename == NULL)
918 if (STREQ (input_filename, "-"))
920 input_filename = _("standard input");
926 in_stream = fopen (input_filename, "r");
927 if (in_stream == NULL)
929 error (0, errno, "%s", input_filename);
934 while (in_stream == NULL);
936 if (limit_bytes_to_format && !flag_dump_strings)
937 SETVBUF (in_stream, NULL, _IONBF, 0);
938 SET_BINARY (fileno (in_stream));
943 /* Test whether there have been errors on in_stream, and close it if
944 it is not standard input. Return nonzero if there has been an error
945 on in_stream or stdout; return zero otherwise. This function will
946 report more than one error only if both a read and a write error
950 check_and_close (void)
954 if (in_stream != NULL)
956 if (ferror (in_stream))
958 error (0, errno, "%s", input_filename);
959 if (in_stream != stdin)
963 else if (in_stream != stdin && fclose (in_stream) == EOF)
965 error (0, errno, "%s", input_filename);
974 error (0, errno, _("standard output"));
981 /* Decode the POSIX-style od format string S. Append the decoded
982 representation to the global array SPEC, reallocating SPEC if
983 necessary. Return zero if S is valid, nonzero otherwise. */
986 decode_format_string (const char *s)
988 const char *s_orig = s;
996 if (decode_one_format (s_orig, s, &next, &tspec))
1002 if (n_specs >= n_specs_allocated)
1004 n_specs_allocated = 1 + (3 * n_specs_allocated) / 2;
1005 spec = (struct tspec *) xrealloc ((char *) spec,
1007 * sizeof (struct tspec)));
1010 memcpy ((char *) &spec[n_specs], (char *) &tspec,
1011 sizeof (struct tspec));
1018 /* Given a list of one or more input filenames FILE_LIST, set the global
1019 file pointer IN_STREAM to position N_SKIP in the concatenation of
1020 those files. If any file operation fails or if there are fewer than
1021 N_SKIP bytes in the combined input, give an error message and return
1022 nonzero. When possible, use seek rather than read operations to
1023 advance IN_STREAM. */
1033 while (in_stream != NULL) /* EOF. */
1035 struct stat file_stats;
1037 /* First try seeking. For large offsets, this extra work is
1038 worthwhile. If the offset is below some threshold it may be
1039 more efficient to move the pointer by reading. There are two
1040 issues when trying to seek:
1041 - the file must be seekable.
1042 - before seeking to the specified position, make sure
1043 that the new position is in the current file.
1044 Try to do that by getting file's size using fstat.
1045 But that will work only for regular files. */
1047 if (fstat (fileno (in_stream), &file_stats) == 0)
1049 /* The st_size field is valid only for regular files
1050 (and for symbolic links, which cannot occur here).
1051 If the number of bytes left to skip is at least
1052 as large as the size of the current file, we can
1053 decrement n_skip and go on to the next file. */
1055 if (S_ISREG (file_stats.st_mode) && file_stats.st_size <= n_skip)
1057 n_skip -= file_stats.st_size;
1060 /* If the number of bytes left to skip is less than the size
1061 of the current file, try seeking to the correct offset. */
1063 else if (S_ISREG (file_stats.st_mode)
1064 && 0 <= lseek (fileno (in_stream), n_skip, SEEK_CUR))
1069 /* If seek didn't work or wasn't attempted,
1070 position the file pointer by reading. */
1075 size_t n_bytes_read, n_bytes_to_read = BUFSIZ;
1079 if (n_skip < n_bytes_to_read)
1080 n_bytes_to_read = n_skip;
1081 n_bytes_read = fread (buf, 1, n_bytes_to_read, in_stream);
1082 n_skip -= n_bytes_read;
1083 if (n_bytes_read != n_bytes_to_read)
1092 else /* cannot fstat() file */
1094 error (0, errno, "%s", input_filename);
1098 err |= check_and_close ();
1100 err |= open_next_file ();
1104 error (EXIT_FAILURE, 0, _("cannot skip past end of combined input"));
1110 format_address_none (off_t address ATTRIBUTE_UNUSED, char c ATTRIBUTE_UNUSED)
1115 format_address_std (off_t address, char c)
1117 char buf[MAX_ADDRESS_LENGTH + 2];
1118 char *p = buf + sizeof buf;
1123 pbound = p - address_pad_len;
1125 /* Use a special case of the code for each base. This is measurably
1126 faster than generic code. */
1127 switch (address_base)
1131 *--p = '0' + (address & 7);
1132 while ((address >>= 3) != 0);
1137 *--p = '0' + (address % 10);
1138 while ((address /= 10) != 0);
1143 *--p = "0123456789abcdef"[address & 15];
1144 while ((address >>= 4) != 0);
1155 format_address_paren (off_t address, char c)
1158 format_address_std (address, ')');
1163 format_address_label (off_t address, char c)
1165 format_address_std (address, ' ');
1166 format_address_paren (address + pseudo_offset, c);
1169 /* Write N_BYTES bytes from CURR_BLOCK to standard output once for each
1170 of the N_SPEC format specs. CURRENT_OFFSET is the byte address of
1171 CURR_BLOCK in the concatenation of input files, and it is printed
1172 (optionally) only before the output line associated with the first
1173 format spec. When duplicate blocks are being abbreviated, the output
1174 for a sequence of identical input blocks is the output for the first
1175 block followed by an asterisk alone on a line. It is valid to compare
1176 the blocks PREV_BLOCK and CURR_BLOCK only when N_BYTES == BYTES_PER_BLOCK.
1177 That condition may be false only for the last input block -- and then
1178 only when it has not been padded to length BYTES_PER_BLOCK. */
1181 write_block (off_t current_offset, off_t n_bytes,
1182 const char *prev_block, const char *curr_block)
1184 static int first = 1;
1185 static int prev_pair_equal = 0;
1187 #define EQUAL_BLOCKS(b1, b2) (memcmp ((b1), (b2), bytes_per_block) == 0)
1189 if (abbreviate_duplicate_blocks
1190 && !first && n_bytes == bytes_per_block
1191 && EQUAL_BLOCKS (prev_block, curr_block))
1193 if (prev_pair_equal)
1195 /* The two preceding blocks were equal, and the current
1196 block is the same as the last one, so print nothing. */
1201 prev_pair_equal = 1;
1208 prev_pair_equal = 0;
1209 for (i = 0; i < n_specs; i++)
1212 format_address (current_offset, '\0');
1214 printf ("%*s", address_pad_len, "");
1215 (*spec[i].print_function) (n_bytes, curr_block, spec[i].fmt_string);
1216 if (spec[i].hexl_mode_trailer)
1218 /* space-pad out to full line width, then dump the trailer */
1219 int datum_width = width_bytes[spec[i].size];
1220 int blank_fields = (bytes_per_block - n_bytes) / datum_width;
1221 int field_width = spec[i].field_width + 1;
1222 printf ("%*s", blank_fields * field_width, "");
1223 dump_hexl_mode_trailer (n_bytes, curr_block);
1231 /* Read a single byte into *C from the concatenation of the input files
1232 named in the global array FILE_LIST. On the first call to this
1233 function, the global variable IN_STREAM is expected to be an open
1234 stream associated with the input file INPUT_FILENAME. If IN_STREAM
1235 is at end-of-file, close it and update the global variables IN_STREAM
1236 and INPUT_FILENAME so they correspond to the next file in the list.
1237 Then try to read a byte from the newly opened file. Repeat if
1238 necessary until EOF is reached for the last file in FILE_LIST, then
1239 set *C to EOF and return. Subsequent calls do likewise. The return
1240 value is nonzero if any errors occured, zero otherwise. */
1249 while (in_stream != NULL) /* EOF. */
1251 *c = fgetc (in_stream);
1256 err |= check_and_close ();
1258 err |= open_next_file ();
1264 /* Read N bytes into BLOCK from the concatenation of the input files
1265 named in the global array FILE_LIST. On the first call to this
1266 function, the global variable IN_STREAM is expected to be an open
1267 stream associated with the input file INPUT_FILENAME. If all N
1268 bytes cannot be read from IN_STREAM, close IN_STREAM and update
1269 the global variables IN_STREAM and INPUT_FILENAME. Then try to
1270 read the remaining bytes from the newly opened file. Repeat if
1271 necessary until EOF is reached for the last file in FILE_LIST.
1272 On subsequent calls, don't modify BLOCK and return zero. Set
1273 *N_BYTES_IN_BUFFER to the number of bytes read. If an error occurs,
1274 it will be detected through ferror when the stream is about to be
1275 closed. If there is an error, give a message but continue reading
1276 as usual and return nonzero. Otherwise return zero. */
1279 read_block (size_t n, char *block, size_t *n_bytes_in_buffer)
1283 assert (0 < n && n <= bytes_per_block);
1285 *n_bytes_in_buffer = 0;
1290 while (in_stream != NULL) /* EOF. */
1295 n_needed = n - *n_bytes_in_buffer;
1296 n_read = fread (block + *n_bytes_in_buffer, 1, n_needed, in_stream);
1298 *n_bytes_in_buffer += n_read;
1300 if (n_read == n_needed)
1303 err |= check_and_close ();
1305 err |= open_next_file ();
1311 /* Return the least common multiple of the sizes associated
1312 with the format specs. */
1320 for (i = 0; i < n_specs; i++)
1321 l_c_m = lcm (l_c_m, width_bytes[(int) spec[i].size]);
1325 /* If S is a valid pre-POSIX offset specification with an optional leading '+'
1326 return the offset it denotes. Otherwise, return -1. */
1329 parse_old_offset (const char *s)
1333 enum strtol_error s_err;
1339 /* Skip over any leading '+'. */
1343 /* Determine the radix we'll use to interpret S. If there is a `.',
1344 it's decimal, otherwise, if the string begins with `0X'or `0x',
1345 it's hexadecimal, else octal. */
1346 if (strchr (s, '.') != NULL)
1350 if (s[0] == '0' && (s[1] == 'x' || s[1] == 'X'))
1356 s_err = xstrtoumax (s, NULL, radix, &tmp, "Bb");
1357 if (s_err != LONGINT_OK)
1359 STRTOL_FAIL_WARN (s, _("old-style offset"), s_err);
1362 if (OFF_T_MAX < tmp)
1363 error (EXIT_FAILURE, 0,
1364 _("%s is larger than the maximum file size on this system"), s);
1369 /* Read a chunk of size BYTES_PER_BLOCK from the input files, write the
1370 formatted block to standard output, and repeat until the specified
1371 maximum number of bytes has been read or until all input has been
1372 processed. If the last block read is smaller than BYTES_PER_BLOCK
1373 and its size is not a multiple of the size associated with a format
1374 spec, extend the input block with zero bytes until its length is a
1375 multiple of all format spec sizes. Write the final block. Finally,
1376 write on a line by itself the offset of the byte after the last byte
1377 read. Accumulate return values from calls to read_block and
1378 check_and_close, and if any was nonzero, return nonzero.
1379 Otherwise, return zero. */
1385 off_t current_offset;
1386 off_t end_offset IF_LINT (= 0);
1389 size_t n_bytes_read;
1391 block[0] = (char *) alloca (bytes_per_block);
1392 block[1] = (char *) alloca (bytes_per_block);
1394 current_offset = n_bytes_to_skip;
1398 if (limit_bytes_to_format)
1400 end_offset = n_bytes_to_skip + max_bytes_to_format;
1405 if (current_offset >= end_offset)
1410 n_needed = MIN (end_offset - current_offset,
1411 (off_t) bytes_per_block);
1412 err |= read_block (n_needed, block[idx], &n_bytes_read);
1413 if (n_bytes_read < bytes_per_block)
1415 assert (n_bytes_read == bytes_per_block);
1416 write_block (current_offset, n_bytes_read,
1417 block[!idx], block[idx]);
1418 current_offset += n_bytes_read;
1426 err |= read_block (bytes_per_block, block[idx], &n_bytes_read);
1427 if (n_bytes_read < bytes_per_block)
1429 assert (n_bytes_read == bytes_per_block);
1430 write_block (current_offset, n_bytes_read,
1431 block[!idx], block[idx]);
1432 current_offset += n_bytes_read;
1437 if (n_bytes_read > 0)
1440 size_t bytes_to_write;
1444 /* Make bytes_to_write the smallest multiple of l_c_m that
1445 is at least as large as n_bytes_read. */
1446 bytes_to_write = l_c_m * ((n_bytes_read + l_c_m - 1) / l_c_m);
1448 memset (block[idx] + n_bytes_read, 0, bytes_to_write - n_bytes_read);
1449 write_block (current_offset, bytes_to_write,
1450 block[!idx], block[idx]);
1451 current_offset += n_bytes_read;
1454 format_address (current_offset, '\n');
1456 if (limit_bytes_to_format && current_offset >= end_offset)
1457 err |= check_and_close ();
1462 /* STRINGS mode. Find each "string constant" in the input.
1463 A string constant is a run of at least `string_min' ASCII
1464 graphic (or formatting) characters terminated by a null.
1465 Based on a function written by Richard Stallman for a
1466 pre-POSIX version of od. Return nonzero if an error
1467 occurs. Otherwise, return zero. */
1472 size_t bufsize = MAX (100, string_min);
1473 char *buf = xmalloc (bufsize);
1474 off_t address = n_bytes_to_skip;
1483 /* See if the next `string_min' chars are all printing chars. */
1486 if (limit_bytes_to_format
1487 && address >= (n_bytes_to_skip + max_bytes_to_format - string_min))
1490 for (i = 0; i < string_min; i++)
1492 err |= read_char (&c);
1500 /* Found a non-printing. Try again starting with next char. */
1505 /* We found a run of `string_min' printable characters.
1506 Now see if it is terminated with a null byte. */
1507 while (!limit_bytes_to_format
1508 || address < n_bytes_to_skip + max_bytes_to_format)
1512 bufsize = 1 + 3 * bufsize / 2;
1513 buf = xrealloc (buf, bufsize);
1515 err |= read_char (&c);
1523 break; /* It is; print this string. */
1525 goto tryline; /* It isn't; give up on this string. */
1526 buf[i++] = c; /* String continues; store it all. */
1529 /* If we get here, the string is all printable and null-terminated,
1530 so print it. It is all in `buf' and `i' is its length. */
1532 format_address (address - i - 1, ' ');
1534 for (i = 0; (c = buf[i]); i++)
1539 fputs ("\\a", stdout);
1543 fputs ("\\b", stdout);
1547 fputs ("\\f", stdout);
1551 fputs ("\\n", stdout);
1555 fputs ("\\r", stdout);
1559 fputs ("\\t", stdout);
1563 fputs ("\\v", stdout);
1573 /* We reach this point only if we search through
1574 (max_bytes_to_format - string_min) bytes before reaching EOF. */
1578 err |= check_and_close ();
1583 main (int argc, char **argv)
1589 size_t desired_width IF_LINT (= 0);
1590 int width_specified = 0;
1591 int n_failed_decodes = 0;
1594 /* The old-style `pseudo starting address' to be printed in parentheses
1595 after any true address. */
1596 off_t pseudo_start IF_LINT (= 0);
1598 program_name = argv[0];
1599 setlocale (LC_ALL, "");
1600 bindtextdomain (PACKAGE, LOCALEDIR);
1601 textdomain (PACKAGE);
1603 atexit (close_stdout);
1607 for (i = 0; i <= MAX_INTEGRAL_TYPE_SIZE; i++)
1608 integral_type_size[i] = NO_SIZE;
1610 integral_type_size[sizeof (char)] = CHAR;
1611 integral_type_size[sizeof (short int)] = SHORT;
1612 integral_type_size[sizeof (int)] = INT;
1613 integral_type_size[sizeof (long int)] = LONG;
1614 #if HAVE_UNSIGNED_LONG_LONG
1615 integral_type_size[sizeof (ulonglong_t)] = LONG_LONG;
1618 for (i = 0; i <= MAX_FP_TYPE_SIZE; i++)
1619 fp_type_size[i] = NO_SIZE;
1621 fp_type_size[sizeof (float)] = FLOAT_SINGLE;
1622 /* The array entry for `double' is filled in after that for LONG_DOUBLE
1623 so that if `long double' is the same type or if long double isn't
1624 supported FLOAT_LONG_DOUBLE will never be used. */
1625 fp_type_size[sizeof (LONG_DOUBLE)] = FLOAT_LONG_DOUBLE;
1626 fp_type_size[sizeof (double)] = FLOAT_DOUBLE;
1629 n_specs_allocated = 5;
1630 spec = (struct tspec *) xmalloc (n_specs_allocated * sizeof (struct tspec));
1632 format_address = format_address_std;
1634 address_pad_len = 7;
1635 flag_dump_strings = 0;
1637 while ((c = getopt_long (argc, argv, "abcdfhilos::xw::A:j:N:t:v",
1638 long_options, NULL)) != -1)
1641 enum strtol_error s_err;
1652 format_address = format_address_std;
1654 address_pad_len = 7;
1657 format_address = format_address_std;
1659 address_pad_len = 7;
1662 format_address = format_address_std;
1664 address_pad_len = 6;
1667 format_address = format_address_none;
1668 address_pad_len = 0;
1671 error (EXIT_FAILURE, 0,
1672 _("invalid output address radix `%c'; \
1673 it must be one character from [doxn]"),
1680 s_err = xstrtoumax (optarg, NULL, 0, &tmp, "bkm");
1681 n_bytes_to_skip = tmp;
1682 if (s_err != LONGINT_OK)
1683 STRTOL_FATAL_ERROR (optarg, _("skip argument"), s_err);
1687 limit_bytes_to_format = 1;
1689 s_err = xstrtoumax (optarg, NULL, 0, &tmp, "bkm");
1690 max_bytes_to_format = tmp;
1691 if (s_err != LONGINT_OK)
1692 STRTOL_FATAL_ERROR (optarg, _("limit argument"), s_err);
1694 if (OFF_T_MAX < tmp)
1695 error (EXIT_FAILURE, 0,
1696 _("%s is larger than the maximum file size on this system"),
1705 s_err = xstrtoumax (optarg, NULL, 0, &tmp, "bkm");
1706 if (s_err != LONGINT_OK)
1707 STRTOL_FATAL_ERROR (optarg, _("minimum string length"), s_err);
1709 /* The minimum string length may be no larger than SIZE_MAX,
1710 since we may allocate a buffer of this size. */
1712 error (EXIT_FAILURE, 0, _("%s is too large"), optarg);
1716 flag_dump_strings = 1;
1720 if (decode_format_string (optarg))
1725 abbreviate_duplicate_blocks = 0;
1732 /* The next several cases map the old, pre-POSIX format
1733 specification options to the corresponding POSIX format
1734 specs. GNU od accepts any combination of old- and
1735 new-style options. Format specification options accumulate. */
1737 #define CASE_OLD_ARG(old_char,new_string) \
1740 if (decode_format_string (new_string)) \
1741 ++n_failed_decodes; \
1745 CASE_OLD_ARG ('a', "a");
1746 CASE_OLD_ARG ('b', "oC");
1747 CASE_OLD_ARG ('c', "c");
1748 CASE_OLD_ARG ('d', "u2");
1749 CASE_OLD_ARG ('f', "fF");
1750 CASE_OLD_ARG ('h', "x2");
1751 CASE_OLD_ARG ('i', "d2");
1752 CASE_OLD_ARG ('l', "d4");
1753 CASE_OLD_ARG ('o', "o2");
1754 CASE_OLD_ARG ('x', "x2");
1759 width_specified = 1;
1767 s_err = xstrtoumax (optarg, NULL, 10, &w_tmp, "");
1768 if (s_err != LONGINT_OK)
1769 STRTOL_FATAL_ERROR (optarg, _("width specification"), s_err);
1770 if (SIZE_MAX < w_tmp)
1771 error (EXIT_FAILURE, 0, _("%s is too large"), optarg);
1772 desired_width = w_tmp;
1776 case_GETOPT_HELP_CHAR;
1778 case_GETOPT_VERSION_CHAR (PROGRAM_NAME, AUTHORS);
1786 if (n_failed_decodes > 0)
1787 exit (EXIT_FAILURE);
1789 if (flag_dump_strings && n_specs > 0)
1790 error (EXIT_FAILURE, 0,
1791 _("no type may be specified when dumping strings"));
1793 n_files = argc - optind;
1795 /* If the --backward-compatible option is used, there may be from
1796 0 to 3 remaining command line arguments; handle each case
1798 od [file] [[+]offset[.][b] [[+]label[.][b]]]
1799 The offset and pseudo_start have the same syntax. */
1807 if ((offset = parse_old_offset (argv[optind])) >= 0)
1809 n_bytes_to_skip = offset;
1814 else if (n_files == 2)
1817 if ((o1 = parse_old_offset (argv[optind])) >= 0
1818 && (o2 = parse_old_offset (argv[optind + 1])) >= 0)
1820 n_bytes_to_skip = o1;
1821 flag_pseudo_start = 1;
1826 else if ((o2 = parse_old_offset (argv[optind + 1])) >= 0)
1828 n_bytes_to_skip = o2;
1830 argv[optind + 1] = argv[optind];
1836 _("invalid second operand in compatibility mode `%s'"),
1841 else if (n_files == 3)
1844 if ((o1 = parse_old_offset (argv[optind + 1])) >= 0
1845 && (o2 = parse_old_offset (argv[optind + 2])) >= 0)
1847 n_bytes_to_skip = o1;
1848 flag_pseudo_start = 1;
1850 argv[optind + 2] = argv[optind];
1857 _("in compatibility mode, the last two arguments must be offsets"));
1861 else if (n_files > 3)
1864 _("compatibility mode supports at most three arguments"));
1868 if (flag_pseudo_start)
1870 if (format_address == format_address_none)
1873 address_pad_len = 7;
1874 format_address = format_address_paren;
1877 format_address = format_address_label;
1883 if (decode_one_format ("o2", "o2", NULL, &(spec[0])))
1885 /* This happens on Cray systems that don't have a 2-byte
1887 exit (EXIT_FAILURE);
1895 /* Set the global pointer FILE_LIST so that it
1896 references the first file-argument on the command-line. */
1898 file_list = (char const *const *) &argv[optind];
1902 /* No files were listed on the command line.
1903 Set the global pointer FILE_LIST so that it
1904 references the null-terminated list of one name: "-". */
1906 file_list = default_file_list;
1909 /* open the first input file */
1910 err |= open_next_file ();
1911 if (in_stream == NULL)
1914 /* skip over any unwanted header bytes */
1915 err |= skip (n_bytes_to_skip);
1916 if (in_stream == NULL)
1919 pseudo_offset = (flag_pseudo_start ? pseudo_start - n_bytes_to_skip : 0);
1921 /* Compute output block length. */
1924 if (width_specified)
1926 if (desired_width != 0 && desired_width % l_c_m == 0)
1927 bytes_per_block = desired_width;
1930 error (0, 0, _("warning: invalid width %lu; using %d instead"),
1931 (unsigned long) desired_width, l_c_m);
1932 bytes_per_block = l_c_m;
1937 if (l_c_m < DEFAULT_BYTES_PER_BLOCK)
1938 bytes_per_block = l_c_m * (DEFAULT_BYTES_PER_BLOCK / l_c_m);
1940 bytes_per_block = l_c_m;
1944 for (i = 0; i < n_specs; i++)
1946 printf (_("%d: fmt=\"%s\" width=%d\n"),
1947 i, spec[i].fmt_string, width_bytes[spec[i].size]);
1951 err |= (flag_dump_strings ? dump_strings () : dump ());
1955 if (have_read_stdin && fclose (stdin) == EOF)
1956 error (EXIT_FAILURE, errno, _("standard input"));
1958 exit (err == 0 ? EXIT_SUCCESS : EXIT_FAILURE);