1 /* od -- dump files in octal and other formats
2 Copyright (C) 92, 1995-2000 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 /* A printf control string for printing a file offset. */
154 static const char *output_address_fmt_string;
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 /* Space for a normal address, a space, a pseudo address, parentheses
161 around the pseudo address, and a trailing zero byte. */
162 static char address_fmt_buffer[2 * MAX_ADDRESS_LENGTH + 4];
163 static char address_pad[MAX_ADDRESS_LENGTH + 1];
165 static size_t string_min;
166 static int flag_dump_strings;
168 /* Non-zero if we should recognize the pre-POSIX 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 long int flag_pseudo_start;
176 /* The difference between the old-style pseudo starting address and
177 the number of bytes to skip. */
178 static long int pseudo_offset;
180 /* Function to format an address and optionally an additional parenthesized
181 pseudo-address; it returns the formatted string. */
182 static const char *(*format_address) PARAMS ((off_t));
184 /* The number of input bytes to skip before formatting and writing. */
185 static off_t n_bytes_to_skip = 0;
187 /* When nonzero, MAX_BYTES_TO_FORMAT is the maximum number of bytes
188 to be read and formatted. Otherwise all input is formatted. */
189 static int limit_bytes_to_format = 0;
191 /* The maximum number of bytes that will be formatted. This
192 value is used only when LIMIT_BYTES_TO_FORMAT is nonzero. */
193 static off_t max_bytes_to_format;
195 /* When nonzero and two or more consecutive blocks are equal, format
196 only the first block and output an asterisk alone on the following
197 line to indicate that identical blocks have been elided. */
198 static int abbreviate_duplicate_blocks = 1;
200 /* An array of specs describing how to format each input block. */
201 static struct tspec *spec;
203 /* The number of format specs. */
204 static unsigned int n_specs;
206 /* The allocated length of SPEC. */
207 static unsigned int n_specs_allocated;
209 /* The number of input bytes formatted per output line. It must be
210 a multiple of the least common multiple of the sizes associated with
211 the specified output types. It should be as large as possible, but
212 no larger than 16 -- unless specified with the -w option. */
213 static unsigned int bytes_per_block;
215 /* Human-readable representation of *file_list (for error messages).
216 It differs from *file_list only when *file_list is "-". */
217 static char const *input_filename;
219 /* A NULL-terminated list of the file-arguments from the command line.
220 If no file-arguments were specified, this variable is initialized
222 static char const *const *file_list;
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 #ifdef HAVE_UNSIGNED_LONG_LONG
231 # define LONGEST_INTEGRAL_TYPE unsigned long long
233 # define LONGEST_INTEGRAL_TYPE long int
236 #define MAX_INTEGRAL_TYPE_SIZE sizeof(LONGEST_INTEGRAL_TYPE)
237 static enum size_spec integral_type_size[MAX_INTEGRAL_TYPE_SIZE + 1];
239 #define MAX_FP_TYPE_SIZE sizeof(LONG_DOUBLE)
240 static enum size_spec fp_type_size[MAX_FP_TYPE_SIZE + 1];
242 static struct option const long_options[] =
245 {"skip-bytes", required_argument, NULL, 'j'},
246 {"address-radix", required_argument, NULL, 'A'},
247 {"read-bytes", required_argument, NULL, 'N'},
248 {"format", required_argument, NULL, 't'},
249 {"output-duplicates", no_argument, NULL, 'v'},
251 /* non-POSIX options. */
252 {"strings", optional_argument, NULL, 's'},
253 {"traditional", no_argument, NULL, 'B'},
254 {"width", optional_argument, NULL, 'w'},
256 {GETOPT_HELP_OPTION_DECL},
257 {GETOPT_VERSION_OPTION_DECL},
265 fprintf (stderr, _("Try `%s --help' for more information.\n"),
270 Usage: %s [OPTION]... [FILE]...\n\
271 or: %s --traditional [FILE] [[+]OFFSET [[+]LABEL]]\n\
273 program_name, program_name);
275 Write an unambiguous representation, octal bytes by default, of FILE\n\
276 to standard output. With no FILE, or when FILE is -, read standard input.\n\
278 -A, --address-radix=RADIX decide how file offsets are printed\n\
279 -j, --skip-bytes=BYTES skip BYTES input bytes first on each file\n\
280 -N, --read-bytes=BYTES limit dump to BYTES input bytes per file\n\
281 -s, --strings[=BYTES] output strings of at least BYTES graphic chars\n\
282 -t, --format=TYPE select output format or formats\n\
283 -v, --output-duplicates do not use * to mark line suppression\n\
284 -w, --width[=BYTES] output BYTES bytes per output line\n\
285 --traditional accept arguments in pre-POSIX form\n\
286 --help display this help and exit\n\
287 --version output version information and exit\n\
289 Pre-POSIX format specifications may be intermixed, they accumulate:\n\
290 -a same as -t a, select named characters\n\
291 -b same as -t oC, select octal bytes\n\
292 -c same as -t c, select ASCII characters or backslash escapes\n\
293 -d same as -t u2, select unsigned decimal shorts\n\
294 -f same as -t fF, select floats\n\
295 -h same as -t x2, select hexadecimal shorts\n\
296 -i same as -t d2, select decimal shorts\n\
297 -l same as -t d4, select decimal longs\n\
298 -o same as -t o2, select octal shorts\n\
299 -x same as -t x2, select hexadecimal shorts\n\
303 For older syntax (second call format), OFFSET means -j OFFSET. LABEL\n\
304 is the pseudo-address at first byte printed, incremented when dump is\n\
305 progressing. For OFFSET and LABEL, a 0x or 0X prefix indicates\n\
306 hexadecimal, suffixes maybe . for octal and b multiply by 512.\n\
308 TYPE is made up of one or more of these specifications:\n\
311 c ASCII character or backslash escape\n\
312 d[SIZE] signed decimal, SIZE bytes per integer\n\
313 f[SIZE] floating point, SIZE bytes per integer\n\
314 o[SIZE] octal, SIZE bytes per integer\n\
315 u[SIZE] unsigned decimal, SIZE bytes per integer\n\
316 x[SIZE] hexadecimal, SIZE bytes per integer\n\
318 SIZE is a number. For TYPE in doux, SIZE may also be C for\n\
319 sizeof(char), S for sizeof(short), I for sizeof(int) or L for\n\
320 sizeof(long). If TYPE is f, SIZE may also be F for sizeof(float), D\n\
321 for sizeof(double) or L for sizeof(long double).\n\
323 RADIX is d for decimal, o for octal, x for hexadecimal or n for none.\n\
324 BYTES is hexadecimal with 0x or 0X prefix, it is multiplied by 512\n\
325 with b suffix, by 1024 with k and by 1048576 with m. Adding a z suffix to\n\
326 any type adds a display of printable characters to the end of each line\n\
327 of output. -s without a number implies 3. -w without a number implies 32.\n\
328 By default, od uses -A o -t d2 -w 16.\n\
330 puts (_("\nReport bugs to <bug-textutils@gnu.org>."));
332 exit (status == 0 ? EXIT_SUCCESS : EXIT_FAILURE);
335 /* Compute the greatest common denominator of U and V
336 using Euclid's algorithm. */
339 gcd (unsigned int u, unsigned int v)
351 /* Compute the least common multiple of U and V. */
354 lcm (unsigned int u, unsigned int v)
356 unsigned int t = gcd (u, v);
363 print_s_char (off_t n_bytes, const char *block, const char *fmt_string)
366 for (i = n_bytes; i > 0; i--)
368 int tmp = (unsigned) *(const unsigned char *) block;
370 tmp -= SCHAR_MAX - SCHAR_MIN + 1;
371 assert (tmp <= SCHAR_MAX);
372 printf (fmt_string, tmp);
373 block += sizeof (unsigned char);
378 print_char (off_t n_bytes, const char *block, const char *fmt_string)
381 for (i = n_bytes; i > 0; i--)
383 unsigned int tmp = *(const unsigned char *) block;
384 printf (fmt_string, tmp);
385 block += sizeof (unsigned char);
390 print_s_short (off_t n_bytes, const char *block, const char *fmt_string)
393 for (i = n_bytes / sizeof (unsigned short); i > 0; i--)
395 int tmp = (unsigned) *(const unsigned short *) block;
397 tmp -= SHRT_MAX - SHRT_MIN + 1;
398 assert (tmp <= SHRT_MAX);
399 printf (fmt_string, tmp);
400 block += sizeof (unsigned short);
405 print_short (off_t n_bytes, const char *block, const char *fmt_string)
408 for (i = n_bytes / sizeof (unsigned short); i > 0; i--)
410 unsigned int tmp = *(const unsigned short *) block;
411 printf (fmt_string, tmp);
412 block += sizeof (unsigned short);
417 print_int (off_t n_bytes, const char *block, const char *fmt_string)
420 for (i = n_bytes / sizeof (unsigned int); i > 0; i--)
422 unsigned int tmp = *(const unsigned int *) block;
423 printf (fmt_string, tmp);
424 block += sizeof (unsigned int);
429 print_long (off_t n_bytes, const char *block, const char *fmt_string)
432 for (i = n_bytes / sizeof (unsigned long); i > 0; i--)
434 unsigned long tmp = *(const unsigned long *) block;
435 printf (fmt_string, tmp);
436 block += sizeof (unsigned long);
440 #ifdef HAVE_UNSIGNED_LONG_LONG
442 print_long_long (off_t n_bytes, const char *block, const char *fmt_string)
445 for (i = n_bytes / sizeof (unsigned long long); i > 0; i--)
447 unsigned long long tmp = *(const unsigned long long *) block;
448 printf (fmt_string, tmp);
449 block += sizeof (unsigned long long);
455 print_float (off_t n_bytes, const char *block, const char *fmt_string)
458 for (i = n_bytes / sizeof (float); i > 0; i--)
460 float tmp = *(const float *) block;
461 printf (fmt_string, tmp);
462 block += sizeof (float);
467 print_double (off_t n_bytes, const char *block, const char *fmt_string)
470 for (i = n_bytes / sizeof (double); i > 0; i--)
472 double tmp = *(const double *) block;
473 printf (fmt_string, tmp);
474 block += sizeof (double);
478 #ifdef HAVE_LONG_DOUBLE
480 print_long_double (off_t n_bytes, const char *block, const char *fmt_string)
483 for (i = n_bytes / sizeof (LONG_DOUBLE); i > 0; i--)
485 LONG_DOUBLE tmp = *(const LONG_DOUBLE *) block;
486 printf (fmt_string, tmp);
487 block += sizeof (LONG_DOUBLE);
494 dump_hexl_mode_trailer (off_t n_bytes, const char *block)
497 fputs (" >", stdout);
498 for (i = n_bytes; i > 0; i--)
500 unsigned int c = *(const unsigned char *) block;
501 unsigned int c2 = (ISPRINT(c) ? c : '.');
503 block += sizeof (unsigned char);
509 print_named_ascii (off_t n_bytes, const char *block,
510 const char *unused_fmt_string ATTRIBUTE_UNUSED)
513 for (i = n_bytes; i > 0; i--)
515 unsigned int c = *(const unsigned char *) block;
516 unsigned int masked_c = (0x7f & c);
522 else if (masked_c <= 040)
523 s = charname[masked_c];
526 sprintf (buf, " %c", masked_c);
531 block += sizeof (unsigned char);
536 print_ascii (off_t n_bytes, const char *block,
537 const char *unused_fmt_string ATTRIBUTE_UNUSED)
540 for (i = n_bytes; i > 0; i--)
542 unsigned int c = *(const unsigned char *) block;
581 sprintf (buf, (ISPRINT (c) ? " %c" : "%03o"), c);
582 s = (const char *) buf;
586 block += sizeof (unsigned char);
590 /* Convert a null-terminated (possibly zero-length) string S to an
591 unsigned long integer value. If S points to a non-digit set *P to S,
592 *VAL to 0, and return 0. Otherwise, accumulate the integer value of
593 the string of digits. If the string of digits represents a value
594 larger than ULONG_MAX, don't modify *VAL or *P and return nonzero.
595 Otherwise, advance *P to the first non-digit after S, set *VAL to
596 the result of the conversion and return zero. */
599 simple_strtoul (const char *s, const char **p, long unsigned int *val)
601 unsigned long int sum;
606 unsigned int c = *s++ - '0';
607 if (sum > (ULONG_MAX - c) / 10)
616 /* If S points to a single valid POSIX-style od format string, put
617 a description of that format in *TSPEC, make *NEXT point at the
618 character following the just-decoded format (if *NEXT is non-NULL),
619 and return zero. If S is not valid, don't modify *NEXT or *TSPEC,
620 give a diagnostic, and return nonzero. For example, if S were
621 "d4afL" *NEXT would be set to "afL" and *TSPEC would be
623 fmt = SIGNED_DECIMAL;
624 size = INT or LONG; (whichever integral_type_size[4] resolves to)
625 print_function = print_int; (assuming size == INT)
626 fmt_string = "%011d%c";
628 S_ORIG is solely for reporting errors. It should be the full format
633 decode_one_format (const char *s_orig, const char *s, const char **next,
636 enum size_spec size_spec;
637 unsigned long int size;
638 enum output_format fmt;
639 const char *pre_fmt_string;
641 void (*print_function) PARAMS ((off_t, const char *, const char *));
644 unsigned int field_width = 0;
646 assert (tspec != NULL);
660 size = sizeof (char);
665 size = sizeof (short);
675 size = sizeof (long int);
679 if (simple_strtoul (s, &p, &size) != 0)
681 /* The integer at P in S would overflow an unsigned long.
682 A digit string that long is sufficiently odd looking
683 that the following diagnostic is sufficient. */
684 error (0, 0, _("invalid type string `%s'"), s_orig);
691 if (MAX_INTEGRAL_TYPE_SIZE < size
692 || integral_type_size[size] == NO_SIZE)
694 error (0, 0, _("invalid type string `%s';\n\
695 this system doesn't provide a %lu-byte integral type"), s_orig, size);
703 #define FMT_BYTES_ALLOCATED 9
704 fmt_string = xmalloc (FMT_BYTES_ALLOCATED);
706 size_spec = integral_type_size[size];
711 fmt = SIGNED_DECIMAL;
712 sprintf (fmt_string, " %%%u%sd",
713 (field_width = bytes_to_signed_dec_digits[size]),
714 (size_spec == LONG ? "l"
715 : (size_spec == LONG_LONG ? "ll"
721 sprintf (fmt_string, " %%0%u%so",
722 (field_width = bytes_to_oct_digits[size]),
723 (size_spec == LONG ? "l" : ""));
727 fmt = UNSIGNED_DECIMAL;
728 sprintf (fmt_string, " %%%u%su",
729 (field_width = bytes_to_unsigned_dec_digits[size]),
730 (size_spec == LONG ? "l" : ""));
735 sprintf (fmt_string, " %%0%u%sx",
736 (field_width = bytes_to_hex_digits[size]),
737 (size_spec == LONG ? "l" : ""));
744 assert (strlen (fmt_string) < FMT_BYTES_ALLOCATED);
749 print_function = (fmt == SIGNED_DECIMAL
755 print_function = (fmt == SIGNED_DECIMAL
761 print_function = print_int;
765 print_function = print_long;
769 print_function = print_long_long;
778 fmt = FLOATING_POINT;
784 size = sizeof (float);
789 size = sizeof (double);
794 size = sizeof (LONG_DOUBLE);
798 if (simple_strtoul (s, &p, &size) != 0)
800 /* The integer at P in S would overflow an unsigned long.
801 A digit string that long is sufficiently odd looking
802 that the following diagnostic is sufficient. */
803 error (0, 0, _("invalid type string `%s'"), s_orig);
807 size = sizeof (double);
810 if (size > MAX_FP_TYPE_SIZE
811 || fp_type_size[size] == NO_SIZE)
813 error (0, 0, _("invalid type string `%s';\n\
814 this system doesn't provide a %lu-byte floating point type"), s_orig, size);
821 size_spec = fp_type_size[size];
826 print_function = print_float;
827 /* Don't use %#e; not all systems support it. */
828 pre_fmt_string = " %%%d.%de";
829 fmt_string = xmalloc (strlen (pre_fmt_string));
830 sprintf (fmt_string, pre_fmt_string,
831 (field_width = FLT_DIG + 8), FLT_DIG);
835 print_function = print_double;
836 pre_fmt_string = " %%%d.%de";
837 fmt_string = xmalloc (strlen (pre_fmt_string));
838 sprintf (fmt_string, pre_fmt_string,
839 (field_width = DBL_DIG + 8), DBL_DIG);
842 #ifdef HAVE_LONG_DOUBLE
843 case FLOAT_LONG_DOUBLE:
844 print_function = print_long_double;
845 pre_fmt_string = " %%%d.%dLe";
846 fmt_string = xmalloc (strlen (pre_fmt_string));
847 sprintf (fmt_string, pre_fmt_string,
848 (field_width = LDBL_DIG + 8), LDBL_DIG);
859 fmt = NAMED_CHARACTER;
862 print_function = print_named_ascii;
871 print_function = print_ascii;
876 error (0, 0, _("invalid character `%c' in type string `%s'"),
881 tspec->size = size_spec;
883 tspec->print_function = print_function;
884 tspec->fmt_string = fmt_string;
886 tspec->field_width = field_width;
887 tspec->hexl_mode_trailer = (*s == 'z');
888 if (tspec->hexl_mode_trailer)
897 /* Decode the POSIX-style od format string S. Append the decoded
898 representation to the global array SPEC, reallocating SPEC if
899 necessary. Return zero if S is valid, nonzero otherwise. */
902 decode_format_string (const char *s)
904 const char *s_orig = s;
912 if (decode_one_format (s_orig, s, &next, &tspec))
918 if (n_specs >= n_specs_allocated)
920 n_specs_allocated = 1 + (3 * n_specs_allocated) / 2;
921 spec = (struct tspec *) xrealloc ((char *) spec,
923 * sizeof (struct tspec)));
926 memcpy ((char *) &spec[n_specs], (char *) &tspec,
927 sizeof (struct tspec));
934 /* Given a list of one or more input filenames FILE_LIST, set the global
935 file pointer IN_STREAM to position N_SKIP in the concatenation of
936 those files. If any file operation fails or if there are fewer than
937 N_SKIP bytes in the combined input, give an error message and return
938 nonzero. When possible, use seek- rather than read operations to
939 advance IN_STREAM. A file name of "-" is interpreted as standard
948 for ( /* empty */ ; *file_list != NULL; ++file_list)
950 struct stat file_stats;
953 if (STREQ (*file_list, "-"))
955 input_filename = _("standard input");
961 input_filename = *file_list;
962 in_stream = fopen (input_filename, "r");
963 if (in_stream == NULL)
965 error (0, errno, "%s", input_filename);
970 SET_BINARY (fileno (in_stream));
975 /* First try seeking. For large offsets, this extra work is
976 worthwhile. If the offset is below some threshold it may be
977 more efficient to move the pointer by reading. There are two
978 issues when trying to seek:
979 - the file must be seekable.
980 - before seeking to the specified position, make sure
981 that the new position is in the current file.
982 Try to do that by getting file's size using fstat.
983 But that will work only for regular files. */
985 if (fstat (fileno (in_stream), &file_stats))
987 error (0, errno, "%s", input_filename);
992 /* The st_size field is valid only for regular files
993 (and for symbolic links, which cannot occur here).
994 If the number of bytes left to skip is at least as large as
995 the size of the current file, we can decrement
996 n_skip and go on to the next file. */
997 if (S_ISREG (file_stats.st_mode))
999 if (file_stats.st_size <= n_skip)
1001 n_skip -= file_stats.st_size;
1002 if (in_stream != stdin && fclose (in_stream) == EOF)
1004 error (0, errno, "%s", input_filename);
1011 if (0 <= lseek (fileno (in_stream), n_skip, SEEK_CUR))
1019 /* Seek didn't work or wasn't attempted; position the file pointer
1022 for (j = n_skip / BUFSIZ; 0 <= j; j--)
1025 size_t n_bytes_to_read = (0 < j
1028 size_t n_bytes_read;
1029 n_bytes_read = fread (buf, 1, n_bytes_to_read, in_stream);
1030 n_skip -= n_bytes_read;
1031 if (n_bytes_read != n_bytes_to_read)
1040 error (EXIT_FAILURE, 0, _("cannot skip past end of combined input"));
1046 format_address_none (off_t address ATTRIBUTE_UNUSED)
1052 format_address_std (off_t address)
1054 const char *address_string;
1056 sprintf (address_fmt_buffer, output_address_fmt_string, address);
1057 address_string = address_fmt_buffer;
1058 return address_string;
1062 format_address_label (off_t address)
1064 const char *address_string;
1065 assert (output_address_fmt_string != NULL);
1067 sprintf (address_fmt_buffer, output_address_fmt_string,
1068 address, address + pseudo_offset);
1069 address_string = address_fmt_buffer;
1070 return address_string;
1073 /* Write N_BYTES bytes from CURR_BLOCK to standard output once for each
1074 of the N_SPEC format specs. CURRENT_OFFSET is the byte address of
1075 CURR_BLOCK in the concatenation of input files, and it is printed
1076 (optionally) only before the output line associated with the first
1077 format spec. When duplicate blocks are being abbreviated, the output
1078 for a sequence of identical input blocks is the output for the first
1079 block followed by an asterisk alone on a line. It is valid to compare
1080 the blocks PREV_BLOCK and CURR_BLOCK only when N_BYTES == BYTES_PER_BLOCK.
1081 That condition may be false only for the last input block -- and then
1082 only when it has not been padded to length BYTES_PER_BLOCK. */
1085 write_block (off_t current_offset, off_t n_bytes,
1086 const char *prev_block, const char *curr_block)
1088 static int first = 1;
1089 static int prev_pair_equal = 0;
1091 #define EQUAL_BLOCKS(b1, b2) (memcmp ((b1), (b2), bytes_per_block) == 0)
1093 if (abbreviate_duplicate_blocks
1094 && !first && n_bytes == bytes_per_block
1095 && EQUAL_BLOCKS (prev_block, curr_block))
1097 if (prev_pair_equal)
1099 /* The two preceding blocks were equal, and the current
1100 block is the same as the last one, so print nothing. */
1105 prev_pair_equal = 1;
1112 prev_pair_equal = 0;
1113 for (i = 0; i < n_specs; i++)
1115 const char *addr_or_pad = (i == 0
1116 ? format_address (current_offset)
1119 fputs (addr_or_pad, stdout);
1120 (*spec[i].print_function) (n_bytes, curr_block, spec[i].fmt_string);
1121 if (spec[i].hexl_mode_trailer)
1123 /* space-pad out to full line width, then dump the trailer */
1124 int datum_width = width_bytes[spec[i].size];
1125 int blank_fields = (bytes_per_block - n_bytes) / datum_width;
1126 int field_width = spec[i].field_width + 1;
1127 printf ("%*s", blank_fields * field_width, "");
1128 dump_hexl_mode_trailer (n_bytes, curr_block);
1136 /* Test whether there have been errors on in_stream, and close it if
1137 it is not standard input. Return nonzero if there has been an error
1138 on in_stream or stdout; return zero otherwise. This function will
1139 report more than one error only if both a read and a write error
1143 check_and_close (void)
1148 if (ferror (in_stream))
1150 error (0, errno, "%s", input_filename);
1151 if (in_stream != stdin)
1155 else if (in_stream != stdin && fclose (in_stream) == EOF)
1157 error (0, errno, "%s", input_filename);
1161 if (ferror (stdout))
1163 error (0, errno, _("standard output"));
1170 /* Read a single byte into *C from the concatenation of the input files
1171 named in the global array FILE_LIST. On the first call to this
1172 function, the global variable IN_STREAM is expected to be an open
1173 stream associated with the input file *FILE_LIST. If IN_STREAM is
1174 at end-of-file, close it and update the global variables IN_STREAM,
1175 FILE_LIST, and INPUT_FILENAME so they correspond to the next file in
1176 the list. Then try to read a byte from the newly opened file.
1177 Repeat if necessary until *FILE_LIST is NULL. When EOF is reached
1178 for the last file in FILE_LIST, set *C to EOF and return. Subsequent
1179 calls do likewise. The return value is nonzero if any errors
1180 occured, zero otherwise. */
1187 if (*file_list == NULL)
1196 *c = fgetc (in_stream);
1201 err |= check_and_close ();
1206 if (*file_list == NULL)
1209 if (STREQ (*file_list, "-"))
1211 input_filename = _("standard input");
1213 have_read_stdin = 1;
1217 input_filename = *file_list;
1218 in_stream = fopen (input_filename, "r");
1219 if (in_stream == NULL)
1221 error (0, errno, "%s", input_filename);
1225 SET_BINARY (fileno (in_stream));
1227 while (in_stream == NULL);
1231 /* Read N bytes into BLOCK 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 *FILE_LIST. On subsequent
1235 calls, if *FILE_LIST is NULL, don't modify BLOCK and return zero.
1236 If all N bytes cannot be read from IN_STREAM, close IN_STREAM and
1237 update the global variables IN_STREAM, FILE_LIST, and INPUT_FILENAME.
1238 Then try to read the remaining bytes from the newly opened file.
1239 Repeat if necessary until *FILE_LIST is NULL. Set *N_BYTES_IN_BUFFER
1240 to the number of bytes read. If an error occurs, it will be detected
1241 through ferror when the stream is about to be closed. If there is an
1242 error, give a message but continue reading as usual and return nonzero.
1243 Otherwise return zero. */
1246 read_block (size_t n, char *block, size_t *n_bytes_in_buffer)
1250 assert (0 < n && n <= bytes_per_block);
1252 *n_bytes_in_buffer = 0;
1257 if (*file_list == NULL)
1258 return 0; /* EOF. */
1266 n_needed = n - *n_bytes_in_buffer;
1267 n_read = fread (block + *n_bytes_in_buffer, 1, n_needed, in_stream);
1269 *n_bytes_in_buffer += n_read;
1271 if (n_read == n_needed)
1274 err |= check_and_close ();
1279 if (*file_list == NULL)
1282 if (STREQ (*file_list, "-"))
1284 input_filename = _("standard input");
1286 have_read_stdin = 1;
1290 input_filename = *file_list;
1291 in_stream = fopen (input_filename, "r");
1292 if (in_stream == NULL)
1294 error (0, errno, "%s", input_filename);
1298 SET_BINARY (fileno (in_stream));
1300 while (in_stream == NULL);
1304 /* Return the least common multiple of the sizes associated
1305 with the format specs. */
1313 for (i = 0; i < n_specs; i++)
1314 l_c_m = lcm (l_c_m, width_bytes[(int) spec[i].size]);
1318 /* If S is a valid pre-POSIX offset specification with an optional leading '+'
1319 return the offset it denotes. Otherwise, return -1. */
1322 parse_old_offset (const char *s)
1326 enum strtol_error s_err;
1332 /* Skip over any leading '+'. */
1336 /* Determine the radix we'll use to interpret S. If there is a `.',
1337 it's decimal, otherwise, if the string begins with `0X'or `0x',
1338 it's hexadecimal, else octal. */
1339 if (strchr (s, '.') != NULL)
1343 if (s[0] == '0' && (s[1] == 'x' || s[1] == 'X'))
1349 s_err = xstrtoumax (s, NULL, radix, &tmp, "Bb");
1350 if (s_err != LONGINT_OK)
1352 STRTOL_FAIL_WARN (s, _("old-style offset"), s_err);
1355 if (OFF_T_MAX < tmp)
1356 error (EXIT_FAILURE, 0,
1357 _("%s is larger than the maximum file size on this system"), s);
1362 /* Read a chunk of size BYTES_PER_BLOCK from the input files, write the
1363 formatted block to standard output, and repeat until the specified
1364 maximum number of bytes has been read or until all input has been
1365 processed. If the last block read is smaller than BYTES_PER_BLOCK
1366 and its size is not a multiple of the size associated with a format
1367 spec, extend the input block with zero bytes until its length is a
1368 multiple of all format spec sizes. Write the final block. Finally,
1369 write on a line by itself the offset of the byte after the last byte
1370 read. Accumulate return values from calls to read_block and
1371 check_and_close, and if any was nonzero, return nonzero.
1372 Otherwise, return zero. */
1378 off_t current_offset;
1379 off_t end_offset IF_LINT (= 0);
1382 size_t n_bytes_read;
1384 block[0] = (char *) alloca (bytes_per_block);
1385 block[1] = (char *) alloca (bytes_per_block);
1387 current_offset = n_bytes_to_skip;
1391 if (limit_bytes_to_format)
1393 end_offset = n_bytes_to_skip + max_bytes_to_format;
1398 if (current_offset >= end_offset)
1403 n_needed = MIN (end_offset - current_offset,
1404 (off_t) bytes_per_block);
1405 err |= read_block (n_needed, block[idx], &n_bytes_read);
1406 if (n_bytes_read < bytes_per_block)
1408 assert (n_bytes_read == bytes_per_block);
1409 write_block (current_offset, n_bytes_read,
1410 block[!idx], block[idx]);
1411 current_offset += n_bytes_read;
1419 err |= read_block (bytes_per_block, block[idx], &n_bytes_read);
1420 if (n_bytes_read < bytes_per_block)
1422 assert (n_bytes_read == bytes_per_block);
1423 write_block (current_offset, n_bytes_read,
1424 block[!idx], block[idx]);
1425 current_offset += n_bytes_read;
1430 if (n_bytes_read > 0)
1433 size_t bytes_to_write;
1437 /* Make bytes_to_write the smallest multiple of l_c_m that
1438 is at least as large as n_bytes_read. */
1439 bytes_to_write = l_c_m * (int) ((n_bytes_read + l_c_m - 1) / l_c_m);
1441 memset (block[idx] + n_bytes_read, 0, bytes_to_write - n_bytes_read);
1442 write_block (current_offset, bytes_to_write,
1443 block[!idx], block[idx]);
1444 current_offset += n_bytes_read;
1447 if (output_address_fmt_string != NULL)
1448 printf ("%s\n", format_address (current_offset));
1450 if (limit_bytes_to_format && current_offset > end_offset)
1451 err |= check_and_close ();
1456 /* STRINGS mode. Find each "string constant" in the input.
1457 A string constant is a run of at least `string_min' ASCII
1458 graphic (or formatting) characters terminated by a null.
1459 Based on a function written by Richard Stallman for a
1460 pre-POSIX version of od. Return nonzero if an error
1461 occurs. Otherwise, return zero. */
1466 size_t bufsize = MAX (100, string_min);
1467 char *buf = xmalloc (bufsize);
1468 off_t address = n_bytes_to_skip;
1477 /* See if the next `string_min' chars are all printing chars. */
1480 if (limit_bytes_to_format
1481 && address >= (n_bytes_to_skip + max_bytes_to_format - string_min))
1484 for (i = 0; i < string_min; i++)
1486 err |= read_char (&c);
1494 /* Found a non-printing. Try again starting with next char. */
1499 /* We found a run of `string_min' printable characters.
1500 Now see if it is terminated with a null byte. */
1501 while (!limit_bytes_to_format
1502 || address < n_bytes_to_skip + max_bytes_to_format)
1506 bufsize = 1 + 3 * bufsize / 2;
1507 buf = xrealloc (buf, bufsize);
1509 err |= read_char (&c);
1517 break; /* It is; print this string. */
1519 goto tryline; /* It isn't; give up on this string. */
1520 buf[i++] = c; /* String continues; store it all. */
1523 /* If we get here, the string is all printable and null-terminated,
1524 so print it. It is all in `buf' and `i' is its length. */
1526 if (output_address_fmt_string != NULL)
1528 printf ("%s ", format_address (address - i - 1));
1530 for (i = 0; (c = buf[i]); i++)
1535 fputs ("\\a", stdout);
1539 fputs ("\\b", stdout);
1543 fputs ("\\f", stdout);
1547 fputs ("\\n", stdout);
1551 fputs ("\\r", stdout);
1555 fputs ("\\t", stdout);
1559 fputs ("\\v", stdout);
1569 /* We reach this point only if we search through
1570 (max_bytes_to_format - string_min) bytes before reachine EOF. */
1574 err |= check_and_close ();
1578 /* There must be exactly one %s format specifier in FORMAT_TEMPLATE.
1579 Return the just-malloc'd result of using sprintf to insert
1580 OFF_T_PRINTF_FORMAT_STRING into FORMAT_TEMPLATE.
1581 Technically, the caller should free this memory, but IMHO it's not
1582 worth it in this case. */
1584 expand_address_fmt (char const *format_template)
1586 size_t len = strlen (format_template);
1587 char *fmt = xmalloc (len + 1);
1588 /* Ensure that the literal we're inserting is no longer than the two-byte
1589 string `%s' it's replacing. There's also the %%, so technically we don't
1590 even need the `+ 1' above. */
1591 assert (OFF_T_PRINTF_FORMAT_STRING[0] == 0
1592 || OFF_T_PRINTF_FORMAT_STRING[1] == 0
1593 || OFF_T_PRINTF_FORMAT_STRING[2] == 0);
1594 sprintf (fmt, format_template, OFF_T_PRINTF_FORMAT_STRING);
1599 main (int argc, char **argv)
1605 unsigned int address_pad_len;
1606 unsigned long int desired_width IF_LINT (= 0);
1607 int width_specified = 0;
1608 int n_failed_decodes = 0;
1611 /* The old-style `pseudo starting address' to be printed in parentheses
1612 after any true address. */
1613 long int pseudo_start IF_LINT (= 0);
1615 program_name = argv[0];
1616 setlocale (LC_ALL, "");
1617 bindtextdomain (PACKAGE, LOCALEDIR);
1618 textdomain (PACKAGE);
1620 atexit (close_stdout);
1624 for (i = 0; i <= MAX_INTEGRAL_TYPE_SIZE; i++)
1625 integral_type_size[i] = NO_SIZE;
1627 integral_type_size[sizeof (char)] = CHAR;
1628 integral_type_size[sizeof (short int)] = SHORT;
1629 integral_type_size[sizeof (int)] = INT;
1630 integral_type_size[sizeof (long int)] = LONG;
1631 #ifdef HAVE_UNSIGNED_LONG_LONG
1632 integral_type_size[sizeof (long long)] = LONG_LONG;
1635 for (i = 0; i <= MAX_FP_TYPE_SIZE; i++)
1636 fp_type_size[i] = NO_SIZE;
1638 fp_type_size[sizeof (float)] = FLOAT_SINGLE;
1639 /* The array entry for `double' is filled in after that for LONG_DOUBLE
1640 so that if `long double' is the same type or if long double isn't
1641 supported FLOAT_LONG_DOUBLE will never be used. */
1642 fp_type_size[sizeof (LONG_DOUBLE)] = FLOAT_LONG_DOUBLE;
1643 fp_type_size[sizeof (double)] = FLOAT_DOUBLE;
1646 n_specs_allocated = 5;
1647 spec = (struct tspec *) xmalloc (n_specs_allocated * sizeof (struct tspec));
1649 output_address_fmt_string = expand_address_fmt ("%%07%so");
1650 format_address = format_address_std;
1651 address_pad_len = 7;
1652 flag_dump_strings = 0;
1654 while ((c = getopt_long (argc, argv, "abcdfhilos::xw::A:j:N:t:v",
1655 long_options, NULL)) != -1)
1658 enum strtol_error s_err;
1669 output_address_fmt_string = expand_address_fmt ("%%07%sd");
1670 format_address = format_address_std;
1671 address_pad_len = 7;
1674 output_address_fmt_string = expand_address_fmt ("%%07%so");
1675 format_address = format_address_std;
1676 address_pad_len = 7;
1679 output_address_fmt_string = expand_address_fmt ("%%06%sx");
1680 format_address = format_address_std;
1681 address_pad_len = 6;
1684 output_address_fmt_string = NULL;
1685 format_address = format_address_none;
1686 address_pad_len = 0;
1689 error (EXIT_FAILURE, 0,
1690 _("invalid output address radix `%c'; \
1691 it must be one character from [doxn]"),
1698 s_err = xstrtoumax (optarg, NULL, 0, &tmp, "bkm");
1699 n_bytes_to_skip = tmp;
1700 if (s_err != LONGINT_OK)
1701 STRTOL_FATAL_ERROR (optarg, _("skip argument"), s_err);
1705 limit_bytes_to_format = 1;
1707 s_err = xstrtoumax (optarg, NULL, 0, &tmp, "bkm");
1708 max_bytes_to_format = tmp;
1709 if (s_err != LONGINT_OK)
1710 STRTOL_FATAL_ERROR (optarg, _("limit argument"), s_err);
1712 if (OFF_T_MAX < tmp)
1713 error (EXIT_FAILURE, 0,
1714 _("%s is larger than the maximum file size on this system"),
1723 s_err = xstrtoumax (optarg, NULL, 0, &tmp, "bkm");
1724 if (s_err != LONGINT_OK)
1725 STRTOL_FATAL_ERROR (optarg, _("minimum string length"), s_err);
1727 /* The minimum string length may be no larger than SIZE_MAX,
1728 since we may allocate a buffer of this size. */
1730 error (EXIT_FAILURE, 0, _("%s is too large"), optarg);
1734 flag_dump_strings = 1;
1738 if (decode_format_string (optarg))
1743 abbreviate_duplicate_blocks = 0;
1750 /* The next several cases map the old, pre-POSIX format
1751 specification options to the corresponding POSIX format
1752 specs. GNU od accepts any combination of old- and
1753 new-style options. Format specification options accumulate. */
1755 #define CASE_OLD_ARG(old_char,new_string) \
1758 if (decode_format_string (new_string)) \
1759 ++n_failed_decodes; \
1763 CASE_OLD_ARG ('a', "a");
1764 CASE_OLD_ARG ('b', "oC");
1765 CASE_OLD_ARG ('c', "c");
1766 CASE_OLD_ARG ('d', "u2");
1767 CASE_OLD_ARG ('f', "fF");
1768 CASE_OLD_ARG ('h', "x2");
1769 CASE_OLD_ARG ('i', "d2");
1770 CASE_OLD_ARG ('l', "d4");
1771 CASE_OLD_ARG ('o', "o2");
1772 CASE_OLD_ARG ('x', "x2");
1777 width_specified = 1;
1785 s_err = xstrtoumax (optarg, NULL, 10, &w_tmp, "");
1786 if (s_err != LONGINT_OK)
1787 STRTOL_FATAL_ERROR (optarg, _("width specification"), s_err);
1788 if (ULONG_MAX < w_tmp)
1789 error (EXIT_FAILURE, 0, _("%s is too large"), optarg);
1790 desired_width = w_tmp;
1794 case_GETOPT_HELP_CHAR;
1796 case_GETOPT_VERSION_CHAR (PROGRAM_NAME, AUTHORS);
1804 if (n_failed_decodes > 0)
1805 exit (EXIT_FAILURE);
1807 if (flag_dump_strings && n_specs > 0)
1808 error (EXIT_FAILURE, 0,
1809 _("no type may be specified when dumping strings"));
1811 n_files = argc - optind;
1813 /* If the --backward-compatible option is used, there may be from
1814 0 to 3 remaining command line arguments; handle each case
1816 od [file] [[+]offset[.][b] [[+]label[.][b]]]
1817 The offset and pseudo_start have the same syntax. */
1825 if ((offset = parse_old_offset (argv[optind])) >= 0)
1827 n_bytes_to_skip = offset;
1832 else if (n_files == 2)
1835 if ((o1 = parse_old_offset (argv[optind])) >= 0
1836 && (o2 = parse_old_offset (argv[optind + 1])) >= 0)
1838 n_bytes_to_skip = o1;
1839 flag_pseudo_start = 1;
1844 else if ((o2 = parse_old_offset (argv[optind + 1])) >= 0)
1846 n_bytes_to_skip = o2;
1848 argv[optind + 1] = argv[optind];
1854 _("invalid second operand in compatibility mode `%s'"),
1859 else if (n_files == 3)
1862 if ((o1 = parse_old_offset (argv[optind + 1])) >= 0
1863 && (o2 = parse_old_offset (argv[optind + 2])) >= 0)
1865 n_bytes_to_skip = o1;
1866 flag_pseudo_start = 1;
1868 argv[optind + 2] = argv[optind];
1875 _("in compatibility mode, the last two arguments must be offsets"));
1879 else if (n_files > 3)
1882 _("compatibility mode supports at most three arguments"));
1886 if (flag_pseudo_start)
1888 static char buf[10];
1890 if (output_address_fmt_string == NULL)
1892 output_address_fmt_string = expand_address_fmt ("(%%07%so)");
1893 format_address = format_address_std;
1897 sprintf (buf, "%s (%s)",
1898 output_address_fmt_string,
1899 output_address_fmt_string);
1900 output_address_fmt_string = buf;
1901 format_address = format_address_label;
1906 assert (address_pad_len <= MAX_ADDRESS_LENGTH);
1907 for (i = 0; i < address_pad_len; i++)
1908 address_pad[i] = ' ';
1909 address_pad[address_pad_len] = '\0';
1913 if (decode_one_format ("o2", "o2", NULL, &(spec[0])))
1915 /* This happens on Cray systems that don't have a 2-byte
1917 exit (EXIT_FAILURE);
1924 file_list = (char const *const *) &argv[optind];
1927 /* If no files were listed on the command line, set up the
1928 global array FILE_LIST so that it contains the null-terminated
1929 list of one name: "-". */
1930 static char const *const default_file_list[] = {"-", NULL};
1932 file_list = default_file_list;
1935 err |= skip (n_bytes_to_skip);
1936 if (in_stream == NULL)
1939 pseudo_offset = (flag_pseudo_start ? pseudo_start - n_bytes_to_skip : 0);
1941 /* Compute output block length. */
1944 if (width_specified)
1946 if (desired_width != 0 && desired_width % l_c_m == 0)
1947 bytes_per_block = desired_width;
1950 error (0, 0, _("warning: invalid width %lu; using %d instead"),
1951 desired_width, l_c_m);
1952 bytes_per_block = l_c_m;
1957 if (l_c_m < DEFAULT_BYTES_PER_BLOCK)
1958 bytes_per_block = l_c_m * (int) (DEFAULT_BYTES_PER_BLOCK / l_c_m);
1960 bytes_per_block = l_c_m;
1964 for (i = 0; i < n_specs; i++)
1966 printf (_("%d: fmt=\"%s\" width=%d\n"),
1967 i, spec[i].fmt_string, width_bytes[spec[i].size]);
1971 err |= (flag_dump_strings ? dump_strings () : dump ());
1975 if (have_read_stdin && fclose (stdin) == EOF)
1976 error (EXIT_FAILURE, errno, _("standard input"));
1978 exit (err == 0 ? EXIT_SUCCESS : EXIT_FAILURE);