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
70 # define fseeko(Stream, Offset, Whence) (-1)
81 /* FIXME: add INTMAX support, too */
98 /* Each output format specification (from POSIX `-t spec' or from
99 old-style options) is represented by one of these structures. */
102 enum output_format fmt;
104 void (*print_function) ();
106 int hexl_mode_trailer;
110 /* The name this program was run with. */
113 /* Convert the number of 8-bit bytes of a binary representation to
114 the number of characters (digits + sign if the type is signed)
115 required to represent the same quantity in the specified base/type.
116 For example, a 32-bit (4-byte) quantity may require a field width
117 as wide as the following for these types:
121 8 unsigned hexadecimal */
123 static const unsigned int bytes_to_oct_digits[] =
124 {0, 3, 6, 8, 11, 14, 16, 19, 22, 25, 27, 30, 32, 35, 38, 41, 43};
126 static const unsigned int bytes_to_signed_dec_digits[] =
127 {1, 4, 6, 8, 11, 13, 16, 18, 20, 23, 25, 28, 30, 33, 35, 37, 40};
129 static const unsigned int bytes_to_unsigned_dec_digits[] =
130 {0, 3, 5, 8, 10, 13, 15, 17, 20, 22, 25, 27, 29, 32, 34, 37, 39};
132 static const unsigned int bytes_to_hex_digits[] =
133 {0, 2, 4, 6, 8, 10, 12, 14, 16, 18, 20, 22, 24, 26, 28, 30, 32};
135 /* Convert enum size_spec to the size of the named type. */
136 static const int width_bytes[] =
148 /* Names for some non-printing characters. */
149 static const char *const charname[33] =
151 "nul", "soh", "stx", "etx", "eot", "enq", "ack", "bel",
152 "bs", "ht", "nl", "vt", "ff", "cr", "so", "si",
153 "dle", "dc1", "dc2", "dc3", "dc4", "nak", "syn", "etb",
154 "can", "em", "sub", "esc", "fs", "gs", "rs", "us",
158 /* A printf control string for printing a file offset. */
159 static const char *output_address_fmt_string;
161 /* FIXME: make this the number of octal digits in an unsigned long. */
162 #define MAX_ADDRESS_LENGTH 13
164 /* Space for a normal address, a space, a pseudo address, parentheses
165 around the pseudo address, and a trailing zero byte. */
166 static char address_fmt_buffer[2 * MAX_ADDRESS_LENGTH + 4];
167 static char address_pad[MAX_ADDRESS_LENGTH + 1];
169 static unsigned long int string_min;
170 static unsigned long int flag_dump_strings;
172 /* Non-zero if we should recognize the pre-POSIX non-option arguments
173 that specified at most one file and optional arguments specifying
174 offset and pseudo-start address. */
175 static int traditional;
177 /* Non-zero if an old-style `pseudo-address' was specified. */
178 static long int flag_pseudo_start;
180 /* The difference between the old-style pseudo starting address and
181 the number of bytes to skip. */
182 static long int pseudo_offset;
184 /* Function to format an address and optionally an additional parenthesized
185 pseudo-address; it returns the formatted string. */
186 static const char *(*format_address) PARAMS ((long unsigned int));
188 /* The number of input bytes to skip before formatting and writing. */
189 static off_t n_bytes_to_skip = 0;
191 /* When nonzero, MAX_BYTES_TO_FORMAT is the maximum number of bytes
192 to be read and formatted. Otherwise all input is formatted. */
193 static int limit_bytes_to_format = 0;
195 /* The maximum number of bytes that will be formatted. This
196 value is used only when LIMIT_BYTES_TO_FORMAT is nonzero. */
197 static off_t max_bytes_to_format;
199 /* When nonzero and two or more consecutive blocks are equal, format
200 only the first block and output an asterisk alone on the following
201 line to indicate that identical blocks have been elided. */
202 static int abbreviate_duplicate_blocks = 1;
204 /* An array of specs describing how to format each input block. */
205 static struct tspec *spec;
207 /* The number of format specs. */
208 static unsigned int n_specs;
210 /* The allocated length of SPEC. */
211 static unsigned int n_specs_allocated;
213 /* The number of input bytes formatted per output line. It must be
214 a multiple of the least common multiple of the sizes associated with
215 the specified output types. It should be as large as possible, but
216 no larger than 16 -- unless specified with the -w option. */
217 static unsigned int bytes_per_block;
219 /* Human-readable representation of *file_list (for error messages).
220 It differs from *file_list only when *file_list is "-". */
221 static char const *input_filename;
223 /* A NULL-terminated list of the file-arguments from the command line.
224 If no file-arguments were specified, this variable is initialized
226 static char const *const *file_list;
228 /* The input stream associated with the current file. */
229 static FILE *in_stream;
231 /* If nonzero, at least one of the files we read was standard input. */
232 static int have_read_stdin;
234 #ifdef HAVE_UNSIGNED_LONG_LONG
235 # define LONGEST_INTEGRAL_TYPE unsigned long long
237 # define LONGEST_INTEGRAL_TYPE long int
240 #define MAX_INTEGRAL_TYPE_SIZE sizeof(LONGEST_INTEGRAL_TYPE)
241 static enum size_spec integral_type_size[MAX_INTEGRAL_TYPE_SIZE + 1];
243 #define MAX_FP_TYPE_SIZE sizeof(LONG_DOUBLE)
244 static enum size_spec fp_type_size[MAX_FP_TYPE_SIZE + 1];
246 static struct option const long_options[] =
249 {"skip-bytes", required_argument, NULL, 'j'},
250 {"address-radix", required_argument, NULL, 'A'},
251 {"read-bytes", required_argument, NULL, 'N'},
252 {"format", required_argument, NULL, 't'},
253 {"output-duplicates", no_argument, NULL, 'v'},
255 /* non-POSIX options. */
256 {"strings", optional_argument, NULL, 's'},
257 {"traditional", no_argument, NULL, 'B'},
258 {"width", optional_argument, NULL, 'w'},
260 {GETOPT_HELP_OPTION_DECL},
261 {GETOPT_VERSION_OPTION_DECL},
269 fprintf (stderr, _("Try `%s --help' for more information.\n"),
274 Usage: %s [OPTION]... [FILE]...\n\
275 or: %s --traditional [FILE] [[+]OFFSET [[+]LABEL]]\n\
277 program_name, program_name);
279 Write an unambiguous representation, octal bytes by default, of FILE\n\
280 to standard output. With no FILE, or when FILE is -, read standard input.\n\
282 -A, --address-radix=RADIX decide how file offsets are printed\n\
283 -j, --skip-bytes=BYTES skip BYTES input bytes first on each file\n\
284 -N, --read-bytes=BYTES limit dump to BYTES input bytes per file\n\
285 -s, --strings[=BYTES] output strings of at least BYTES graphic chars\n\
286 -t, --format=TYPE select output format or formats\n\
287 -v, --output-duplicates do not use * to mark line suppression\n\
288 -w, --width[=BYTES] output BYTES bytes per output line\n\
289 --traditional accept arguments in pre-POSIX form\n\
290 --help display this help and exit\n\
291 --version output version information and exit\n\
293 Pre-POSIX format specifications may be intermixed, they accumulate:\n\
294 -a same as -t a, select named characters\n\
295 -b same as -t oC, select octal bytes\n\
296 -c same as -t c, select ASCII characters or backslash escapes\n\
297 -d same as -t u2, select unsigned decimal shorts\n\
298 -f same as -t fF, select floats\n\
299 -h same as -t x2, select hexadecimal shorts\n\
300 -i same as -t d2, select decimal shorts\n\
301 -l same as -t d4, select decimal longs\n\
302 -o same as -t o2, select octal shorts\n\
303 -x same as -t x2, select hexadecimal shorts\n\
307 For older syntax (second call format), OFFSET means -j OFFSET. LABEL\n\
308 is the pseudo-address at first byte printed, incremented when dump is\n\
309 progressing. For OFFSET and LABEL, a 0x or 0X prefix indicates\n\
310 hexadecimal, suffixes maybe . for octal and b multiply by 512.\n\
312 TYPE is made up of one or more of these specifications:\n\
315 c ASCII character or backslash escape\n\
316 d[SIZE] signed decimal, SIZE bytes per integer\n\
317 f[SIZE] floating point, SIZE bytes per integer\n\
318 o[SIZE] octal, SIZE bytes per integer\n\
319 u[SIZE] unsigned decimal, SIZE bytes per integer\n\
320 x[SIZE] hexadecimal, SIZE bytes per integer\n\
322 SIZE is a number. For TYPE in doux, SIZE may also be C for\n\
323 sizeof(char), S for sizeof(short), I for sizeof(int) or L for\n\
324 sizeof(long). If TYPE is f, SIZE may also be F for sizeof(float), D\n\
325 for sizeof(double) or L for sizeof(long double).\n\
327 RADIX is d for decimal, o for octal, x for hexadecimal or n for none.\n\
328 BYTES is hexadecimal with 0x or 0X prefix, it is multiplied by 512\n\
329 with b suffix, by 1024 with k and by 1048576 with m. Adding a z suffix to\n\
330 any type adds a display of printable characters to the end of each line\n\
331 of output. -s without a number implies 3. -w without a number implies 32.\n\
332 By default, od uses -A o -t d2 -w 16.\n\
334 puts (_("\nReport bugs to <bug-textutils@gnu.org>."));
336 exit (status == 0 ? EXIT_SUCCESS : EXIT_FAILURE);
339 /* Compute the greatest common denominator of U and V
340 using Euclid's algorithm. */
343 gcd (unsigned int u, unsigned int v)
355 /* Compute the least common multiple of U and V. */
358 lcm (unsigned int u, unsigned int v)
360 unsigned int t = gcd (u, v);
367 print_s_char (long unsigned int n_bytes, const char *block,
368 const char *fmt_string)
371 for (i = n_bytes; i > 0; i--)
373 int tmp = (unsigned) *(const unsigned char *) block;
375 tmp -= SCHAR_MAX - SCHAR_MIN + 1;
376 assert (tmp <= SCHAR_MAX);
377 printf (fmt_string, tmp);
378 block += sizeof (unsigned char);
383 print_char (long unsigned int n_bytes, const char *block,
384 const char *fmt_string)
387 for (i = n_bytes; i > 0; i--)
389 unsigned int tmp = *(const unsigned char *) block;
390 printf (fmt_string, tmp);
391 block += sizeof (unsigned char);
396 print_s_short (long unsigned int n_bytes, const char *block,
397 const char *fmt_string)
400 for (i = n_bytes / sizeof (unsigned short); i > 0; i--)
402 int tmp = (unsigned) *(const unsigned short *) block;
404 tmp -= SHRT_MAX - SHRT_MIN + 1;
405 assert (tmp <= SHRT_MAX);
406 printf (fmt_string, tmp);
407 block += sizeof (unsigned short);
412 print_short (long unsigned int n_bytes, const char *block,
413 const char *fmt_string)
416 for (i = n_bytes / sizeof (unsigned short); i > 0; i--)
418 unsigned int tmp = *(const unsigned short *) block;
419 printf (fmt_string, tmp);
420 block += sizeof (unsigned short);
425 print_int (long unsigned int n_bytes, const char *block,
426 const char *fmt_string)
429 for (i = n_bytes / sizeof (unsigned int); i > 0; i--)
431 unsigned int tmp = *(const unsigned int *) block;
432 printf (fmt_string, tmp);
433 block += sizeof (unsigned int);
438 print_long (long unsigned int n_bytes, const char *block,
439 const char *fmt_string)
442 for (i = n_bytes / sizeof (unsigned long); i > 0; i--)
444 unsigned long tmp = *(const unsigned long *) block;
445 printf (fmt_string, tmp);
446 block += sizeof (unsigned long);
450 #ifdef HAVE_UNSIGNED_LONG_LONG
452 print_long_long (long unsigned int n_bytes, const char *block,
453 const char *fmt_string)
456 for (i = n_bytes / sizeof (unsigned long long); i > 0; i--)
458 unsigned long long tmp = *(const unsigned long long *) block;
459 printf (fmt_string, tmp);
460 block += sizeof (unsigned long long);
466 print_float (long unsigned int n_bytes, const char *block,
467 const char *fmt_string)
470 for (i = n_bytes / sizeof (float); i > 0; i--)
472 float tmp = *(const float *) block;
473 printf (fmt_string, tmp);
474 block += sizeof (float);
479 print_double (long unsigned int n_bytes, const char *block,
480 const char *fmt_string)
483 for (i = n_bytes / sizeof (double); i > 0; i--)
485 double tmp = *(const double *) block;
486 printf (fmt_string, tmp);
487 block += sizeof (double);
491 #ifdef HAVE_LONG_DOUBLE
493 print_long_double (long unsigned int n_bytes, const char *block,
494 const char *fmt_string)
497 for (i = n_bytes / sizeof (LONG_DOUBLE); i > 0; i--)
499 LONG_DOUBLE tmp = *(const LONG_DOUBLE *) block;
500 printf (fmt_string, tmp);
501 block += sizeof (LONG_DOUBLE);
508 dump_hexl_mode_trailer (long unsigned int n_bytes, const char *block)
511 fputs (" >", stdout);
512 for (i = n_bytes; i > 0; i--)
514 unsigned int c = *(const unsigned char *) block;
515 unsigned int c2 = (ISPRINT(c) ? c : '.');
517 block += sizeof (unsigned char);
523 print_named_ascii (long unsigned int n_bytes, const char *block,
524 const char *unused_fmt_string)
527 for (i = n_bytes; i > 0; i--)
529 unsigned int c = *(const unsigned char *) block;
530 unsigned int masked_c = (0x7f & c);
536 else if (masked_c <= 040)
537 s = charname[masked_c];
540 sprintf (buf, " %c", masked_c);
545 block += sizeof (unsigned char);
550 print_ascii (long unsigned int n_bytes, const char *block,
551 const char *unused_fmt_string)
554 for (i = n_bytes; i > 0; i--)
556 unsigned int c = *(const unsigned char *) block;
595 sprintf (buf, (ISPRINT (c) ? " %c" : "%03o"), c);
596 s = (const char *) buf;
600 block += sizeof (unsigned char);
604 /* Convert a null-terminated (possibly zero-length) string S to an
605 unsigned long integer value. If S points to a non-digit set *P to S,
606 *VAL to 0, and return 0. Otherwise, accumulate the integer value of
607 the string of digits. If the string of digits represents a value
608 larger than ULONG_MAX, don't modify *VAL or *P and return nonzero.
609 Otherwise, advance *P to the first non-digit after S, set *VAL to
610 the result of the conversion and return zero. */
613 simple_strtoul (const char *s, const char **p, long unsigned int *val)
615 unsigned long int sum;
620 unsigned int c = *s++ - '0';
621 if (sum > (ULONG_MAX - c) / 10)
630 /* If S points to a single valid POSIX-style od format string, put
631 a description of that format in *TSPEC, make *NEXT point at the
632 character following the just-decoded format (if *NEXT is non-NULL),
633 and return zero. If S is not valid, don't modify *NEXT or *TSPEC,
634 give a diagnostic, and return nonzero. For example, if S were
635 "d4afL" *NEXT would be set to "afL" and *TSPEC would be
637 fmt = SIGNED_DECIMAL;
638 size = INT or LONG; (whichever integral_type_size[4] resolves to)
639 print_function = print_int; (assuming size == INT)
640 fmt_string = "%011d%c";
642 S_ORIG is solely for reporting errors. It should be the full format
647 decode_one_format (const char *s_orig, const char *s, const char **next,
650 enum size_spec size_spec;
651 unsigned long int size;
652 enum output_format fmt;
653 const char *pre_fmt_string;
655 void (*print_function) ();
658 unsigned int field_width = 0;
660 assert (tspec != NULL);
674 size = sizeof (char);
679 size = sizeof (short);
689 size = sizeof (long int);
693 if (simple_strtoul (s, &p, &size) != 0)
695 /* The integer at P in S would overflow an unsigned long.
696 A digit string that long is sufficiently odd looking
697 that the following diagnostic is sufficient. */
698 error (0, 0, _("invalid type string `%s'"), s_orig);
705 if (size > MAX_INTEGRAL_TYPE_SIZE
706 || integral_type_size[size] == NO_SIZE)
708 error (0, 0, _("invalid type string `%s';\n\
709 this system doesn't provide a %lu-byte integral type"), s_orig, size);
717 #define FMT_BYTES_ALLOCATED 9
718 fmt_string = xmalloc (FMT_BYTES_ALLOCATED);
720 size_spec = integral_type_size[size];
725 fmt = SIGNED_DECIMAL;
726 sprintf (fmt_string, " %%%u%sd",
727 (field_width = bytes_to_signed_dec_digits[size]),
728 (size_spec == LONG ? "l"
729 : (size_spec == LONG_LONG ? "ll"
735 sprintf (fmt_string, " %%0%u%so",
736 (field_width = bytes_to_oct_digits[size]),
737 (size_spec == LONG ? "l" : ""));
741 fmt = UNSIGNED_DECIMAL;
742 sprintf (fmt_string, " %%%u%su",
743 (field_width = bytes_to_unsigned_dec_digits[size]),
744 (size_spec == LONG ? "l" : ""));
749 sprintf (fmt_string, " %%0%u%sx",
750 (field_width = bytes_to_hex_digits[size]),
751 (size_spec == LONG ? "l" : ""));
758 assert (strlen (fmt_string) < FMT_BYTES_ALLOCATED);
763 print_function = (fmt == SIGNED_DECIMAL
769 print_function = (fmt == SIGNED_DECIMAL
775 print_function = print_int;
779 print_function = print_long;
783 print_function = print_long_long;
792 fmt = FLOATING_POINT;
798 size = sizeof (float);
803 size = sizeof (double);
808 size = sizeof (LONG_DOUBLE);
812 if (simple_strtoul (s, &p, &size) != 0)
814 /* The integer at P in S would overflow an unsigned long.
815 A digit string that long is sufficiently odd looking
816 that the following diagnostic is sufficient. */
817 error (0, 0, _("invalid type string `%s'"), s_orig);
821 size = sizeof (double);
824 if (size > MAX_FP_TYPE_SIZE
825 || fp_type_size[size] == NO_SIZE)
827 error (0, 0, _("invalid type string `%s';\n\
828 this system doesn't provide a %lu-byte floating point type"), s_orig, size);
835 size_spec = fp_type_size[size];
840 print_function = print_float;
841 /* Don't use %#e; not all systems support it. */
842 pre_fmt_string = " %%%d.%de";
843 fmt_string = xmalloc (strlen (pre_fmt_string));
844 sprintf (fmt_string, pre_fmt_string,
845 (field_width = FLT_DIG + 8), FLT_DIG);
849 print_function = print_double;
850 pre_fmt_string = " %%%d.%de";
851 fmt_string = xmalloc (strlen (pre_fmt_string));
852 sprintf (fmt_string, pre_fmt_string,
853 (field_width = DBL_DIG + 8), DBL_DIG);
856 #ifdef HAVE_LONG_DOUBLE
857 case FLOAT_LONG_DOUBLE:
858 print_function = print_long_double;
859 pre_fmt_string = " %%%d.%dLe";
860 fmt_string = xmalloc (strlen (pre_fmt_string));
861 sprintf (fmt_string, pre_fmt_string,
862 (field_width = LDBL_DIG + 8), LDBL_DIG);
873 fmt = NAMED_CHARACTER;
876 print_function = print_named_ascii;
885 print_function = print_ascii;
890 error (0, 0, _("invalid character `%c' in type string `%s'"),
895 tspec->size = size_spec;
897 tspec->print_function = print_function;
898 tspec->fmt_string = fmt_string;
900 tspec->field_width = field_width;
901 tspec->hexl_mode_trailer = (*s == 'z');
902 if (tspec->hexl_mode_trailer)
911 /* Decode the POSIX-style od format string S. Append the decoded
912 representation to the global array SPEC, reallocating SPEC if
913 necessary. Return zero if S is valid, nonzero otherwise. */
916 decode_format_string (const char *s)
918 const char *s_orig = s;
926 if (decode_one_format (s_orig, s, &next, &tspec))
932 if (n_specs >= n_specs_allocated)
934 n_specs_allocated = 1 + (3 * n_specs_allocated) / 2;
935 spec = (struct tspec *) xrealloc ((char *) spec,
937 * sizeof (struct tspec)));
940 memcpy ((char *) &spec[n_specs], (char *) &tspec,
941 sizeof (struct tspec));
948 /* Given a list of one or more input filenames FILE_LIST, set the global
949 file pointer IN_STREAM to position N_SKIP in the concatenation of
950 those files. If any file operation fails or if there are fewer than
951 N_SKIP bytes in the combined input, give an error message and return
952 nonzero. When possible, use seek- rather than read operations to
953 advance IN_STREAM. A file name of "-" is interpreted as standard
962 for ( /* empty */ ; *file_list != NULL; ++file_list)
964 struct stat file_stats;
967 if (STREQ (*file_list, "-"))
969 input_filename = _("standard input");
975 input_filename = *file_list;
976 in_stream = fopen (input_filename, "r");
977 if (in_stream == NULL)
979 error (0, errno, "%s", input_filename);
984 SET_BINARY (fileno (in_stream));
989 /* First try using fseek. For large offsets, this extra work is
990 worthwhile. If the offset is below some threshold it may be
991 more efficient to move the pointer by reading. There are two
992 issues when trying to use fseek:
993 - the file must be seekable.
994 - before seeking to the specified position, make sure
995 that the new position is in the current file.
996 Try to do that by getting file's size using fstat().
997 But that will work only for regular files and dirs. */
999 if (fstat (fileno (in_stream), &file_stats))
1001 error (0, errno, "%s", input_filename);
1006 /* The st_size field is valid only for regular files and
1007 directories. FIXME: is the preceding true?
1008 If the number of bytes left to skip is at least as large as
1009 the size of the current file, we can decrement
1010 n_skip and go on to the next file. */
1011 if (S_ISREG (file_stats.st_mode) || S_ISDIR (file_stats.st_mode))
1013 if (n_skip >= file_stats.st_size)
1015 n_skip -= file_stats.st_size;
1016 if (in_stream != stdin && fclose (in_stream) == EOF)
1018 error (0, errno, "%s", input_filename);
1025 /* Try fseeko if available, fseek otherwise. */
1026 if (fseeko (in_stream, n_skip, SEEK_SET) == 0
1027 || (n_skip <= LONG_MAX
1028 && fseek (in_stream, (long) n_skip, SEEK_SET) == 0))
1036 /* Seek didn't work or wasn't attempted; position the file pointer
1039 for (j = n_skip / BUFSIZ; j >= 0; j--)
1042 size_t n_bytes_to_read = (j > 0
1045 size_t n_bytes_read;
1046 n_bytes_read = fread (buf, 1, n_bytes_to_read, in_stream);
1047 n_skip -= n_bytes_read;
1048 if (n_bytes_read != n_bytes_to_read)
1057 error (EXIT_FAILURE, 0, _("cannot skip past end of combined input"));
1063 format_address_none (long unsigned int address)
1069 format_address_std (long unsigned int address)
1071 const char *address_string;
1073 sprintf (address_fmt_buffer, output_address_fmt_string, address);
1074 address_string = address_fmt_buffer;
1075 return address_string;
1079 format_address_label (long unsigned int address)
1081 const char *address_string;
1082 assert (output_address_fmt_string != NULL);
1084 sprintf (address_fmt_buffer, output_address_fmt_string,
1085 address, address + pseudo_offset);
1086 address_string = address_fmt_buffer;
1087 return address_string;
1090 /* Write N_BYTES bytes from CURR_BLOCK to standard output once for each
1091 of the N_SPEC format specs. CURRENT_OFFSET is the byte address of
1092 CURR_BLOCK in the concatenation of input files, and it is printed
1093 (optionally) only before the output line associated with the first
1094 format spec. When duplicate blocks are being abbreviated, the output
1095 for a sequence of identical input blocks is the output for the first
1096 block followed by an asterisk alone on a line. It is valid to compare
1097 the blocks PREV_BLOCK and CURR_BLOCK only when N_BYTES == BYTES_PER_BLOCK.
1098 That condition may be false only for the last input block -- and then
1099 only when it has not been padded to length BYTES_PER_BLOCK. */
1102 write_block (long unsigned int current_offset, long unsigned int n_bytes,
1103 const char *prev_block, const char *curr_block)
1105 static int first = 1;
1106 static int prev_pair_equal = 0;
1108 #define EQUAL_BLOCKS(b1, b2) (memcmp ((b1), (b2), bytes_per_block) == 0)
1110 if (abbreviate_duplicate_blocks
1111 && !first && n_bytes == bytes_per_block
1112 && EQUAL_BLOCKS (prev_block, curr_block))
1114 if (prev_pair_equal)
1116 /* The two preceding blocks were equal, and the current
1117 block is the same as the last one, so print nothing. */
1122 prev_pair_equal = 1;
1129 prev_pair_equal = 0;
1130 for (i = 0; i < n_specs; i++)
1132 const char *addr_or_pad = (i == 0
1133 ? format_address (current_offset)
1136 fputs (addr_or_pad, stdout);
1137 (*spec[i].print_function) (n_bytes, curr_block, spec[i].fmt_string);
1138 if (spec[i].hexl_mode_trailer)
1140 /* space-pad out to full line width, then dump the trailer */
1141 int datum_width = width_bytes[spec[i].size];
1142 int blank_fields = (bytes_per_block - n_bytes) / datum_width;
1143 int field_width = spec[i].field_width + 1;
1144 printf ("%*s", blank_fields * field_width, "");
1145 dump_hexl_mode_trailer (n_bytes, curr_block);
1153 /* Test whether there have been errors on in_stream, and close it if
1154 it is not standard input. Return nonzero if there has been an error
1155 on in_stream or stdout; return zero otherwise. This function will
1156 report more than one error only if both a read and a write error
1160 check_and_close (void)
1165 if (ferror (in_stream))
1167 error (0, errno, "%s", input_filename);
1168 if (in_stream != stdin)
1172 else if (in_stream != stdin && fclose (in_stream) == EOF)
1174 error (0, errno, "%s", input_filename);
1178 if (ferror (stdout))
1180 error (0, errno, _("standard output"));
1187 /* Read a single byte into *C from the concatenation of the input files
1188 named in the global array FILE_LIST. On the first call to this
1189 function, the global variable IN_STREAM is expected to be an open
1190 stream associated with the input file *FILE_LIST. If IN_STREAM is
1191 at end-of-file, close it and update the global variables IN_STREAM,
1192 FILE_LIST, and INPUT_FILENAME so they correspond to the next file in
1193 the list. Then try to read a byte from the newly opened file.
1194 Repeat if necessary until *FILE_LIST is NULL. When EOF is reached
1195 for the last file in FILE_LIST, set *C to EOF and return. Subsequent
1196 calls do likewise. The return value is nonzero if any errors
1197 occured, zero otherwise. */
1204 if (*file_list == NULL)
1213 *c = fgetc (in_stream);
1218 err |= check_and_close ();
1223 if (*file_list == NULL)
1226 if (STREQ (*file_list, "-"))
1228 input_filename = _("standard input");
1230 have_read_stdin = 1;
1234 input_filename = *file_list;
1235 in_stream = fopen (input_filename, "r");
1236 if (in_stream == NULL)
1238 error (0, errno, "%s", input_filename);
1242 SET_BINARY (fileno (in_stream));
1244 while (in_stream == NULL);
1248 /* Read N bytes into BLOCK from the concatenation of the input files
1249 named in the global array FILE_LIST. On the first call to this
1250 function, the global variable IN_STREAM is expected to be an open
1251 stream associated with the input file *FILE_LIST. On subsequent
1252 calls, if *FILE_LIST is NULL, don't modify BLOCK and return zero.
1253 If all N bytes cannot be read from IN_STREAM, close IN_STREAM and
1254 update the global variables IN_STREAM, FILE_LIST, and INPUT_FILENAME.
1255 Then try to read the remaining bytes from the newly opened file.
1256 Repeat if necessary until *FILE_LIST is NULL. Set *N_BYTES_IN_BUFFER
1257 to the number of bytes read. If an error occurs, it will be detected
1258 through ferror when the stream is about to be closed. If there is an
1259 error, give a message but continue reading as usual and return nonzero.
1260 Otherwise return zero. */
1263 read_block (size_t n, char *block, size_t *n_bytes_in_buffer)
1267 assert (n > 0 && n <= bytes_per_block);
1269 *n_bytes_in_buffer = 0;
1274 if (*file_list == NULL)
1275 return 0; /* EOF. */
1283 n_needed = n - *n_bytes_in_buffer;
1284 n_read = fread (block + *n_bytes_in_buffer, 1, n_needed, in_stream);
1286 *n_bytes_in_buffer += n_read;
1288 if (n_read == n_needed)
1291 err |= check_and_close ();
1296 if (*file_list == NULL)
1299 if (STREQ (*file_list, "-"))
1301 input_filename = _("standard input");
1303 have_read_stdin = 1;
1307 input_filename = *file_list;
1308 in_stream = fopen (input_filename, "r");
1309 if (in_stream == NULL)
1311 error (0, errno, "%s", input_filename);
1315 SET_BINARY (fileno (in_stream));
1317 while (in_stream == NULL);
1321 /* Return the least common multiple of the sizes associated
1322 with the format specs. */
1330 for (i = 0; i < n_specs; i++)
1331 l_c_m = lcm (l_c_m, width_bytes[(int) spec[i].size]);
1335 /* If S is a valid pre-POSIX offset specification with an optional leading '+'
1336 return the offset it denotes. Otherwise, return -1. */
1339 parse_old_offset (const char *s)
1343 enum strtol_error s_err;
1344 long unsigned int tmp;
1349 /* Skip over any leading '+'. */
1353 /* Determine the radix we'll use to interpret S. If there is a `.',
1354 it's decimal, otherwise, if the string begins with `0X'or `0x',
1355 it's hexadecimal, else octal. */
1356 if (strchr (s, '.') != NULL)
1360 if (s[0] == '0' && (s[1] == 'x' || s[1] == 'X'))
1366 s_err = xstrtoul (s, NULL, radix, &tmp, "Bb");
1367 if (s_err != LONGINT_OK)
1369 STRTOL_FAIL_WARN (s, _("old-style offset"), s_err);
1376 /* Read a chunk of size BYTES_PER_BLOCK from the input files, write the
1377 formatted block to standard output, and repeat until the specified
1378 maximum number of bytes has been read or until all input has been
1379 processed. If the last block read is smaller than BYTES_PER_BLOCK
1380 and its size is not a multiple of the size associated with a format
1381 spec, extend the input block with zero bytes until its length is a
1382 multiple of all format spec sizes. Write the final block. Finally,
1383 write on a line by itself the offset of the byte after the last byte
1384 read. Accumulate return values from calls to read_block and
1385 check_and_close, and if any was nonzero, return nonzero.
1386 Otherwise, return zero. */
1392 off_t current_offset;
1393 off_t end_offset IF_LINT (= 0);
1396 size_t n_bytes_read;
1398 block[0] = (char *) alloca (bytes_per_block);
1399 block[1] = (char *) alloca (bytes_per_block);
1401 current_offset = n_bytes_to_skip;
1405 if (limit_bytes_to_format)
1407 end_offset = n_bytes_to_skip + max_bytes_to_format;
1412 if (current_offset >= end_offset)
1417 n_needed = MIN (end_offset - current_offset,
1418 (off_t) bytes_per_block);
1419 err |= read_block (n_needed, 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;
1433 err |= read_block (bytes_per_block, block[idx], &n_bytes_read);
1434 if (n_bytes_read < bytes_per_block)
1436 assert (n_bytes_read == bytes_per_block);
1437 write_block (current_offset, n_bytes_read,
1438 block[!idx], block[idx]);
1439 current_offset += n_bytes_read;
1444 if (n_bytes_read > 0)
1447 size_t bytes_to_write;
1451 /* Make bytes_to_write the smallest multiple of l_c_m that
1452 is at least as large as n_bytes_read. */
1453 bytes_to_write = l_c_m * (int) ((n_bytes_read + l_c_m - 1) / l_c_m);
1455 memset (block[idx] + n_bytes_read, 0, bytes_to_write - n_bytes_read);
1456 write_block (current_offset, bytes_to_write,
1457 block[!idx], block[idx]);
1458 current_offset += n_bytes_read;
1461 if (output_address_fmt_string != NULL)
1462 printf ("%s\n", format_address (current_offset));
1464 if (limit_bytes_to_format && current_offset > end_offset)
1465 err |= check_and_close ();
1470 /* STRINGS mode. Find each "string constant" in the input.
1471 A string constant is a run of at least `string_min' ASCII
1472 graphic (or formatting) characters terminated by a null.
1473 Based on a function written by Richard Stallman for a
1474 pre-POSIX version of od. Return nonzero if an error
1475 occurs. Otherwise, return zero. */
1480 size_t bufsize = MAX (100, string_min);
1481 char *buf = xmalloc (bufsize);
1482 off_t address = n_bytes_to_skip;
1491 /* See if the next `string_min' chars are all printing chars. */
1494 if (limit_bytes_to_format
1495 && address >= (n_bytes_to_skip + max_bytes_to_format -
1496 (off_t) string_min))
1499 for (i = 0; i < string_min; i++)
1501 err |= read_char (&c);
1509 /* Found a non-printing. Try again starting with next char. */
1514 /* We found a run of `string_min' printable characters.
1515 Now see if it is terminated with a null byte. */
1516 while (!limit_bytes_to_format
1517 || address < n_bytes_to_skip + max_bytes_to_format)
1521 bufsize = 1 + 3 * bufsize / 2;
1522 buf = xrealloc (buf, bufsize);
1524 err |= read_char (&c);
1532 break; /* It is; print this string. */
1534 goto tryline; /* It isn't; give up on this string. */
1535 buf[i++] = c; /* String continues; store it all. */
1538 /* If we get here, the string is all printable and null-terminated,
1539 so print it. It is all in `buf' and `i' is its length. */
1541 if (output_address_fmt_string != NULL)
1543 printf ("%s ", format_address (address - i - 1));
1545 for (i = 0; (c = buf[i]); i++)
1550 fputs ("\\a", stdout);
1554 fputs ("\\b", stdout);
1558 fputs ("\\f", stdout);
1562 fputs ("\\n", stdout);
1566 fputs ("\\r", stdout);
1570 fputs ("\\t", stdout);
1574 fputs ("\\v", stdout);
1584 /* We reach this point only if we search through
1585 (max_bytes_to_format - string_min) bytes before reachine EOF. */
1589 err |= check_and_close ();
1594 main (int argc, char **argv)
1600 unsigned int address_pad_len;
1601 unsigned long int desired_width;
1602 int width_specified = 0;
1603 int n_failed_decodes = 0;
1606 /* The old-style `pseudo starting address' to be printed in parentheses
1607 after any true address. */
1608 long int pseudo_start IF_LINT (= 0);
1610 program_name = argv[0];
1611 setlocale (LC_ALL, "");
1612 bindtextdomain (PACKAGE, LOCALEDIR);
1613 textdomain (PACKAGE);
1615 atexit (close_stdout);
1619 for (i = 0; i <= MAX_INTEGRAL_TYPE_SIZE; i++)
1620 integral_type_size[i] = NO_SIZE;
1622 integral_type_size[sizeof (char)] = CHAR;
1623 integral_type_size[sizeof (short int)] = SHORT;
1624 integral_type_size[sizeof (int)] = INT;
1625 integral_type_size[sizeof (long int)] = LONG;
1626 #ifdef HAVE_UNSIGNED_LONG_LONG
1627 integral_type_size[sizeof (long long)] = LONG_LONG;
1630 for (i = 0; i <= MAX_FP_TYPE_SIZE; i++)
1631 fp_type_size[i] = NO_SIZE;
1633 fp_type_size[sizeof (float)] = FLOAT_SINGLE;
1634 /* The array entry for `double' is filled in after that for LONG_DOUBLE
1635 so that if `long double' is the same type or if long double isn't
1636 supported FLOAT_LONG_DOUBLE will never be used. */
1637 fp_type_size[sizeof (LONG_DOUBLE)] = FLOAT_LONG_DOUBLE;
1638 fp_type_size[sizeof (double)] = FLOAT_DOUBLE;
1641 n_specs_allocated = 5;
1642 spec = (struct tspec *) xmalloc (n_specs_allocated * sizeof (struct tspec));
1644 output_address_fmt_string = "%07o";
1645 format_address = format_address_std;
1646 address_pad_len = 7;
1647 flag_dump_strings = 0;
1649 while ((c = getopt_long (argc, argv, "abcdfhilos::xw::A:j:N:t:v",
1650 long_options, NULL)) != -1)
1652 unsigned long int tmp;
1653 enum strtol_error s_err;
1664 output_address_fmt_string = "%07d";
1665 format_address = format_address_std;
1666 address_pad_len = 7;
1669 output_address_fmt_string = "%07o";
1670 format_address = format_address_std;
1671 address_pad_len = 7;
1674 output_address_fmt_string = "%06x";
1675 format_address = format_address_std;
1676 address_pad_len = 6;
1679 output_address_fmt_string = NULL;
1680 format_address = format_address_none;
1681 address_pad_len = 0;
1684 error (EXIT_FAILURE, 0,
1685 _("invalid output address radix `%c'; \
1686 it must be one character from [doxn]"),
1693 s_err = xstrtoul (optarg, NULL, 0, &tmp, "bkm");
1694 n_bytes_to_skip = tmp;
1695 if (s_err != LONGINT_OK)
1696 STRTOL_FATAL_ERROR (optarg, _("skip argument"), s_err);
1700 limit_bytes_to_format = 1;
1702 /* FIXME: if off_t is long long and that's an 8-byte type,
1703 use xstrtouq here. */
1704 s_err = xstrtoul (optarg, NULL, 0, &tmp, "bkm");
1705 max_bytes_to_format = tmp;
1706 if (s_err != LONGINT_OK)
1707 STRTOL_FATAL_ERROR (optarg, _("limit argument"), s_err);
1710 error (EXIT_FAILURE, 0,
1711 _("specified number of bytes `%s' is larger than \
1712 the maximum\nrepresentable value of type `long'"), optarg);
1720 s_err = xstrtoul (optarg, NULL, 0, &string_min, "bkm");
1721 if (s_err != LONGINT_OK)
1722 STRTOL_FATAL_ERROR (optarg, _("minimum string length"), s_err);
1724 ++flag_dump_strings;
1728 if (decode_format_string (optarg))
1733 abbreviate_duplicate_blocks = 0;
1740 /* The next several cases map the old, pre-POSIX format
1741 specification options to the corresponding POSIX format
1742 specs. GNU od accepts any combination of old- and
1743 new-style options. Format specification options accumulate. */
1745 #define CASE_OLD_ARG(old_char,new_string) \
1748 if (decode_format_string (new_string)) \
1749 ++n_failed_decodes; \
1753 CASE_OLD_ARG ('a', "a");
1754 CASE_OLD_ARG ('b', "oC");
1755 CASE_OLD_ARG ('c', "c");
1756 CASE_OLD_ARG ('d', "u2");
1757 CASE_OLD_ARG ('f', "fF");
1758 CASE_OLD_ARG ('h', "x2");
1759 CASE_OLD_ARG ('i', "d2");
1760 CASE_OLD_ARG ('l', "d4");
1761 CASE_OLD_ARG ('o', "o2");
1762 CASE_OLD_ARG ('x', "x2");
1767 width_specified = 1;
1774 s_err = xstrtoul (optarg, NULL, 10, &desired_width, "");
1775 if (s_err != LONGINT_OK)
1776 STRTOL_FATAL_ERROR (optarg, _("width specification"), s_err);
1780 case_GETOPT_HELP_CHAR;
1782 case_GETOPT_VERSION_CHAR (PROGRAM_NAME, AUTHORS);
1790 if (n_failed_decodes > 0)
1791 exit (EXIT_FAILURE);
1793 if (flag_dump_strings && n_specs > 0)
1794 error (EXIT_FAILURE, 0,
1795 _("no type may be specified when dumping strings"));
1797 n_files = argc - optind;
1799 /* If the --backward-compatible option is used, there may be from
1800 0 to 3 remaining command line arguments; handle each case
1802 od [file] [[+]offset[.][b] [[+]label[.][b]]]
1803 The offset and pseudo_start have the same syntax. */
1811 if ((offset = parse_old_offset (argv[optind])) >= 0)
1813 n_bytes_to_skip = offset;
1818 else if (n_files == 2)
1821 if ((o1 = parse_old_offset (argv[optind])) >= 0
1822 && (o2 = parse_old_offset (argv[optind + 1])) >= 0)
1824 n_bytes_to_skip = o1;
1825 flag_pseudo_start = 1;
1830 else if ((o2 = parse_old_offset (argv[optind + 1])) >= 0)
1832 n_bytes_to_skip = o2;
1834 argv[optind + 1] = argv[optind];
1840 _("invalid second operand in compatibility mode `%s'"),
1845 else if (n_files == 3)
1848 if ((o1 = parse_old_offset (argv[optind + 1])) >= 0
1849 && (o2 = parse_old_offset (argv[optind + 2])) >= 0)
1851 n_bytes_to_skip = o1;
1852 flag_pseudo_start = 1;
1854 argv[optind + 2] = argv[optind];
1861 _("in compatibility mode, the last two arguments must be offsets"));
1865 else if (n_files > 3)
1868 _("compatibility mode supports at most three arguments"));
1872 if (flag_pseudo_start)
1874 static char buf[10];
1876 if (output_address_fmt_string == NULL)
1878 output_address_fmt_string = "(%07o)";
1879 format_address = format_address_std;
1883 sprintf (buf, "%s (%s)",
1884 output_address_fmt_string,
1885 output_address_fmt_string);
1886 output_address_fmt_string = buf;
1887 format_address = format_address_label;
1892 assert (address_pad_len <= MAX_ADDRESS_LENGTH);
1893 for (i = 0; i < address_pad_len; i++)
1894 address_pad[i] = ' ';
1895 address_pad[address_pad_len] = '\0';
1899 if (decode_one_format ("o2", "o2", NULL, &(spec[0])))
1901 /* This happens on Cray systems that don't have a 2-byte
1903 exit (EXIT_FAILURE);
1910 file_list = (char const *const *) &argv[optind];
1913 /* If no files were listed on the command line, set up the
1914 global array FILE_LIST so that it contains the null-terminated
1915 list of one name: "-". */
1916 static char const *const default_file_list[] = {"-", NULL};
1918 file_list = default_file_list;
1921 err |= skip (n_bytes_to_skip);
1922 if (in_stream == NULL)
1925 pseudo_offset = (flag_pseudo_start ? pseudo_start - n_bytes_to_skip : 0);
1927 /* Compute output block length. */
1930 if (width_specified)
1932 if (desired_width != 0 && desired_width % l_c_m == 0)
1933 bytes_per_block = desired_width;
1936 error (0, 0, _("warning: invalid width %lu; using %d instead"),
1937 desired_width, l_c_m);
1938 bytes_per_block = l_c_m;
1943 if (l_c_m < DEFAULT_BYTES_PER_BLOCK)
1944 bytes_per_block = l_c_m * (int) (DEFAULT_BYTES_PER_BLOCK / l_c_m);
1946 bytes_per_block = l_c_m;
1950 for (i = 0; i < n_specs; i++)
1952 printf (_("%d: fmt=\"%s\" width=%d\n"),
1953 i, spec[i].fmt_string, width_bytes[spec[i].size]);
1957 err |= (flag_dump_strings ? dump_strings () : dump ());
1961 if (have_read_stdin && fclose (stdin) == EOF)
1962 error (EXIT_FAILURE, errno, _("standard input"));
1964 exit (err == 0 ? EXIT_SUCCESS : EXIT_FAILURE);