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 If no file-arguments were specified, this variable is initialized
220 static char const *const *file_list;
222 /* The input stream associated with the current file. */
223 static FILE *in_stream;
225 /* If nonzero, at least one of the files we read was standard input. */
226 static int have_read_stdin;
228 #if HAVE_UNSIGNED_LONG_LONG
229 # define LONGEST_INTEGRAL_TYPE unsigned long long
231 # define LONGEST_INTEGRAL_TYPE long int
234 #define MAX_INTEGRAL_TYPE_SIZE sizeof(LONGEST_INTEGRAL_TYPE)
235 static enum size_spec integral_type_size[MAX_INTEGRAL_TYPE_SIZE + 1];
237 #define MAX_FP_TYPE_SIZE sizeof(LONG_DOUBLE)
238 static enum size_spec fp_type_size[MAX_FP_TYPE_SIZE + 1];
240 static struct option const long_options[] =
243 {"skip-bytes", required_argument, NULL, 'j'},
244 {"address-radix", required_argument, NULL, 'A'},
245 {"read-bytes", required_argument, NULL, 'N'},
246 {"format", required_argument, NULL, 't'},
247 {"output-duplicates", no_argument, NULL, 'v'},
249 /* non-POSIX options. */
250 {"strings", optional_argument, NULL, 's'},
251 {"traditional", no_argument, NULL, 'B'},
252 {"width", optional_argument, NULL, 'w'},
254 {GETOPT_HELP_OPTION_DECL},
255 {GETOPT_VERSION_OPTION_DECL},
263 fprintf (stderr, _("Try `%s --help' for more information.\n"),
268 Usage: %s [OPTION]... [FILE]...\n\
269 or: %s --traditional [FILE] [[+]OFFSET [[+]LABEL]]\n\
271 program_name, program_name);
273 Write an unambiguous representation, octal bytes by default, of FILE\n\
274 to standard output. With no FILE, or when FILE is -, read standard input.\n\
276 -A, --address-radix=RADIX decide how file offsets are printed\n\
277 -j, --skip-bytes=BYTES skip BYTES input bytes first on each file\n\
278 -N, --read-bytes=BYTES limit dump to BYTES input bytes per file\n\
279 -s, --strings[=BYTES] output strings of at least BYTES graphic chars\n\
280 -t, --format=TYPE select output format or formats\n\
281 -v, --output-duplicates do not use * to mark line suppression\n\
282 -w, --width[=BYTES] output BYTES bytes per output line\n\
283 --traditional accept arguments in pre-POSIX form\n\
284 --help display this help and exit\n\
285 --version output version information and exit\n\
287 Pre-POSIX format specifications may be intermixed, they accumulate:\n\
288 -a same as -t a, select named characters\n\
289 -b same as -t oC, select octal bytes\n\
290 -c same as -t c, select ASCII characters or backslash escapes\n\
291 -d same as -t u2, select unsigned decimal shorts\n\
292 -f same as -t fF, select floats\n\
293 -h same as -t x2, select hexadecimal shorts\n\
294 -i same as -t d2, select decimal shorts\n\
295 -l same as -t d4, select decimal longs\n\
296 -o same as -t o2, select octal shorts\n\
297 -x same as -t x2, select hexadecimal shorts\n\
301 For older syntax (second call format), OFFSET means -j OFFSET. LABEL\n\
302 is the pseudo-address at first byte printed, incremented when dump is\n\
303 progressing. For OFFSET and LABEL, a 0x or 0X prefix indicates\n\
304 hexadecimal, suffixes maybe . for octal and b multiply by 512.\n\
306 TYPE is made up of one or more of these specifications:\n\
309 c ASCII character or backslash escape\n\
310 d[SIZE] signed decimal, SIZE bytes per integer\n\
311 f[SIZE] floating point, SIZE bytes per integer\n\
312 o[SIZE] octal, SIZE bytes per integer\n\
313 u[SIZE] unsigned decimal, SIZE bytes per integer\n\
314 x[SIZE] hexadecimal, SIZE bytes per integer\n\
316 SIZE is a number. For TYPE in doux, SIZE may also be C for\n\
317 sizeof(char), S for sizeof(short), I for sizeof(int) or L for\n\
318 sizeof(long). If TYPE is f, SIZE may also be F for sizeof(float), D\n\
319 for sizeof(double) or L for sizeof(long double).\n\
321 RADIX is d for decimal, o for octal, x for hexadecimal or n for none.\n\
322 BYTES is hexadecimal with 0x or 0X prefix, it is multiplied by 512\n\
323 with b suffix, by 1024 with k and by 1048576 with m. Adding a z suffix to\n\
324 any type adds a display of printable characters to the end of each line\n\
325 of output. -s without a number implies 3. -w without a number implies 32.\n\
326 By default, od uses -A o -t d2 -w 16.\n\
328 puts (_("\nReport bugs to <bug-textutils@gnu.org>."));
330 exit (status == 0 ? EXIT_SUCCESS : EXIT_FAILURE);
333 /* Compute the greatest common denominator of U and V
334 using Euclid's algorithm. */
337 gcd (unsigned int u, unsigned int v)
349 /* Compute the least common multiple of U and V. */
352 lcm (unsigned int u, unsigned int v)
354 unsigned int t = gcd (u, v);
361 print_s_char (off_t n_bytes, const char *block, const char *fmt_string)
364 for (i = n_bytes; i > 0; i--)
366 int tmp = (unsigned) *(const unsigned char *) block;
368 tmp -= SCHAR_MAX - SCHAR_MIN + 1;
369 assert (tmp <= SCHAR_MAX);
370 printf (fmt_string, tmp);
371 block += sizeof (unsigned char);
376 print_char (off_t n_bytes, const char *block, const char *fmt_string)
379 for (i = n_bytes; i > 0; i--)
381 unsigned int tmp = *(const unsigned char *) block;
382 printf (fmt_string, tmp);
383 block += sizeof (unsigned char);
388 print_s_short (off_t n_bytes, const char *block, const char *fmt_string)
391 for (i = n_bytes / sizeof (unsigned short); i > 0; i--)
393 int tmp = (unsigned) *(const unsigned short *) block;
395 tmp -= SHRT_MAX - SHRT_MIN + 1;
396 assert (tmp <= SHRT_MAX);
397 printf (fmt_string, tmp);
398 block += sizeof (unsigned short);
403 print_short (off_t n_bytes, const char *block, const char *fmt_string)
406 for (i = n_bytes / sizeof (unsigned short); i > 0; i--)
408 unsigned int tmp = *(const unsigned short *) block;
409 printf (fmt_string, tmp);
410 block += sizeof (unsigned short);
415 print_int (off_t n_bytes, const char *block, const char *fmt_string)
418 for (i = n_bytes / sizeof (unsigned int); i > 0; i--)
420 unsigned int tmp = *(const unsigned int *) block;
421 printf (fmt_string, tmp);
422 block += sizeof (unsigned int);
427 print_long (off_t n_bytes, const char *block, const char *fmt_string)
430 for (i = n_bytes / sizeof (unsigned long); i > 0; i--)
432 unsigned long tmp = *(const unsigned long *) block;
433 printf (fmt_string, tmp);
434 block += sizeof (unsigned long);
438 #if HAVE_UNSIGNED_LONG_LONG
440 print_long_long (off_t n_bytes, const char *block, const char *fmt_string)
443 for (i = n_bytes / sizeof (unsigned long long); i > 0; i--)
445 unsigned long long tmp = *(const unsigned long long *) block;
446 printf (fmt_string, tmp);
447 block += sizeof (unsigned long long);
453 print_float (off_t n_bytes, const char *block, const char *fmt_string)
456 for (i = n_bytes / sizeof (float); i > 0; i--)
458 float tmp = *(const float *) block;
459 printf (fmt_string, tmp);
460 block += sizeof (float);
465 print_double (off_t n_bytes, const char *block, const char *fmt_string)
468 for (i = n_bytes / sizeof (double); i > 0; i--)
470 double tmp = *(const double *) block;
471 printf (fmt_string, tmp);
472 block += sizeof (double);
476 #ifdef HAVE_LONG_DOUBLE
478 print_long_double (off_t n_bytes, const char *block, const char *fmt_string)
481 for (i = n_bytes / sizeof (LONG_DOUBLE); i > 0; i--)
483 LONG_DOUBLE tmp = *(const LONG_DOUBLE *) block;
484 printf (fmt_string, tmp);
485 block += sizeof (LONG_DOUBLE);
492 dump_hexl_mode_trailer (off_t n_bytes, const char *block)
495 fputs (" >", stdout);
496 for (i = n_bytes; i > 0; i--)
498 unsigned int c = *(const unsigned char *) block;
499 unsigned int c2 = (ISPRINT(c) ? c : '.');
501 block += sizeof (unsigned char);
507 print_named_ascii (off_t n_bytes, const char *block,
508 const char *unused_fmt_string ATTRIBUTE_UNUSED)
511 for (i = n_bytes; i > 0; i--)
513 unsigned int c = *(const unsigned char *) block;
514 unsigned int masked_c = (0x7f & c);
520 else if (masked_c <= 040)
521 s = charname[masked_c];
524 sprintf (buf, " %c", masked_c);
529 block += sizeof (unsigned char);
534 print_ascii (off_t n_bytes, const char *block,
535 const char *unused_fmt_string ATTRIBUTE_UNUSED)
538 for (i = n_bytes; i > 0; i--)
540 unsigned int c = *(const unsigned char *) block;
579 sprintf (buf, (ISPRINT (c) ? " %c" : "%03o"), c);
580 s = (const char *) buf;
584 block += sizeof (unsigned char);
588 /* Convert a null-terminated (possibly zero-length) string S to an
589 unsigned long integer value. If S points to a non-digit set *P to S,
590 *VAL to 0, and return 0. Otherwise, accumulate the integer value of
591 the string of digits. If the string of digits represents a value
592 larger than ULONG_MAX, don't modify *VAL or *P and return nonzero.
593 Otherwise, advance *P to the first non-digit after S, set *VAL to
594 the result of the conversion and return zero. */
597 simple_strtoul (const char *s, const char **p, long unsigned int *val)
599 unsigned long int sum;
604 unsigned int c = *s++ - '0';
605 if (sum > (ULONG_MAX - c) / 10)
614 /* If S points to a single valid POSIX-style od format string, put
615 a description of that format in *TSPEC, make *NEXT point at the
616 character following the just-decoded format (if *NEXT is non-NULL),
617 and return zero. If S is not valid, don't modify *NEXT or *TSPEC,
618 give a diagnostic, and return nonzero. For example, if S were
619 "d4afL" *NEXT would be set to "afL" and *TSPEC would be
621 fmt = SIGNED_DECIMAL;
622 size = INT or LONG; (whichever integral_type_size[4] resolves to)
623 print_function = print_int; (assuming size == INT)
624 fmt_string = "%011d%c";
626 S_ORIG is solely for reporting errors. It should be the full format
631 decode_one_format (const char *s_orig, const char *s, const char **next,
634 enum size_spec size_spec;
635 unsigned long int size;
636 enum output_format fmt;
637 const char *pre_fmt_string;
639 void (*print_function) PARAMS ((off_t, const char *, const char *));
642 unsigned int field_width = 0;
644 assert (tspec != NULL);
658 size = sizeof (char);
663 size = sizeof (short);
673 size = sizeof (long int);
677 if (simple_strtoul (s, &p, &size) != 0)
679 /* The integer at P in S would overflow an unsigned long.
680 A digit string that long is sufficiently odd looking
681 that the following diagnostic is sufficient. */
682 error (0, 0, _("invalid type string `%s'"), s_orig);
689 if (MAX_INTEGRAL_TYPE_SIZE < size
690 || integral_type_size[size] == NO_SIZE)
692 error (0, 0, _("invalid type string `%s';\n\
693 this system doesn't provide a %lu-byte integral type"), s_orig, size);
701 #define FMT_BYTES_ALLOCATED 9
702 fmt_string = xmalloc (FMT_BYTES_ALLOCATED);
704 size_spec = integral_type_size[size];
709 fmt = SIGNED_DECIMAL;
710 sprintf (fmt_string, " %%%u%sd",
711 (field_width = bytes_to_signed_dec_digits[size]),
712 (size_spec == LONG ? "l"
713 : (size_spec == LONG_LONG ? "ll"
719 sprintf (fmt_string, " %%0%u%so",
720 (field_width = bytes_to_oct_digits[size]),
721 (size_spec == LONG ? "l" : ""));
725 fmt = UNSIGNED_DECIMAL;
726 sprintf (fmt_string, " %%%u%su",
727 (field_width = bytes_to_unsigned_dec_digits[size]),
728 (size_spec == LONG ? "l" : ""));
733 sprintf (fmt_string, " %%0%u%sx",
734 (field_width = bytes_to_hex_digits[size]),
735 (size_spec == LONG ? "l" : ""));
742 assert (strlen (fmt_string) < FMT_BYTES_ALLOCATED);
747 print_function = (fmt == SIGNED_DECIMAL
753 print_function = (fmt == SIGNED_DECIMAL
759 print_function = print_int;
763 print_function = print_long;
767 #if HAVE_UNSIGNED_LONG_LONG
768 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, char c ATTRIBUTE_UNUSED)
1051 format_address_std (off_t address, char c)
1053 char buf[MAX_ADDRESS_LENGTH + 2];
1054 char *p = buf + sizeof buf;
1059 pbound = p - address_pad_len;
1061 /* Use a special case of the code for each base. This is measurably
1062 faster than generic code. */
1063 switch (address_base)
1067 *--p = '0' + (address & 7);
1068 while ((address >>= 3) != 0);
1073 *--p = '0' + (address % 10);
1074 while ((address /= 10) != 0);
1079 *--p = "0123456789abcdef"[address & 15];
1080 while ((address >>= 4) != 0);
1091 format_address_paren (off_t address, char c)
1094 format_address_std (address, ')');
1099 format_address_label (off_t address, char c)
1101 format_address_std (address, ' ');
1102 format_address_paren (address + pseudo_offset, c);
1105 /* Write N_BYTES bytes from CURR_BLOCK to standard output once for each
1106 of the N_SPEC format specs. CURRENT_OFFSET is the byte address of
1107 CURR_BLOCK in the concatenation of input files, and it is printed
1108 (optionally) only before the output line associated with the first
1109 format spec. When duplicate blocks are being abbreviated, the output
1110 for a sequence of identical input blocks is the output for the first
1111 block followed by an asterisk alone on a line. It is valid to compare
1112 the blocks PREV_BLOCK and CURR_BLOCK only when N_BYTES == BYTES_PER_BLOCK.
1113 That condition may be false only for the last input block -- and then
1114 only when it has not been padded to length BYTES_PER_BLOCK. */
1117 write_block (off_t current_offset, off_t n_bytes,
1118 const char *prev_block, const char *curr_block)
1120 static int first = 1;
1121 static int prev_pair_equal = 0;
1123 #define EQUAL_BLOCKS(b1, b2) (memcmp ((b1), (b2), bytes_per_block) == 0)
1125 if (abbreviate_duplicate_blocks
1126 && !first && n_bytes == bytes_per_block
1127 && EQUAL_BLOCKS (prev_block, curr_block))
1129 if (prev_pair_equal)
1131 /* The two preceding blocks were equal, and the current
1132 block is the same as the last one, so print nothing. */
1137 prev_pair_equal = 1;
1144 prev_pair_equal = 0;
1145 for (i = 0; i < n_specs; i++)
1148 format_address (current_offset, '\0');
1150 printf ("%*s", address_pad_len, "");
1151 (*spec[i].print_function) (n_bytes, curr_block, spec[i].fmt_string);
1152 if (spec[i].hexl_mode_trailer)
1154 /* space-pad out to full line width, then dump the trailer */
1155 int datum_width = width_bytes[spec[i].size];
1156 int blank_fields = (bytes_per_block - n_bytes) / datum_width;
1157 int field_width = spec[i].field_width + 1;
1158 printf ("%*s", blank_fields * field_width, "");
1159 dump_hexl_mode_trailer (n_bytes, curr_block);
1167 /* Test whether there have been errors on in_stream, and close it if
1168 it is not standard input. Return nonzero if there has been an error
1169 on in_stream or stdout; return zero otherwise. This function will
1170 report more than one error only if both a read and a write error
1174 check_and_close (void)
1179 if (ferror (in_stream))
1181 error (0, errno, "%s", input_filename);
1182 if (in_stream != stdin)
1186 else if (in_stream != stdin && fclose (in_stream) == EOF)
1188 error (0, errno, "%s", input_filename);
1192 if (ferror (stdout))
1194 error (0, errno, _("standard output"));
1201 /* Read a single byte into *C from the concatenation of the input files
1202 named in the global array FILE_LIST. On the first call to this
1203 function, the global variable IN_STREAM is expected to be an open
1204 stream associated with the input file *FILE_LIST. If IN_STREAM is
1205 at end-of-file, close it and update the global variables IN_STREAM,
1206 FILE_LIST, and INPUT_FILENAME so they correspond to the next file in
1207 the list. Then try to read a byte from the newly opened file.
1208 Repeat if necessary until *FILE_LIST is NULL. When EOF is reached
1209 for the last file in FILE_LIST, set *C to EOF and return. Subsequent
1210 calls do likewise. The return value is nonzero if any errors
1211 occured, zero otherwise. */
1218 if (*file_list == NULL)
1227 *c = fgetc (in_stream);
1232 err |= check_and_close ();
1237 if (*file_list == NULL)
1240 if (STREQ (*file_list, "-"))
1242 input_filename = _("standard input");
1244 have_read_stdin = 1;
1248 input_filename = *file_list;
1249 in_stream = fopen (input_filename, "r");
1250 if (in_stream == NULL)
1252 error (0, errno, "%s", input_filename);
1256 SET_BINARY (fileno (in_stream));
1258 while (in_stream == NULL);
1262 /* Read N bytes into BLOCK from the concatenation of the input files
1263 named in the global array FILE_LIST. On the first call to this
1264 function, the global variable IN_STREAM is expected to be an open
1265 stream associated with the input file *FILE_LIST. On subsequent
1266 calls, if *FILE_LIST is NULL, don't modify BLOCK and return zero.
1267 If all N bytes cannot be read from IN_STREAM, close IN_STREAM and
1268 update the global variables IN_STREAM, FILE_LIST, and INPUT_FILENAME.
1269 Then try to read the remaining bytes from the newly opened file.
1270 Repeat if necessary until *FILE_LIST is NULL. Set *N_BYTES_IN_BUFFER
1271 to the number of bytes read. If an error occurs, it will be detected
1272 through ferror when the stream is about to be closed. If there is an
1273 error, give a message but continue reading as usual and return nonzero.
1274 Otherwise return zero. */
1277 read_block (size_t n, char *block, size_t *n_bytes_in_buffer)
1281 assert (0 < n && n <= bytes_per_block);
1283 *n_bytes_in_buffer = 0;
1288 if (*file_list == NULL)
1289 return 0; /* EOF. */
1297 n_needed = n - *n_bytes_in_buffer;
1298 n_read = fread (block + *n_bytes_in_buffer, 1, n_needed, in_stream);
1300 *n_bytes_in_buffer += n_read;
1302 if (n_read == n_needed)
1305 err |= check_and_close ();
1310 if (*file_list == NULL)
1313 if (STREQ (*file_list, "-"))
1315 input_filename = _("standard input");
1317 have_read_stdin = 1;
1321 input_filename = *file_list;
1322 in_stream = fopen (input_filename, "r");
1323 if (in_stream == NULL)
1325 error (0, errno, "%s", input_filename);
1329 SET_BINARY (fileno (in_stream));
1331 while (in_stream == NULL);
1335 /* Return the least common multiple of the sizes associated
1336 with the format specs. */
1344 for (i = 0; i < n_specs; i++)
1345 l_c_m = lcm (l_c_m, width_bytes[(int) spec[i].size]);
1349 /* If S is a valid pre-POSIX offset specification with an optional leading '+'
1350 return the offset it denotes. Otherwise, return -1. */
1353 parse_old_offset (const char *s)
1357 enum strtol_error s_err;
1363 /* Skip over any leading '+'. */
1367 /* Determine the radix we'll use to interpret S. If there is a `.',
1368 it's decimal, otherwise, if the string begins with `0X'or `0x',
1369 it's hexadecimal, else octal. */
1370 if (strchr (s, '.') != NULL)
1374 if (s[0] == '0' && (s[1] == 'x' || s[1] == 'X'))
1380 s_err = xstrtoumax (s, NULL, radix, &tmp, "Bb");
1381 if (s_err != LONGINT_OK)
1383 STRTOL_FAIL_WARN (s, _("old-style offset"), s_err);
1386 if (OFF_T_MAX < tmp)
1387 error (EXIT_FAILURE, 0,
1388 _("%s is larger than the maximum file size on this system"), s);
1393 /* Read a chunk of size BYTES_PER_BLOCK from the input files, write the
1394 formatted block to standard output, and repeat until the specified
1395 maximum number of bytes has been read or until all input has been
1396 processed. If the last block read is smaller than BYTES_PER_BLOCK
1397 and its size is not a multiple of the size associated with a format
1398 spec, extend the input block with zero bytes until its length is a
1399 multiple of all format spec sizes. Write the final block. Finally,
1400 write on a line by itself the offset of the byte after the last byte
1401 read. Accumulate return values from calls to read_block and
1402 check_and_close, and if any was nonzero, return nonzero.
1403 Otherwise, return zero. */
1409 off_t current_offset;
1410 off_t end_offset IF_LINT (= 0);
1413 size_t n_bytes_read;
1415 block[0] = (char *) alloca (bytes_per_block);
1416 block[1] = (char *) alloca (bytes_per_block);
1418 current_offset = n_bytes_to_skip;
1422 if (limit_bytes_to_format)
1424 end_offset = n_bytes_to_skip + max_bytes_to_format;
1429 if (current_offset >= end_offset)
1434 n_needed = MIN (end_offset - current_offset,
1435 (off_t) bytes_per_block);
1436 err |= read_block (n_needed, block[idx], &n_bytes_read);
1437 if (n_bytes_read < bytes_per_block)
1439 assert (n_bytes_read == bytes_per_block);
1440 write_block (current_offset, n_bytes_read,
1441 block[!idx], block[idx]);
1442 current_offset += n_bytes_read;
1450 err |= read_block (bytes_per_block, block[idx], &n_bytes_read);
1451 if (n_bytes_read < bytes_per_block)
1453 assert (n_bytes_read == bytes_per_block);
1454 write_block (current_offset, n_bytes_read,
1455 block[!idx], block[idx]);
1456 current_offset += n_bytes_read;
1461 if (n_bytes_read > 0)
1464 size_t bytes_to_write;
1468 /* Make bytes_to_write the smallest multiple of l_c_m that
1469 is at least as large as n_bytes_read. */
1470 bytes_to_write = l_c_m * ((n_bytes_read + l_c_m - 1) / l_c_m);
1472 memset (block[idx] + n_bytes_read, 0, bytes_to_write - n_bytes_read);
1473 write_block (current_offset, bytes_to_write,
1474 block[!idx], block[idx]);
1475 current_offset += n_bytes_read;
1478 format_address (current_offset, '\n');
1480 if (limit_bytes_to_format && current_offset > end_offset)
1481 err |= check_and_close ();
1486 /* STRINGS mode. Find each "string constant" in the input.
1487 A string constant is a run of at least `string_min' ASCII
1488 graphic (or formatting) characters terminated by a null.
1489 Based on a function written by Richard Stallman for a
1490 pre-POSIX version of od. Return nonzero if an error
1491 occurs. Otherwise, return zero. */
1496 size_t bufsize = MAX (100, string_min);
1497 char *buf = xmalloc (bufsize);
1498 off_t address = n_bytes_to_skip;
1507 /* See if the next `string_min' chars are all printing chars. */
1510 if (limit_bytes_to_format
1511 && address >= (n_bytes_to_skip + max_bytes_to_format - string_min))
1514 for (i = 0; i < string_min; i++)
1516 err |= read_char (&c);
1524 /* Found a non-printing. Try again starting with next char. */
1529 /* We found a run of `string_min' printable characters.
1530 Now see if it is terminated with a null byte. */
1531 while (!limit_bytes_to_format
1532 || address < n_bytes_to_skip + max_bytes_to_format)
1536 bufsize = 1 + 3 * bufsize / 2;
1537 buf = xrealloc (buf, bufsize);
1539 err |= read_char (&c);
1547 break; /* It is; print this string. */
1549 goto tryline; /* It isn't; give up on this string. */
1550 buf[i++] = c; /* String continues; store it all. */
1553 /* If we get here, the string is all printable and null-terminated,
1554 so print it. It is all in `buf' and `i' is its length. */
1556 format_address (address - i - 1, ' ');
1558 for (i = 0; (c = buf[i]); i++)
1563 fputs ("\\a", stdout);
1567 fputs ("\\b", stdout);
1571 fputs ("\\f", stdout);
1575 fputs ("\\n", stdout);
1579 fputs ("\\r", stdout);
1583 fputs ("\\t", stdout);
1587 fputs ("\\v", stdout);
1597 /* We reach this point only if we search through
1598 (max_bytes_to_format - string_min) bytes before reachine EOF. */
1602 err |= check_and_close ();
1607 main (int argc, char **argv)
1613 size_t desired_width IF_LINT (= 0);
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 off_t pseudo_start IF_LINT (= 0);
1622 program_name = argv[0];
1623 setlocale (LC_ALL, "");
1624 bindtextdomain (PACKAGE, LOCALEDIR);
1625 textdomain (PACKAGE);
1627 atexit (close_stdout);
1631 for (i = 0; i <= MAX_INTEGRAL_TYPE_SIZE; i++)
1632 integral_type_size[i] = NO_SIZE;
1634 integral_type_size[sizeof (char)] = CHAR;
1635 integral_type_size[sizeof (short int)] = SHORT;
1636 integral_type_size[sizeof (int)] = INT;
1637 integral_type_size[sizeof (long int)] = LONG;
1638 #if HAVE_UNSIGNED_LONG_LONG
1639 integral_type_size[sizeof (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 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)
1665 enum strtol_error s_err;
1676 format_address = format_address_std;
1678 address_pad_len = 7;
1681 format_address = format_address_std;
1683 address_pad_len = 7;
1686 format_address = format_address_std;
1688 address_pad_len = 6;
1691 format_address = format_address_none;
1692 address_pad_len = 0;
1695 error (EXIT_FAILURE, 0,
1696 _("invalid output address radix `%c'; \
1697 it must be one character from [doxn]"),
1704 s_err = xstrtoumax (optarg, NULL, 0, &tmp, "bkm");
1705 n_bytes_to_skip = tmp;
1706 if (s_err != LONGINT_OK)
1707 STRTOL_FATAL_ERROR (optarg, _("skip argument"), s_err);
1711 limit_bytes_to_format = 1;
1713 s_err = xstrtoumax (optarg, NULL, 0, &tmp, "bkm");
1714 max_bytes_to_format = tmp;
1715 if (s_err != LONGINT_OK)
1716 STRTOL_FATAL_ERROR (optarg, _("limit argument"), s_err);
1718 if (OFF_T_MAX < tmp)
1719 error (EXIT_FAILURE, 0,
1720 _("%s is larger than the maximum file size on this system"),
1729 s_err = xstrtoumax (optarg, NULL, 0, &tmp, "bkm");
1730 if (s_err != LONGINT_OK)
1731 STRTOL_FATAL_ERROR (optarg, _("minimum string length"), s_err);
1733 /* The minimum string length may be no larger than SIZE_MAX,
1734 since we may allocate a buffer of this size. */
1736 error (EXIT_FAILURE, 0, _("%s is too large"), optarg);
1740 flag_dump_strings = 1;
1744 if (decode_format_string (optarg))
1749 abbreviate_duplicate_blocks = 0;
1756 /* The next several cases map the old, pre-POSIX format
1757 specification options to the corresponding POSIX format
1758 specs. GNU od accepts any combination of old- and
1759 new-style options. Format specification options accumulate. */
1761 #define CASE_OLD_ARG(old_char,new_string) \
1764 if (decode_format_string (new_string)) \
1765 ++n_failed_decodes; \
1769 CASE_OLD_ARG ('a', "a");
1770 CASE_OLD_ARG ('b', "oC");
1771 CASE_OLD_ARG ('c', "c");
1772 CASE_OLD_ARG ('d', "u2");
1773 CASE_OLD_ARG ('f', "fF");
1774 CASE_OLD_ARG ('h', "x2");
1775 CASE_OLD_ARG ('i', "d2");
1776 CASE_OLD_ARG ('l', "d4");
1777 CASE_OLD_ARG ('o', "o2");
1778 CASE_OLD_ARG ('x', "x2");
1783 width_specified = 1;
1791 s_err = xstrtoumax (optarg, NULL, 10, &w_tmp, "");
1792 if (s_err != LONGINT_OK)
1793 STRTOL_FATAL_ERROR (optarg, _("width specification"), s_err);
1794 if (SIZE_MAX < w_tmp)
1795 error (EXIT_FAILURE, 0, _("%s is too large"), optarg);
1796 desired_width = w_tmp;
1800 case_GETOPT_HELP_CHAR;
1802 case_GETOPT_VERSION_CHAR (PROGRAM_NAME, AUTHORS);
1810 if (n_failed_decodes > 0)
1811 exit (EXIT_FAILURE);
1813 if (flag_dump_strings && n_specs > 0)
1814 error (EXIT_FAILURE, 0,
1815 _("no type may be specified when dumping strings"));
1817 n_files = argc - optind;
1819 /* If the --backward-compatible option is used, there may be from
1820 0 to 3 remaining command line arguments; handle each case
1822 od [file] [[+]offset[.][b] [[+]label[.][b]]]
1823 The offset and pseudo_start have the same syntax. */
1831 if ((offset = parse_old_offset (argv[optind])) >= 0)
1833 n_bytes_to_skip = offset;
1838 else if (n_files == 2)
1841 if ((o1 = parse_old_offset (argv[optind])) >= 0
1842 && (o2 = parse_old_offset (argv[optind + 1])) >= 0)
1844 n_bytes_to_skip = o1;
1845 flag_pseudo_start = 1;
1850 else if ((o2 = parse_old_offset (argv[optind + 1])) >= 0)
1852 n_bytes_to_skip = o2;
1854 argv[optind + 1] = argv[optind];
1860 _("invalid second operand in compatibility mode `%s'"),
1865 else if (n_files == 3)
1868 if ((o1 = parse_old_offset (argv[optind + 1])) >= 0
1869 && (o2 = parse_old_offset (argv[optind + 2])) >= 0)
1871 n_bytes_to_skip = o1;
1872 flag_pseudo_start = 1;
1874 argv[optind + 2] = argv[optind];
1881 _("in compatibility mode, the last two arguments must be offsets"));
1885 else if (n_files > 3)
1888 _("compatibility mode supports at most three arguments"));
1892 if (flag_pseudo_start)
1894 if (format_address == format_address_none)
1897 address_pad_len = 7;
1898 format_address = format_address_paren;
1901 format_address = format_address_label;
1907 if (decode_one_format ("o2", "o2", NULL, &(spec[0])))
1909 /* This happens on Cray systems that don't have a 2-byte
1911 exit (EXIT_FAILURE);
1918 file_list = (char const *const *) &argv[optind];
1921 /* If no files were listed on the command line, set up the
1922 global array FILE_LIST so that it contains the null-terminated
1923 list of one name: "-". */
1924 static char const *const default_file_list[] = {"-", NULL};
1926 file_list = default_file_list;
1929 err |= skip (n_bytes_to_skip);
1930 if (in_stream == NULL)
1933 pseudo_offset = (flag_pseudo_start ? pseudo_start - n_bytes_to_skip : 0);
1935 /* Compute output block length. */
1938 if (width_specified)
1940 if (desired_width != 0 && desired_width % l_c_m == 0)
1941 bytes_per_block = desired_width;
1944 error (0, 0, _("warning: invalid width %lu; using %d instead"),
1945 (unsigned long) desired_width, l_c_m);
1946 bytes_per_block = l_c_m;
1951 if (l_c_m < DEFAULT_BYTES_PER_BLOCK)
1952 bytes_per_block = l_c_m * (DEFAULT_BYTES_PER_BLOCK / l_c_m);
1954 bytes_per_block = l_c_m;
1958 for (i = 0; i < n_specs; i++)
1960 printf (_("%d: fmt=\"%s\" width=%d\n"),
1961 i, spec[i].fmt_string, width_bytes[spec[i].size]);
1965 err |= (flag_dump_strings ? dump_strings () : dump ());
1969 if (have_read_stdin && fclose (stdin) == EOF)
1970 error (EXIT_FAILURE, errno, _("standard input"));
1972 exit (err == 0 ? EXIT_SUCCESS : EXIT_FAILURE);