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 /* FIXME: make this the number of octal digits in an unsigned long. */
157 #define MAX_ADDRESS_LENGTH 13
159 /* Space for a normal address, a space, a pseudo address, parentheses
160 around the pseudo address, and a trailing zero byte. */
161 static char address_fmt_buffer[2 * MAX_ADDRESS_LENGTH + 4];
162 static char address_pad[MAX_ADDRESS_LENGTH + 1];
164 static unsigned long int string_min;
165 static unsigned long int flag_dump_strings;
167 /* Non-zero if we should recognize the pre-POSIX non-option arguments
168 that specified at most one file and optional arguments specifying
169 offset and pseudo-start address. */
170 static int traditional;
172 /* Non-zero if an old-style `pseudo-address' was specified. */
173 static long int flag_pseudo_start;
175 /* The difference between the old-style pseudo starting address and
176 the number of bytes to skip. */
177 static long int pseudo_offset;
179 /* Function to format an address and optionally an additional parenthesized
180 pseudo-address; it returns the formatted string. */
181 static const char *(*format_address) PARAMS ((off_t));
183 /* The number of input bytes to skip before formatting and writing. */
184 static off_t n_bytes_to_skip = 0;
186 /* When nonzero, MAX_BYTES_TO_FORMAT is the maximum number of bytes
187 to be read and formatted. Otherwise all input is formatted. */
188 static int limit_bytes_to_format = 0;
190 /* The maximum number of bytes that will be formatted. This
191 value is used only when LIMIT_BYTES_TO_FORMAT is nonzero. */
192 static off_t max_bytes_to_format;
194 /* When nonzero and two or more consecutive blocks are equal, format
195 only the first block and output an asterisk alone on the following
196 line to indicate that identical blocks have been elided. */
197 static int abbreviate_duplicate_blocks = 1;
199 /* An array of specs describing how to format each input block. */
200 static struct tspec *spec;
202 /* The number of format specs. */
203 static unsigned int n_specs;
205 /* The allocated length of SPEC. */
206 static unsigned int n_specs_allocated;
208 /* The number of input bytes formatted per output line. It must be
209 a multiple of the least common multiple of the sizes associated with
210 the specified output types. It should be as large as possible, but
211 no larger than 16 -- unless specified with the -w option. */
212 static unsigned int bytes_per_block;
214 /* Human-readable representation of *file_list (for error messages).
215 It differs from *file_list only when *file_list is "-". */
216 static char const *input_filename;
218 /* A NULL-terminated list of the file-arguments from the command line.
219 If no file-arguments were specified, this variable is initialized
221 static char const *const *file_list;
223 /* The input stream associated with the current file. */
224 static FILE *in_stream;
226 /* If nonzero, at least one of the files we read was standard input. */
227 static int have_read_stdin;
229 #ifdef HAVE_UNSIGNED_LONG_LONG
230 # define LONGEST_INTEGRAL_TYPE unsigned long long
232 # define LONGEST_INTEGRAL_TYPE long int
235 #define MAX_INTEGRAL_TYPE_SIZE sizeof(LONGEST_INTEGRAL_TYPE)
236 static enum size_spec integral_type_size[MAX_INTEGRAL_TYPE_SIZE + 1];
238 #define MAX_FP_TYPE_SIZE sizeof(LONG_DOUBLE)
239 static enum size_spec fp_type_size[MAX_FP_TYPE_SIZE + 1];
241 static struct option const long_options[] =
244 {"skip-bytes", required_argument, NULL, 'j'},
245 {"address-radix", required_argument, NULL, 'A'},
246 {"read-bytes", required_argument, NULL, 'N'},
247 {"format", required_argument, NULL, 't'},
248 {"output-duplicates", no_argument, NULL, 'v'},
250 /* non-POSIX options. */
251 {"strings", optional_argument, NULL, 's'},
252 {"traditional", no_argument, NULL, 'B'},
253 {"width", optional_argument, NULL, 'w'},
255 {GETOPT_HELP_OPTION_DECL},
256 {GETOPT_VERSION_OPTION_DECL},
264 fprintf (stderr, _("Try `%s --help' for more information.\n"),
269 Usage: %s [OPTION]... [FILE]...\n\
270 or: %s --traditional [FILE] [[+]OFFSET [[+]LABEL]]\n\
272 program_name, program_name);
274 Write an unambiguous representation, octal bytes by default, of FILE\n\
275 to standard output. With no FILE, or when FILE is -, read standard input.\n\
277 -A, --address-radix=RADIX decide how file offsets are printed\n\
278 -j, --skip-bytes=BYTES skip BYTES input bytes first on each file\n\
279 -N, --read-bytes=BYTES limit dump to BYTES input bytes per file\n\
280 -s, --strings[=BYTES] output strings of at least BYTES graphic chars\n\
281 -t, --format=TYPE select output format or formats\n\
282 -v, --output-duplicates do not use * to mark line suppression\n\
283 -w, --width[=BYTES] output BYTES bytes per output line\n\
284 --traditional accept arguments in pre-POSIX form\n\
285 --help display this help and exit\n\
286 --version output version information and exit\n\
288 Pre-POSIX format specifications may be intermixed, they accumulate:\n\
289 -a same as -t a, select named characters\n\
290 -b same as -t oC, select octal bytes\n\
291 -c same as -t c, select ASCII characters or backslash escapes\n\
292 -d same as -t u2, select unsigned decimal shorts\n\
293 -f same as -t fF, select floats\n\
294 -h same as -t x2, select hexadecimal shorts\n\
295 -i same as -t d2, select decimal shorts\n\
296 -l same as -t d4, select decimal longs\n\
297 -o same as -t o2, select octal shorts\n\
298 -x same as -t x2, select hexadecimal shorts\n\
302 For older syntax (second call format), OFFSET means -j OFFSET. LABEL\n\
303 is the pseudo-address at first byte printed, incremented when dump is\n\
304 progressing. For OFFSET and LABEL, a 0x or 0X prefix indicates\n\
305 hexadecimal, suffixes maybe . for octal and b multiply by 512.\n\
307 TYPE is made up of one or more of these specifications:\n\
310 c ASCII character or backslash escape\n\
311 d[SIZE] signed decimal, SIZE bytes per integer\n\
312 f[SIZE] floating point, SIZE bytes per integer\n\
313 o[SIZE] octal, SIZE bytes per integer\n\
314 u[SIZE] unsigned decimal, SIZE bytes per integer\n\
315 x[SIZE] hexadecimal, SIZE bytes per integer\n\
317 SIZE is a number. For TYPE in doux, SIZE may also be C for\n\
318 sizeof(char), S for sizeof(short), I for sizeof(int) or L for\n\
319 sizeof(long). If TYPE is f, SIZE may also be F for sizeof(float), D\n\
320 for sizeof(double) or L for sizeof(long double).\n\
322 RADIX is d for decimal, o for octal, x for hexadecimal or n for none.\n\
323 BYTES is hexadecimal with 0x or 0X prefix, it is multiplied by 512\n\
324 with b suffix, by 1024 with k and by 1048576 with m. Adding a z suffix to\n\
325 any type adds a display of printable characters to the end of each line\n\
326 of output. -s without a number implies 3. -w without a number implies 32.\n\
327 By default, od uses -A o -t d2 -w 16.\n\
329 puts (_("\nReport bugs to <bug-textutils@gnu.org>."));
331 exit (status == 0 ? EXIT_SUCCESS : EXIT_FAILURE);
334 /* Compute the greatest common denominator of U and V
335 using Euclid's algorithm. */
338 gcd (unsigned int u, unsigned int v)
350 /* Compute the least common multiple of U and V. */
353 lcm (unsigned int u, unsigned int v)
355 unsigned int t = gcd (u, v);
362 print_s_char (long unsigned int n_bytes, const char *block,
363 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 (long unsigned int n_bytes, const char *block,
379 const char *fmt_string)
382 for (i = n_bytes; i > 0; i--)
384 unsigned int tmp = *(const unsigned char *) block;
385 printf (fmt_string, tmp);
386 block += sizeof (unsigned char);
391 print_s_short (long unsigned int n_bytes, const char *block,
392 const char *fmt_string)
395 for (i = n_bytes / sizeof (unsigned short); i > 0; i--)
397 int tmp = (unsigned) *(const unsigned short *) block;
399 tmp -= SHRT_MAX - SHRT_MIN + 1;
400 assert (tmp <= SHRT_MAX);
401 printf (fmt_string, tmp);
402 block += sizeof (unsigned short);
407 print_short (long unsigned int n_bytes, const char *block,
408 const char *fmt_string)
411 for (i = n_bytes / sizeof (unsigned short); i > 0; i--)
413 unsigned int tmp = *(const unsigned short *) block;
414 printf (fmt_string, tmp);
415 block += sizeof (unsigned short);
420 print_int (long unsigned int n_bytes, const char *block,
421 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 (long unsigned int n_bytes, const char *block,
434 const char *fmt_string)
437 for (i = n_bytes / sizeof (unsigned long); i > 0; i--)
439 unsigned long tmp = *(const unsigned long *) block;
440 printf (fmt_string, tmp);
441 block += sizeof (unsigned long);
445 #ifdef HAVE_UNSIGNED_LONG_LONG
447 print_long_long (long unsigned int n_bytes, const char *block,
448 const char *fmt_string)
451 for (i = n_bytes / sizeof (unsigned long long); i > 0; i--)
453 unsigned long long tmp = *(const unsigned long long *) block;
454 printf (fmt_string, tmp);
455 block += sizeof (unsigned long long);
461 print_float (long unsigned int n_bytes, const char *block,
462 const char *fmt_string)
465 for (i = n_bytes / sizeof (float); i > 0; i--)
467 float tmp = *(const float *) block;
468 printf (fmt_string, tmp);
469 block += sizeof (float);
474 print_double (long unsigned int n_bytes, const char *block,
475 const char *fmt_string)
478 for (i = n_bytes / sizeof (double); i > 0; i--)
480 double tmp = *(const double *) block;
481 printf (fmt_string, tmp);
482 block += sizeof (double);
486 #ifdef HAVE_LONG_DOUBLE
488 print_long_double (long unsigned int n_bytes, const char *block,
489 const char *fmt_string)
492 for (i = n_bytes / sizeof (LONG_DOUBLE); i > 0; i--)
494 LONG_DOUBLE tmp = *(const LONG_DOUBLE *) block;
495 printf (fmt_string, tmp);
496 block += sizeof (LONG_DOUBLE);
503 dump_hexl_mode_trailer (long unsigned int n_bytes, const char *block)
506 fputs (" >", stdout);
507 for (i = n_bytes; i > 0; i--)
509 unsigned int c = *(const unsigned char *) block;
510 unsigned int c2 = (ISPRINT(c) ? c : '.');
512 block += sizeof (unsigned char);
518 print_named_ascii (long unsigned int n_bytes, const char *block,
519 const char *unused_fmt_string ATTRIBUTE_UNUSED)
522 for (i = n_bytes; i > 0; i--)
524 unsigned int c = *(const unsigned char *) block;
525 unsigned int masked_c = (0x7f & c);
531 else if (masked_c <= 040)
532 s = charname[masked_c];
535 sprintf (buf, " %c", masked_c);
540 block += sizeof (unsigned char);
545 print_ascii (long unsigned int n_bytes, const char *block,
546 const char *unused_fmt_string ATTRIBUTE_UNUSED)
549 for (i = n_bytes; i > 0; i--)
551 unsigned int c = *(const unsigned char *) block;
590 sprintf (buf, (ISPRINT (c) ? " %c" : "%03o"), c);
591 s = (const char *) buf;
595 block += sizeof (unsigned char);
599 /* Convert a null-terminated (possibly zero-length) string S to an
600 unsigned long integer value. If S points to a non-digit set *P to S,
601 *VAL to 0, and return 0. Otherwise, accumulate the integer value of
602 the string of digits. If the string of digits represents a value
603 larger than ULONG_MAX, don't modify *VAL or *P and return nonzero.
604 Otherwise, advance *P to the first non-digit after S, set *VAL to
605 the result of the conversion and return zero. */
608 simple_strtoul (const char *s, const char **p, long unsigned int *val)
610 unsigned long int sum;
615 unsigned int c = *s++ - '0';
616 if (sum > (ULONG_MAX - c) / 10)
625 /* If S points to a single valid POSIX-style od format string, put
626 a description of that format in *TSPEC, make *NEXT point at the
627 character following the just-decoded format (if *NEXT is non-NULL),
628 and return zero. If S is not valid, don't modify *NEXT or *TSPEC,
629 give a diagnostic, and return nonzero. For example, if S were
630 "d4afL" *NEXT would be set to "afL" and *TSPEC would be
632 fmt = SIGNED_DECIMAL;
633 size = INT or LONG; (whichever integral_type_size[4] resolves to)
634 print_function = print_int; (assuming size == INT)
635 fmt_string = "%011d%c";
637 S_ORIG is solely for reporting errors. It should be the full format
642 decode_one_format (const char *s_orig, const char *s, const char **next,
645 enum size_spec size_spec;
646 unsigned long int size;
647 enum output_format fmt;
648 const char *pre_fmt_string;
650 void (*print_function) ();
653 unsigned int field_width = 0;
655 assert (tspec != NULL);
669 size = sizeof (char);
674 size = sizeof (short);
684 size = sizeof (long int);
688 if (simple_strtoul (s, &p, &size) != 0)
690 /* The integer at P in S would overflow an unsigned long.
691 A digit string that long is sufficiently odd looking
692 that the following diagnostic is sufficient. */
693 error (0, 0, _("invalid type string `%s'"), s_orig);
700 if (size > MAX_INTEGRAL_TYPE_SIZE
701 || integral_type_size[size] == NO_SIZE)
703 error (0, 0, _("invalid type string `%s';\n\
704 this system doesn't provide a %lu-byte integral type"), s_orig, size);
712 #define FMT_BYTES_ALLOCATED 9
713 fmt_string = xmalloc (FMT_BYTES_ALLOCATED);
715 size_spec = integral_type_size[size];
720 fmt = SIGNED_DECIMAL;
721 sprintf (fmt_string, " %%%u%sd",
722 (field_width = bytes_to_signed_dec_digits[size]),
723 (size_spec == LONG ? "l"
724 : (size_spec == LONG_LONG ? "ll"
730 sprintf (fmt_string, " %%0%u%so",
731 (field_width = bytes_to_oct_digits[size]),
732 (size_spec == LONG ? "l" : ""));
736 fmt = UNSIGNED_DECIMAL;
737 sprintf (fmt_string, " %%%u%su",
738 (field_width = bytes_to_unsigned_dec_digits[size]),
739 (size_spec == LONG ? "l" : ""));
744 sprintf (fmt_string, " %%0%u%sx",
745 (field_width = bytes_to_hex_digits[size]),
746 (size_spec == LONG ? "l" : ""));
753 assert (strlen (fmt_string) < FMT_BYTES_ALLOCATED);
758 print_function = (fmt == SIGNED_DECIMAL
764 print_function = (fmt == SIGNED_DECIMAL
770 print_function = print_int;
774 print_function = print_long;
778 print_function = print_long_long;
787 fmt = FLOATING_POINT;
793 size = sizeof (float);
798 size = sizeof (double);
803 size = sizeof (LONG_DOUBLE);
807 if (simple_strtoul (s, &p, &size) != 0)
809 /* The integer at P in S would overflow an unsigned long.
810 A digit string that long is sufficiently odd looking
811 that the following diagnostic is sufficient. */
812 error (0, 0, _("invalid type string `%s'"), s_orig);
816 size = sizeof (double);
819 if (size > MAX_FP_TYPE_SIZE
820 || fp_type_size[size] == NO_SIZE)
822 error (0, 0, _("invalid type string `%s';\n\
823 this system doesn't provide a %lu-byte floating point type"), s_orig, size);
830 size_spec = fp_type_size[size];
835 print_function = print_float;
836 /* Don't use %#e; not all systems support it. */
837 pre_fmt_string = " %%%d.%de";
838 fmt_string = xmalloc (strlen (pre_fmt_string));
839 sprintf (fmt_string, pre_fmt_string,
840 (field_width = FLT_DIG + 8), FLT_DIG);
844 print_function = print_double;
845 pre_fmt_string = " %%%d.%de";
846 fmt_string = xmalloc (strlen (pre_fmt_string));
847 sprintf (fmt_string, pre_fmt_string,
848 (field_width = DBL_DIG + 8), DBL_DIG);
851 #ifdef HAVE_LONG_DOUBLE
852 case FLOAT_LONG_DOUBLE:
853 print_function = print_long_double;
854 pre_fmt_string = " %%%d.%dLe";
855 fmt_string = xmalloc (strlen (pre_fmt_string));
856 sprintf (fmt_string, pre_fmt_string,
857 (field_width = LDBL_DIG + 8), LDBL_DIG);
868 fmt = NAMED_CHARACTER;
871 print_function = print_named_ascii;
880 print_function = print_ascii;
885 error (0, 0, _("invalid character `%c' in type string `%s'"),
890 tspec->size = size_spec;
892 tspec->print_function = print_function;
893 tspec->fmt_string = fmt_string;
895 tspec->field_width = field_width;
896 tspec->hexl_mode_trailer = (*s == 'z');
897 if (tspec->hexl_mode_trailer)
906 /* Decode the POSIX-style od format string S. Append the decoded
907 representation to the global array SPEC, reallocating SPEC if
908 necessary. Return zero if S is valid, nonzero otherwise. */
911 decode_format_string (const char *s)
913 const char *s_orig = s;
921 if (decode_one_format (s_orig, s, &next, &tspec))
927 if (n_specs >= n_specs_allocated)
929 n_specs_allocated = 1 + (3 * n_specs_allocated) / 2;
930 spec = (struct tspec *) xrealloc ((char *) spec,
932 * sizeof (struct tspec)));
935 memcpy ((char *) &spec[n_specs], (char *) &tspec,
936 sizeof (struct tspec));
943 /* Given a list of one or more input filenames FILE_LIST, set the global
944 file pointer IN_STREAM to position N_SKIP in the concatenation of
945 those files. If any file operation fails or if there are fewer than
946 N_SKIP bytes in the combined input, give an error message and return
947 nonzero. When possible, use seek- rather than read operations to
948 advance IN_STREAM. A file name of "-" is interpreted as standard
957 for ( /* empty */ ; *file_list != NULL; ++file_list)
959 struct stat file_stats;
962 if (STREQ (*file_list, "-"))
964 input_filename = _("standard input");
970 input_filename = *file_list;
971 in_stream = fopen (input_filename, "r");
972 if (in_stream == NULL)
974 error (0, errno, "%s", input_filename);
979 SET_BINARY (fileno (in_stream));
984 /* First try seeking. For large offsets, this extra work is
985 worthwhile. If the offset is below some threshold it may be
986 more efficient to move the pointer by reading. There are two
987 issues when trying to seek:
988 - the file must be seekable.
989 - before seeking to the specified position, make sure
990 that the new position is in the current file.
991 Try to do that by getting file's size using fstat.
992 But that will work only for regular files. */
994 if (fstat (fileno (in_stream), &file_stats))
996 error (0, errno, "%s", input_filename);
1001 /* The st_size field is valid only for regular files
1002 (and for symbolic links, which cannot occur here).
1003 If the number of bytes left to skip is at least as large as
1004 the size of the current file, we can decrement
1005 n_skip and go on to the next file. */
1006 if (S_ISREG (file_stats.st_mode))
1008 if (n_skip >= file_stats.st_size)
1010 n_skip -= file_stats.st_size;
1011 if (in_stream != stdin && fclose (in_stream) == EOF)
1013 error (0, errno, "%s", input_filename);
1020 if (0 <= lseek (fileno (in_stream), n_skip, SEEK_CUR))
1028 /* Seek didn't work or wasn't attempted; position the file pointer
1031 for (j = n_skip / BUFSIZ; j >= 0; j--)
1034 size_t n_bytes_to_read = (j > 0
1037 size_t n_bytes_read;
1038 n_bytes_read = fread (buf, 1, n_bytes_to_read, in_stream);
1039 n_skip -= n_bytes_read;
1040 if (n_bytes_read != n_bytes_to_read)
1049 error (EXIT_FAILURE, 0, _("cannot skip past end of combined input"));
1055 format_address_none (off_t address ATTRIBUTE_UNUSED)
1061 format_address_std (off_t address)
1063 const char *address_string;
1065 sprintf (address_fmt_buffer, output_address_fmt_string, address);
1066 address_string = address_fmt_buffer;
1067 return address_string;
1071 format_address_label (off_t address)
1073 const char *address_string;
1074 assert (output_address_fmt_string != NULL);
1076 sprintf (address_fmt_buffer, output_address_fmt_string,
1077 address, address + pseudo_offset);
1078 address_string = address_fmt_buffer;
1079 return address_string;
1082 /* Write N_BYTES bytes from CURR_BLOCK to standard output once for each
1083 of the N_SPEC format specs. CURRENT_OFFSET is the byte address of
1084 CURR_BLOCK in the concatenation of input files, and it is printed
1085 (optionally) only before the output line associated with the first
1086 format spec. When duplicate blocks are being abbreviated, the output
1087 for a sequence of identical input blocks is the output for the first
1088 block followed by an asterisk alone on a line. It is valid to compare
1089 the blocks PREV_BLOCK and CURR_BLOCK only when N_BYTES == BYTES_PER_BLOCK.
1090 That condition may be false only for the last input block -- and then
1091 only when it has not been padded to length BYTES_PER_BLOCK. */
1094 write_block (off_t current_offset, long unsigned int n_bytes,
1095 const char *prev_block, const char *curr_block)
1097 static int first = 1;
1098 static int prev_pair_equal = 0;
1100 #define EQUAL_BLOCKS(b1, b2) (memcmp ((b1), (b2), bytes_per_block) == 0)
1102 if (abbreviate_duplicate_blocks
1103 && !first && n_bytes == bytes_per_block
1104 && EQUAL_BLOCKS (prev_block, curr_block))
1106 if (prev_pair_equal)
1108 /* The two preceding blocks were equal, and the current
1109 block is the same as the last one, so print nothing. */
1114 prev_pair_equal = 1;
1121 prev_pair_equal = 0;
1122 for (i = 0; i < n_specs; i++)
1124 const char *addr_or_pad = (i == 0
1125 ? format_address (current_offset)
1128 fputs (addr_or_pad, stdout);
1129 (*spec[i].print_function) (n_bytes, curr_block, spec[i].fmt_string);
1130 if (spec[i].hexl_mode_trailer)
1132 /* space-pad out to full line width, then dump the trailer */
1133 int datum_width = width_bytes[spec[i].size];
1134 int blank_fields = (bytes_per_block - n_bytes) / datum_width;
1135 int field_width = spec[i].field_width + 1;
1136 printf ("%*s", blank_fields * field_width, "");
1137 dump_hexl_mode_trailer (n_bytes, curr_block);
1145 /* Test whether there have been errors on in_stream, and close it if
1146 it is not standard input. Return nonzero if there has been an error
1147 on in_stream or stdout; return zero otherwise. This function will
1148 report more than one error only if both a read and a write error
1152 check_and_close (void)
1157 if (ferror (in_stream))
1159 error (0, errno, "%s", input_filename);
1160 if (in_stream != stdin)
1164 else if (in_stream != stdin && fclose (in_stream) == EOF)
1166 error (0, errno, "%s", input_filename);
1170 if (ferror (stdout))
1172 error (0, errno, _("standard output"));
1179 /* Read a single byte into *C from the concatenation of the input files
1180 named in the global array FILE_LIST. On the first call to this
1181 function, the global variable IN_STREAM is expected to be an open
1182 stream associated with the input file *FILE_LIST. If IN_STREAM is
1183 at end-of-file, close it and update the global variables IN_STREAM,
1184 FILE_LIST, and INPUT_FILENAME so they correspond to the next file in
1185 the list. Then try to read a byte from the newly opened file.
1186 Repeat if necessary until *FILE_LIST is NULL. When EOF is reached
1187 for the last file in FILE_LIST, set *C to EOF and return. Subsequent
1188 calls do likewise. The return value is nonzero if any errors
1189 occured, zero otherwise. */
1196 if (*file_list == NULL)
1205 *c = fgetc (in_stream);
1210 err |= check_and_close ();
1215 if (*file_list == NULL)
1218 if (STREQ (*file_list, "-"))
1220 input_filename = _("standard input");
1222 have_read_stdin = 1;
1226 input_filename = *file_list;
1227 in_stream = fopen (input_filename, "r");
1228 if (in_stream == NULL)
1230 error (0, errno, "%s", input_filename);
1234 SET_BINARY (fileno (in_stream));
1236 while (in_stream == NULL);
1240 /* Read N bytes into BLOCK from the concatenation of the input files
1241 named in the global array FILE_LIST. On the first call to this
1242 function, the global variable IN_STREAM is expected to be an open
1243 stream associated with the input file *FILE_LIST. On subsequent
1244 calls, if *FILE_LIST is NULL, don't modify BLOCK and return zero.
1245 If all N bytes cannot be read from IN_STREAM, close IN_STREAM and
1246 update the global variables IN_STREAM, FILE_LIST, and INPUT_FILENAME.
1247 Then try to read the remaining bytes from the newly opened file.
1248 Repeat if necessary until *FILE_LIST is NULL. Set *N_BYTES_IN_BUFFER
1249 to the number of bytes read. If an error occurs, it will be detected
1250 through ferror when the stream is about to be closed. If there is an
1251 error, give a message but continue reading as usual and return nonzero.
1252 Otherwise return zero. */
1255 read_block (size_t n, char *block, size_t *n_bytes_in_buffer)
1259 assert (n > 0 && n <= bytes_per_block);
1261 *n_bytes_in_buffer = 0;
1266 if (*file_list == NULL)
1267 return 0; /* EOF. */
1275 n_needed = n - *n_bytes_in_buffer;
1276 n_read = fread (block + *n_bytes_in_buffer, 1, n_needed, in_stream);
1278 *n_bytes_in_buffer += n_read;
1280 if (n_read == n_needed)
1283 err |= check_and_close ();
1288 if (*file_list == NULL)
1291 if (STREQ (*file_list, "-"))
1293 input_filename = _("standard input");
1295 have_read_stdin = 1;
1299 input_filename = *file_list;
1300 in_stream = fopen (input_filename, "r");
1301 if (in_stream == NULL)
1303 error (0, errno, "%s", input_filename);
1307 SET_BINARY (fileno (in_stream));
1309 while (in_stream == NULL);
1313 /* Return the least common multiple of the sizes associated
1314 with the format specs. */
1322 for (i = 0; i < n_specs; i++)
1323 l_c_m = lcm (l_c_m, width_bytes[(int) spec[i].size]);
1327 /* If S is a valid pre-POSIX offset specification with an optional leading '+'
1328 return the offset it denotes. Otherwise, return -1. */
1331 parse_old_offset (const char *s)
1335 enum strtol_error s_err;
1336 long unsigned int tmp;
1341 /* Skip over any leading '+'. */
1345 /* Determine the radix we'll use to interpret S. If there is a `.',
1346 it's decimal, otherwise, if the string begins with `0X'or `0x',
1347 it's hexadecimal, else octal. */
1348 if (strchr (s, '.') != NULL)
1352 if (s[0] == '0' && (s[1] == 'x' || s[1] == 'X'))
1358 s_err = xstrtoul (s, NULL, radix, &tmp, "Bb");
1359 if (s_err != LONGINT_OK)
1361 STRTOL_FAIL_WARN (s, _("old-style offset"), s_err);
1368 /* Read a chunk of size BYTES_PER_BLOCK from the input files, write the
1369 formatted block to standard output, and repeat until the specified
1370 maximum number of bytes has been read or until all input has been
1371 processed. If the last block read is smaller than BYTES_PER_BLOCK
1372 and its size is not a multiple of the size associated with a format
1373 spec, extend the input block with zero bytes until its length is a
1374 multiple of all format spec sizes. Write the final block. Finally,
1375 write on a line by itself the offset of the byte after the last byte
1376 read. Accumulate return values from calls to read_block and
1377 check_and_close, and if any was nonzero, return nonzero.
1378 Otherwise, return zero. */
1384 off_t current_offset;
1385 off_t end_offset IF_LINT (= 0);
1388 size_t n_bytes_read;
1390 block[0] = (char *) alloca (bytes_per_block);
1391 block[1] = (char *) alloca (bytes_per_block);
1393 current_offset = n_bytes_to_skip;
1397 if (limit_bytes_to_format)
1399 end_offset = n_bytes_to_skip + max_bytes_to_format;
1404 if (current_offset >= end_offset)
1409 n_needed = MIN (end_offset - current_offset,
1410 (off_t) bytes_per_block);
1411 err |= read_block (n_needed, block[idx], &n_bytes_read);
1412 if (n_bytes_read < bytes_per_block)
1414 assert (n_bytes_read == bytes_per_block);
1415 write_block (current_offset, n_bytes_read,
1416 block[!idx], block[idx]);
1417 current_offset += n_bytes_read;
1425 err |= read_block (bytes_per_block, block[idx], &n_bytes_read);
1426 if (n_bytes_read < bytes_per_block)
1428 assert (n_bytes_read == bytes_per_block);
1429 write_block (current_offset, n_bytes_read,
1430 block[!idx], block[idx]);
1431 current_offset += n_bytes_read;
1436 if (n_bytes_read > 0)
1439 size_t bytes_to_write;
1443 /* Make bytes_to_write the smallest multiple of l_c_m that
1444 is at least as large as n_bytes_read. */
1445 bytes_to_write = l_c_m * (int) ((n_bytes_read + l_c_m - 1) / l_c_m);
1447 memset (block[idx] + n_bytes_read, 0, bytes_to_write - n_bytes_read);
1448 write_block (current_offset, bytes_to_write,
1449 block[!idx], block[idx]);
1450 current_offset += n_bytes_read;
1453 if (output_address_fmt_string != NULL)
1454 printf ("%s\n", format_address (current_offset));
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 -
1488 (off_t) string_min))
1491 for (i = 0; i < string_min; i++)
1493 err |= read_char (&c);
1501 /* Found a non-printing. Try again starting with next char. */
1506 /* We found a run of `string_min' printable characters.
1507 Now see if it is terminated with a null byte. */
1508 while (!limit_bytes_to_format
1509 || address < n_bytes_to_skip + max_bytes_to_format)
1513 bufsize = 1 + 3 * bufsize / 2;
1514 buf = xrealloc (buf, bufsize);
1516 err |= read_char (&c);
1524 break; /* It is; print this string. */
1526 goto tryline; /* It isn't; give up on this string. */
1527 buf[i++] = c; /* String continues; store it all. */
1530 /* If we get here, the string is all printable and null-terminated,
1531 so print it. It is all in `buf' and `i' is its length. */
1533 if (output_address_fmt_string != NULL)
1535 printf ("%s ", format_address (address - i - 1));
1537 for (i = 0; (c = buf[i]); i++)
1542 fputs ("\\a", stdout);
1546 fputs ("\\b", stdout);
1550 fputs ("\\f", stdout);
1554 fputs ("\\n", stdout);
1558 fputs ("\\r", stdout);
1562 fputs ("\\t", stdout);
1566 fputs ("\\v", stdout);
1576 /* We reach this point only if we search through
1577 (max_bytes_to_format - string_min) bytes before reachine EOF. */
1581 err |= check_and_close ();
1585 /* There must be exactly one %s format specifier in FORMAT_TEMPLATE.
1586 Return the just-malloc'd result of using sprintf to insert
1587 OFF_T_PRINTF_FORMAT_STRING into FORMAT_TEMPLATE.
1588 Technically, the caller should free this memory, but IMHO it's not
1589 worth it in this case. */
1591 expand_address_fmt (char const *format_template)
1593 size_t len = strlen (format_template);
1594 char *fmt = xmalloc (len + 1);
1595 /* Ensure that the literal we're inserting is no longer than the two-byte
1596 string `%s' it's replacing. There's also the %%, so technically we don't
1597 even need the `+ 1' above. */
1598 assert (OFF_T_PRINTF_FORMAT_STRING[0] == 0
1599 || OFF_T_PRINTF_FORMAT_STRING[1] == 0
1600 || OFF_T_PRINTF_FORMAT_STRING[2] == 0);
1601 sprintf (fmt, format_template, OFF_T_PRINTF_FORMAT_STRING);
1606 main (int argc, char **argv)
1612 unsigned int address_pad_len;
1613 unsigned long int desired_width;
1614 int width_specified = 0;
1615 int n_failed_decodes = 0;
1618 /* The old-style `pseudo starting address' to be printed in parentheses
1619 after any true address. */
1620 long int 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 #ifdef HAVE_UNSIGNED_LONG_LONG
1639 integral_type_size[sizeof (long long)] = 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 output_address_fmt_string = expand_address_fmt ("%%07%so");
1657 format_address = format_address_std;
1658 address_pad_len = 7;
1659 flag_dump_strings = 0;
1661 while ((c = getopt_long (argc, argv, "abcdfhilos::xw::A:j:N:t:v",
1662 long_options, NULL)) != -1)
1664 unsigned long int tmp;
1665 enum strtol_error s_err;
1676 output_address_fmt_string = expand_address_fmt ("%%07%sd");
1677 format_address = format_address_std;
1678 address_pad_len = 7;
1681 output_address_fmt_string = expand_address_fmt ("%%07%so");
1682 format_address = format_address_std;
1683 address_pad_len = 7;
1686 output_address_fmt_string = expand_address_fmt ("%%06%sx");
1687 format_address = format_address_std;
1688 address_pad_len = 6;
1691 output_address_fmt_string = NULL;
1692 format_address = format_address_none;
1693 address_pad_len = 0;
1696 error (EXIT_FAILURE, 0,
1697 _("invalid output address radix `%c'; \
1698 it must be one character from [doxn]"),
1705 s_err = xstrtoul (optarg, NULL, 0, &tmp, "bkm");
1706 n_bytes_to_skip = tmp;
1707 if (s_err != LONGINT_OK)
1708 STRTOL_FATAL_ERROR (optarg, _("skip argument"), s_err);
1712 limit_bytes_to_format = 1;
1714 /* FIXME: if off_t is long long and that's an 8-byte type,
1715 use xstrtouq here. */
1716 s_err = xstrtoul (optarg, NULL, 0, &tmp, "bkm");
1717 max_bytes_to_format = tmp;
1718 if (s_err != LONGINT_OK)
1719 STRTOL_FATAL_ERROR (optarg, _("limit argument"), s_err);
1722 error (EXIT_FAILURE, 0,
1723 _("specified number of bytes `%s' is larger than \
1724 the maximum\nrepresentable value of type `long'"), optarg);
1732 s_err = xstrtoul (optarg, NULL, 0, &string_min, "bkm");
1733 if (s_err != LONGINT_OK)
1734 STRTOL_FATAL_ERROR (optarg, _("minimum string length"), s_err);
1736 ++flag_dump_strings;
1740 if (decode_format_string (optarg))
1745 abbreviate_duplicate_blocks = 0;
1752 /* The next several cases map the old, pre-POSIX format
1753 specification options to the corresponding POSIX format
1754 specs. GNU od accepts any combination of old- and
1755 new-style options. Format specification options accumulate. */
1757 #define CASE_OLD_ARG(old_char,new_string) \
1760 if (decode_format_string (new_string)) \
1761 ++n_failed_decodes; \
1765 CASE_OLD_ARG ('a', "a");
1766 CASE_OLD_ARG ('b', "oC");
1767 CASE_OLD_ARG ('c', "c");
1768 CASE_OLD_ARG ('d', "u2");
1769 CASE_OLD_ARG ('f', "fF");
1770 CASE_OLD_ARG ('h', "x2");
1771 CASE_OLD_ARG ('i', "d2");
1772 CASE_OLD_ARG ('l', "d4");
1773 CASE_OLD_ARG ('o', "o2");
1774 CASE_OLD_ARG ('x', "x2");
1779 width_specified = 1;
1786 s_err = xstrtoul (optarg, NULL, 10, &desired_width, "");
1787 if (s_err != LONGINT_OK)
1788 STRTOL_FATAL_ERROR (optarg, _("width specification"), s_err);
1792 case_GETOPT_HELP_CHAR;
1794 case_GETOPT_VERSION_CHAR (PROGRAM_NAME, AUTHORS);
1802 if (n_failed_decodes > 0)
1803 exit (EXIT_FAILURE);
1805 if (flag_dump_strings && n_specs > 0)
1806 error (EXIT_FAILURE, 0,
1807 _("no type may be specified when dumping strings"));
1809 n_files = argc - optind;
1811 /* If the --backward-compatible option is used, there may be from
1812 0 to 3 remaining command line arguments; handle each case
1814 od [file] [[+]offset[.][b] [[+]label[.][b]]]
1815 The offset and pseudo_start have the same syntax. */
1823 if ((offset = parse_old_offset (argv[optind])) >= 0)
1825 n_bytes_to_skip = offset;
1830 else if (n_files == 2)
1833 if ((o1 = parse_old_offset (argv[optind])) >= 0
1834 && (o2 = parse_old_offset (argv[optind + 1])) >= 0)
1836 n_bytes_to_skip = o1;
1837 flag_pseudo_start = 1;
1842 else if ((o2 = parse_old_offset (argv[optind + 1])) >= 0)
1844 n_bytes_to_skip = o2;
1846 argv[optind + 1] = argv[optind];
1852 _("invalid second operand in compatibility mode `%s'"),
1857 else if (n_files == 3)
1860 if ((o1 = parse_old_offset (argv[optind + 1])) >= 0
1861 && (o2 = parse_old_offset (argv[optind + 2])) >= 0)
1863 n_bytes_to_skip = o1;
1864 flag_pseudo_start = 1;
1866 argv[optind + 2] = argv[optind];
1873 _("in compatibility mode, the last two arguments must be offsets"));
1877 else if (n_files > 3)
1880 _("compatibility mode supports at most three arguments"));
1884 if (flag_pseudo_start)
1886 static char buf[10];
1888 if (output_address_fmt_string == NULL)
1890 output_address_fmt_string = expand_address_fmt ("(%%07%so)");
1891 format_address = format_address_std;
1895 sprintf (buf, "%s (%s)",
1896 output_address_fmt_string,
1897 output_address_fmt_string);
1898 output_address_fmt_string = buf;
1899 format_address = format_address_label;
1904 assert (address_pad_len <= MAX_ADDRESS_LENGTH);
1905 for (i = 0; i < address_pad_len; i++)
1906 address_pad[i] = ' ';
1907 address_pad[address_pad_len] = '\0';
1911 if (decode_one_format ("o2", "o2", NULL, &(spec[0])))
1913 /* This happens on Cray systems that don't have a 2-byte
1915 exit (EXIT_FAILURE);
1922 file_list = (char const *const *) &argv[optind];
1925 /* If no files were listed on the command line, set up the
1926 global array FILE_LIST so that it contains the null-terminated
1927 list of one name: "-". */
1928 static char const *const default_file_list[] = {"-", NULL};
1930 file_list = default_file_list;
1933 err |= skip (n_bytes_to_skip);
1934 if (in_stream == NULL)
1937 pseudo_offset = (flag_pseudo_start ? pseudo_start - n_bytes_to_skip : 0);
1939 /* Compute output block length. */
1942 if (width_specified)
1944 if (desired_width != 0 && desired_width % l_c_m == 0)
1945 bytes_per_block = desired_width;
1948 error (0, 0, _("warning: invalid width %lu; using %d instead"),
1949 desired_width, l_c_m);
1950 bytes_per_block = l_c_m;
1955 if (l_c_m < DEFAULT_BYTES_PER_BLOCK)
1956 bytes_per_block = l_c_m * (int) (DEFAULT_BYTES_PER_BLOCK / l_c_m);
1958 bytes_per_block = l_c_m;
1962 for (i = 0; i < n_specs; i++)
1964 printf (_("%d: fmt=\"%s\" width=%d\n"),
1965 i, spec[i].fmt_string, width_bytes[spec[i].size]);
1969 err |= (flag_dump_strings ? dump_strings () : dump ());
1973 if (have_read_stdin && fclose (stdin) == EOF)
1974 error (EXIT_FAILURE, errno, _("standard input"));
1976 exit (err == 0 ? EXIT_SUCCESS : EXIT_FAILURE);