1 /* od -- dump files in octal and other formats
2 Copyright (C) 92, 95, 96, 1997 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>
30 #if defined(__GNUC__) || defined(STDC_HEADERS)
34 #ifdef HAVE_LONG_DOUBLE
35 typedef long double LONG_DOUBLE;
37 typedef double LONG_DOUBLE;
44 # define SCHAR_MAX 127
47 # define SCHAR_MIN (-128)
50 # define SHRT_MAX 32767
53 # define SHRT_MIN (-32768)
56 # define ULONG_MAX ((unsigned long) ~(unsigned long) 0)
59 # define LONG_MAX ((long int) (ULONG_MAX >> 1))
67 # define BITSPERBYTE 8
71 # define MAX(a, b) ((a) > (b) ? (a) : (b))
75 # define MIN(a,b) (((a) < (b)) ? (a) : (b))
78 #if defined (_WIN32) && defined (_O_BINARY)
79 # define WINDOWS_SETFILEMODE_BINARY(IN_STREAM, FILENAME) \
81 { /* Turn off DOS text file modes, "rb" doesn't work on stdin. */\
82 if (_setmode (_fileno ((IN_STREAM)), _O_BINARY) == -1) \
84 error (0, errno, "%s", (FILENAME)); \
91 # define WINDOWS_SETFILEMODE_BINARY(IN_STREAM, FILENAME) /* empty */
94 /* The default number of input bytes per output line. */
95 #define DEFAULT_BYTES_PER_BLOCK 16
97 /* The number of decimal digits of precision in a float. */
102 /* The number of decimal digits of precision in a double. */
107 /* The number of decimal digits of precision in a long double. */
109 # define LDBL_DIG DBL_DIG
114 # define fseeko(Stream, Offset, Whence) (-1)
140 /* Each output format specification (from POSIX `-t spec' or from
141 old-style options) is represented by one of these structures. */
144 enum output_format fmt;
146 void (*print_function) ();
148 int hexl_mode_trailer;
152 /* The name this program was run with. */
155 /* Convert the number of 8-bit bytes of a binary representation to
156 the number of characters (digits + sign if the type is signed)
157 required to represent the same quantity in the specified base/type.
158 For example, a 32-bit (4-byte) quantity may require a field width
159 as wide as the following for these types:
163 8 unsigned hexadecimal */
165 static const unsigned int bytes_to_oct_digits[] =
166 {0, 3, 6, 8, 11, 14, 16, 19, 22, 25, 27, 30, 32, 35, 38, 41, 43};
168 static const unsigned int bytes_to_signed_dec_digits[] =
169 {1, 4, 6, 8, 11, 13, 16, 18, 20, 23, 25, 28, 30, 33, 35, 37, 40};
171 static const unsigned int bytes_to_unsigned_dec_digits[] =
172 {0, 3, 5, 8, 10, 13, 15, 17, 20, 22, 25, 27, 29, 32, 34, 37, 39};
174 static const unsigned int bytes_to_hex_digits[] =
175 {0, 2, 4, 6, 8, 10, 12, 14, 16, 18, 20, 22, 24, 26, 28, 30, 32};
177 /* Convert enum size_spec to the size of the named type. */
178 static const int width_bytes[] =
190 /* Names for some non-printing characters. */
191 static const char *const charname[33] =
193 "nul", "soh", "stx", "etx", "eot", "enq", "ack", "bel",
194 "bs", "ht", "nl", "vt", "ff", "cr", "so", "si",
195 "dle", "dc1", "dc2", "dc3", "dc4", "nak", "syn", "etb",
196 "can", "em", "sub", "esc", "fs", "gs", "rs", "us",
200 /* A printf control string for printing a file offset. */
201 static const char *output_address_fmt_string;
203 /* FIXME: make this the number of octal digits in an unsigned long. */
204 #define MAX_ADDRESS_LENGTH 13
206 /* Space for a normal address, a space, a pseudo address, parentheses
207 around the pseudo address, and a trailing zero byte. */
208 static char address_fmt_buffer[2 * MAX_ADDRESS_LENGTH + 4];
209 static char address_pad[MAX_ADDRESS_LENGTH + 1];
211 static unsigned long int string_min;
212 static unsigned long int flag_dump_strings;
214 /* Non-zero if we should recognize the pre-POSIX non-option arguments
215 that specified at most one file and optional arguments specifying
216 offset and pseudo-start address. */
217 static int traditional;
219 /* Non-zero if an old-style `pseudo-address' was specified. */
220 static long int flag_pseudo_start;
222 /* The difference between the old-style pseudo starting address and
223 the number of bytes to skip. */
224 static long int pseudo_offset;
226 /* Function to format an address and optionally an additional parenthesized
227 pseudo-address; it returns the formatted string. */
228 static const char *(*format_address) PARAMS ((long unsigned int));
230 /* The number of input bytes to skip before formatting and writing. */
231 static off_t n_bytes_to_skip = 0;
233 /* When nonzero, MAX_BYTES_TO_FORMAT is the maximum number of bytes
234 to be read and formatted. Otherwise all input is formatted. */
235 static int limit_bytes_to_format = 0;
237 /* The maximum number of bytes that will be formatted. This
238 value is used only when LIMIT_BYTES_TO_FORMAT is nonzero. */
239 static off_t max_bytes_to_format;
241 /* When nonzero and two or more consecutive blocks are equal, format
242 only the first block and output an asterisk alone on the following
243 line to indicate that identical blocks have been elided. */
244 static int abbreviate_duplicate_blocks = 1;
246 /* An array of specs describing how to format each input block. */
247 static struct tspec *spec;
249 /* The number of format specs. */
250 static unsigned int n_specs;
252 /* The allocated length of SPEC. */
253 static unsigned int n_specs_allocated;
255 /* The number of input bytes formatted per output line. It must be
256 a multiple of the least common multiple of the sizes associated with
257 the specified output types. It should be as large as possible, but
258 no larger than 16 -- unless specified with the -w option. */
259 static unsigned int bytes_per_block;
261 /* Human-readable representation of *file_list (for error messages).
262 It differs from *file_list only when *file_list is "-". */
263 static char const *input_filename;
265 /* A NULL-terminated list of the file-arguments from the command line.
266 If no file-arguments were specified, this variable is initialized
268 static char const *const *file_list;
270 /* The input stream associated with the current file. */
271 static FILE *in_stream;
273 /* If nonzero, at least one of the files we read was standard input. */
274 static int have_read_stdin;
276 #define LONGEST_INTEGRAL_TYPE long int
278 #define MAX_INTEGRAL_TYPE_SIZE sizeof(LONGEST_INTEGRAL_TYPE)
279 static enum size_spec integral_type_size[MAX_INTEGRAL_TYPE_SIZE + 1];
281 #define MAX_FP_TYPE_SIZE sizeof(LONG_DOUBLE)
282 static enum size_spec fp_type_size[MAX_FP_TYPE_SIZE + 1];
284 /* If nonzero, display usage information and exit. */
285 static int show_help;
287 /* If nonzero, print the version on standard output then exit. */
288 static int show_version;
290 static struct option const long_options[] =
293 {"skip-bytes", required_argument, NULL, 'j'},
294 {"address-radix", required_argument, NULL, 'A'},
295 {"read-bytes", required_argument, NULL, 'N'},
296 {"format", required_argument, NULL, 't'},
297 {"output-duplicates", no_argument, NULL, 'v'},
299 /* non-POSIX options. */
300 {"strings", optional_argument, NULL, 's'},
301 {"traditional", no_argument, NULL, 'B'},
302 {"width", optional_argument, NULL, 'w'},
303 {"help", no_argument, &show_help, 1},
304 {"version", no_argument, &show_version, 1},
312 fprintf (stderr, _("Try `%s --help' for more information.\n"),
317 Usage: %s [OPTION]... [FILE]...\n\
318 or: %s --traditional [FILE] [[+]OFFSET [[+]LABEL]]\n\
320 program_name, program_name);
322 Write an unambiguous representation, octal bytes by default, of FILE\n\
323 to standard output. With no FILE, or when FILE is -, read standard input.\n\
325 -A, --address-radix=RADIX decide how file offsets are printed\n\
326 -j, --skip-bytes=BYTES skip BYTES input bytes first on each file\n\
327 -N, --read-bytes=BYTES limit dump to BYTES input bytes per file\n\
328 -s, --strings[=BYTES] output strings of at least BYTES graphic chars\n\
329 -t, --format=TYPE select output format or formats\n\
330 -v, --output-duplicates do not use * to mark line suppression\n\
331 -w, --width[=BYTES] output BYTES bytes per output line\n\
332 --traditional accept arguments in pre-POSIX form\n\
333 --help display this help and exit\n\
334 --version output version information and exit\n\
336 Pre-POSIX format specifications may be intermixed, they accumulate:\n\
337 -a same as -t a, select named characters\n\
338 -b same as -t oC, select octal bytes\n\
339 -c same as -t c, select ASCII characters or backslash escapes\n\
340 -d same as -t u2, select unsigned decimal shorts\n\
341 -f same as -t fF, select floats\n\
342 -h same as -t x2, select hexadecimal shorts\n\
343 -i same as -t d2, select decimal shorts\n\
344 -l same as -t d4, select decimal longs\n\
345 -o same as -t o2, select octal shorts\n\
346 -x same as -t x2, select hexadecimal shorts\n\
350 For older syntax (second call format), OFFSET means -j OFFSET. LABEL\n\
351 is the pseudo-address at first byte printed, incremented when dump is\n\
352 progressing. For OFFSET and LABEL, a 0x or 0X prefix indicates\n\
353 hexadecimal, suffixes maybe . for octal and b multiply by 512.\n\
355 TYPE is made up of one or more of these specifications:\n\
358 c ASCII character or backslash escape\n\
359 d[SIZE] signed decimal, SIZE bytes per integer\n\
360 f[SIZE] floating point, SIZE bytes per integer\n\
361 o[SIZE] octal, SIZE bytes per integer\n\
362 u[SIZE] unsigned decimal, SIZE bytes per integer\n\
363 x[SIZE] hexadecimal, SIZE bytes per integer\n\
365 SIZE is a number. For TYPE in doux, SIZE may also be C for\n\
366 sizeof(char), S for sizeof(short), I for sizeof(int) or L for\n\
367 sizeof(long). If TYPE is f, SIZE may also be F for sizeof(float), D\n\
368 for sizeof(double) or L for sizeof(long double).\n\
370 RADIX is d for decimal, o for octal, x for hexadecimal or n for none.\n\
371 BYTES is hexadecimal with 0x or 0X prefix, it is multiplied by 512\n\
372 with b suffix, by 1024 with k and by 1048576 with m. Adding a z suffix to\n\
373 any type adds a display of printable characters to the end of each line\n\
374 of output. -s without a number implies 3. -w without a number implies 32.\n\
375 By default, od uses -A o -t d2 -w 16.\n\
377 puts (_("\nReport bugs to <textutils-bugs@gnu.org>."));
379 exit (status == 0 ? EXIT_SUCCESS : EXIT_FAILURE);
382 /* Compute the greatest common denominator of U and V
383 using Euclid's algorithm. */
386 gcd (unsigned int u, unsigned int v)
398 /* Compute the least common multiple of U and V. */
401 lcm (unsigned int u, unsigned int v)
403 unsigned int t = gcd (u, v);
410 print_s_char (long unsigned int n_bytes, const char *block,
411 const char *fmt_string)
414 for (i = n_bytes; i > 0; i--)
416 int tmp = (unsigned) *(const unsigned char *) block;
418 tmp -= SCHAR_MAX - SCHAR_MIN + 1;
419 assert (tmp <= SCHAR_MAX);
420 printf (fmt_string, tmp);
421 block += sizeof (unsigned char);
426 print_char (long unsigned int n_bytes, const char *block,
427 const char *fmt_string)
430 for (i = n_bytes; i > 0; i--)
432 unsigned int tmp = *(const unsigned char *) block;
433 printf (fmt_string, tmp);
434 block += sizeof (unsigned char);
439 print_s_short (long unsigned int n_bytes, const char *block,
440 const char *fmt_string)
443 for (i = n_bytes / sizeof (unsigned short); i > 0; i--)
445 int tmp = (unsigned) *(const unsigned short *) block;
447 tmp -= SHRT_MAX - SHRT_MIN + 1;
448 assert (tmp <= SHRT_MAX);
449 printf (fmt_string, tmp);
450 block += sizeof (unsigned short);
455 print_short (long unsigned int n_bytes, const char *block,
456 const char *fmt_string)
459 for (i = n_bytes / sizeof (unsigned short); i > 0; i--)
461 unsigned int tmp = *(const unsigned short *) block;
462 printf (fmt_string, tmp);
463 block += sizeof (unsigned short);
468 print_int (long unsigned int n_bytes, const char *block,
469 const char *fmt_string)
472 for (i = n_bytes / sizeof (unsigned int); i > 0; i--)
474 unsigned int tmp = *(const unsigned int *) block;
475 printf (fmt_string, tmp);
476 block += sizeof (unsigned int);
481 print_long (long unsigned int n_bytes, const char *block,
482 const char *fmt_string)
485 for (i = n_bytes / sizeof (unsigned long); i > 0; i--)
487 unsigned long tmp = *(const unsigned long *) block;
488 printf (fmt_string, tmp);
489 block += sizeof (unsigned long);
494 print_float (long unsigned int n_bytes, const char *block,
495 const char *fmt_string)
498 for (i = n_bytes / sizeof (float); i > 0; i--)
500 float tmp = *(const float *) block;
501 printf (fmt_string, tmp);
502 block += sizeof (float);
507 print_double (long unsigned int n_bytes, const char *block,
508 const char *fmt_string)
511 for (i = n_bytes / sizeof (double); i > 0; i--)
513 double tmp = *(const double *) block;
514 printf (fmt_string, tmp);
515 block += sizeof (double);
519 #ifdef HAVE_LONG_DOUBLE
521 print_long_double (long unsigned int n_bytes, const char *block,
522 const char *fmt_string)
525 for (i = n_bytes / sizeof (LONG_DOUBLE); i > 0; i--)
527 LONG_DOUBLE tmp = *(const LONG_DOUBLE *) block;
528 printf (fmt_string, tmp);
529 block += sizeof (LONG_DOUBLE);
536 dump_hexl_mode_trailer (long unsigned int n_bytes, const char *block)
539 fputs (" >", stdout);
540 for (i = n_bytes; i > 0; i--)
542 unsigned int c = *(const unsigned char *) block;
543 unsigned int c2 = (ISPRINT(c) ? c : '.');
545 block += sizeof (unsigned char);
551 print_named_ascii (long unsigned int n_bytes, const char *block,
552 const char *unused_fmt_string)
555 for (i = n_bytes; i > 0; i--)
557 unsigned int c = *(const unsigned char *) block;
558 unsigned int masked_c = (0x7f & c);
564 else if (masked_c <= 040)
565 s = charname[masked_c];
568 sprintf (buf, " %c", masked_c);
573 block += sizeof (unsigned char);
578 print_ascii (long unsigned int n_bytes, const char *block,
579 const char *unused_fmt_string)
582 for (i = n_bytes; i > 0; i--)
584 unsigned int c = *(const unsigned char *) block;
623 sprintf (buf, (ISPRINT (c) ? " %c" : "%03o"), c);
624 s = (const char *) buf;
628 block += sizeof (unsigned char);
632 /* Convert a null-terminated (possibly zero-length) string S to an
633 unsigned long integer value. If S points to a non-digit set *P to S,
634 *VAL to 0, and return 0. Otherwise, accumulate the integer value of
635 the string of digits. If the string of digits represents a value
636 larger than ULONG_MAX, don't modify *VAL or *P and return nonzero.
637 Otherwise, advance *P to the first non-digit after S, set *VAL to
638 the result of the conversion and return zero. */
641 simple_strtoul (const char *s, const char **p, long unsigned int *val)
643 unsigned long int sum;
648 unsigned int c = *s++ - '0';
649 if (sum > (ULONG_MAX - c) / 10)
658 /* If S points to a single valid POSIX-style od format string, put
659 a description of that format in *TSPEC, make *NEXT point at the
660 character following the just-decoded format (if *NEXT is non-NULL),
661 and return zero. If S is not valid, don't modify *NEXT or *TSPEC,
662 give a diagnostic, and return nonzero. For example, if S were
663 "d4afL" *NEXT would be set to "afL" and *TSPEC would be
665 fmt = SIGNED_DECIMAL;
666 size = INT or LONG; (whichever integral_type_size[4] resolves to)
667 print_function = print_int; (assuming size == INT)
668 fmt_string = "%011d%c";
670 S_ORIG is solely for reporting errors. It should be the full format
675 decode_one_format (const char *s_orig, const char *s, const char **next,
678 enum size_spec size_spec;
679 unsigned long int size;
680 enum output_format fmt;
681 const char *pre_fmt_string;
683 void (*print_function) ();
686 unsigned int field_width = 0;
688 assert (tspec != NULL);
702 size = sizeof (char);
707 size = sizeof (short);
717 size = sizeof (long int);
721 if (simple_strtoul (s, &p, &size) != 0)
723 /* The integer at P in S would overflow an unsigned long.
724 A digit string that long is sufficiently odd looking
725 that the following diagnostic is sufficient. */
726 error (0, 0, _("invalid type string `%s'"), s_orig);
733 if (size > MAX_INTEGRAL_TYPE_SIZE
734 || integral_type_size[size] == NO_SIZE)
736 error (0, 0, _("invalid type string `%s';\n\
737 this system doesn't provide a %lu-byte integral type"), s_orig, size);
745 #define FMT_BYTES_ALLOCATED 9
746 fmt_string = xmalloc (FMT_BYTES_ALLOCATED);
748 size_spec = integral_type_size[size];
753 fmt = SIGNED_DECIMAL;
754 sprintf (fmt_string, " %%%u%sd",
755 (field_width = bytes_to_signed_dec_digits[size]),
756 (size_spec == LONG ? "l" : ""));
761 sprintf (fmt_string, " %%0%u%so",
762 (field_width = bytes_to_oct_digits[size]),
763 (size_spec == LONG ? "l" : ""));
767 fmt = UNSIGNED_DECIMAL;
768 sprintf (fmt_string, " %%%u%su",
769 (field_width = bytes_to_unsigned_dec_digits[size]),
770 (size_spec == LONG ? "l" : ""));
775 sprintf (fmt_string, " %%0%u%sx",
776 (field_width = bytes_to_hex_digits[size]),
777 (size_spec == LONG ? "l" : ""));
784 assert (strlen (fmt_string) < FMT_BYTES_ALLOCATED);
789 print_function = (fmt == SIGNED_DECIMAL
795 print_function = (fmt == SIGNED_DECIMAL
801 print_function = print_int;
805 print_function = print_long;
814 fmt = FLOATING_POINT;
820 size = sizeof (float);
825 size = sizeof (double);
830 size = sizeof (LONG_DOUBLE);
834 if (simple_strtoul (s, &p, &size) != 0)
836 /* The integer at P in S would overflow an unsigned long.
837 A digit string that long is sufficiently odd looking
838 that the following diagnostic is sufficient. */
839 error (0, 0, _("invalid type string `%s'"), s_orig);
843 size = sizeof (double);
846 if (size > MAX_FP_TYPE_SIZE
847 || fp_type_size[size] == NO_SIZE)
849 error (0, 0, _("invalid type string `%s';\n\
850 this system doesn't provide a %lu-byte floating point type"), s_orig, size);
857 size_spec = fp_type_size[size];
862 print_function = print_float;
863 /* Don't use %#e; not all systems support it. */
864 pre_fmt_string = " %%%d.%de";
865 fmt_string = xmalloc (strlen (pre_fmt_string));
866 sprintf (fmt_string, pre_fmt_string,
867 (field_width = FLT_DIG + 8), FLT_DIG);
871 print_function = print_double;
872 pre_fmt_string = " %%%d.%de";
873 fmt_string = xmalloc (strlen (pre_fmt_string));
874 sprintf (fmt_string, pre_fmt_string,
875 (field_width = DBL_DIG + 8), DBL_DIG);
878 #ifdef HAVE_LONG_DOUBLE
879 case FLOAT_LONG_DOUBLE:
880 print_function = print_long_double;
881 pre_fmt_string = " %%%d.%dLe";
882 fmt_string = xmalloc (strlen (pre_fmt_string));
883 sprintf (fmt_string, pre_fmt_string,
884 (field_width = LDBL_DIG + 8), LDBL_DIG);
895 fmt = NAMED_CHARACTER;
898 print_function = print_named_ascii;
907 print_function = print_ascii;
912 error (0, 0, _("invalid character `%c' in type string `%s'"),
917 tspec->size = size_spec;
919 tspec->print_function = print_function;
920 tspec->fmt_string = fmt_string;
922 tspec->field_width = field_width;
923 tspec->hexl_mode_trailer = (*s == 'z');
924 if (tspec->hexl_mode_trailer)
933 /* Decode the POSIX-style od format string S. Append the decoded
934 representation to the global array SPEC, reallocating SPEC if
935 necessary. Return zero if S is valid, nonzero otherwise. */
938 decode_format_string (const char *s)
940 const char *s_orig = s;
948 if (decode_one_format (s_orig, s, &next, &tspec))
954 if (n_specs >= n_specs_allocated)
956 n_specs_allocated = 1 + (3 * n_specs_allocated) / 2;
957 spec = (struct tspec *) xrealloc ((char *) spec,
959 * sizeof (struct tspec)));
962 memcpy ((char *) &spec[n_specs], (char *) &tspec,
963 sizeof (struct tspec));
970 /* Given a list of one or more input filenames FILE_LIST, set the global
971 file pointer IN_STREAM to position N_SKIP in the concatenation of
972 those files. If any file operation fails or if there are fewer than
973 N_SKIP bytes in the combined input, give an error message and return
974 nonzero. When possible, use seek- rather than read operations to
975 advance IN_STREAM. A file name of "-" is interpreted as standard
984 for ( /* empty */ ; *file_list != NULL; ++file_list)
986 struct stat file_stats;
989 if (STREQ (*file_list, "-"))
991 input_filename = _("standard input");
997 input_filename = *file_list;
998 in_stream = fopen (input_filename, "r");
999 if (in_stream == NULL)
1001 error (0, errno, "%s", input_filename);
1006 WINDOWS_SETFILEMODE_BINARY (in_stream, input_filename);
1011 /* First try using fseek. For large offsets, this extra work is
1012 worthwhile. If the offset is below some threshold it may be
1013 more efficient to move the pointer by reading. There are two
1014 issues when trying to use fseek:
1015 - the file must be seekable.
1016 - before seeking to the specified position, make sure
1017 that the new position is in the current file.
1018 Try to do that by getting file's size using fstat().
1019 But that will work only for regular files and dirs. */
1021 if (fstat (fileno (in_stream), &file_stats))
1023 error (0, errno, "%s", input_filename);
1028 /* The st_size field is valid only for regular files and
1029 directories. FIXME: is the preceding true?
1030 If the number of bytes left to skip is at least as large as
1031 the size of the current file, we can decrement
1032 n_skip and go on to the next file. */
1033 if (S_ISREG (file_stats.st_mode) || S_ISDIR (file_stats.st_mode))
1035 if (n_skip >= file_stats.st_size)
1037 n_skip -= file_stats.st_size;
1038 if (in_stream != stdin && fclose (in_stream) == EOF)
1040 error (0, errno, "%s", input_filename);
1047 /* Try fseeko if available, fseek otherwise. */
1048 if (fseeko (in_stream, n_skip, SEEK_SET) == 0
1049 || (n_skip <= LONG_MAX
1050 && fseek (in_stream, (long) n_skip, SEEK_SET) == 0))
1058 /* Seek didn't work or wasn't attempted; position the file pointer
1061 for (j = n_skip / BUFSIZ; j >= 0; j--)
1064 size_t n_bytes_to_read = (j > 0
1067 size_t n_bytes_read;
1068 n_bytes_read = fread (buf, 1, n_bytes_to_read, in_stream);
1069 n_skip -= n_bytes_read;
1070 if (n_bytes_read != n_bytes_to_read)
1079 error (EXIT_FAILURE, 0, _("cannot skip past end of combined input"));
1085 format_address_none (long unsigned int address)
1091 format_address_std (long unsigned int address)
1093 const char *address_string;
1095 sprintf (address_fmt_buffer, output_address_fmt_string, address);
1096 address_string = address_fmt_buffer;
1097 return address_string;
1101 format_address_label (long unsigned int address)
1103 const char *address_string;
1104 assert (output_address_fmt_string != NULL);
1106 sprintf (address_fmt_buffer, output_address_fmt_string,
1107 address, address + pseudo_offset);
1108 address_string = address_fmt_buffer;
1109 return address_string;
1112 /* Write N_BYTES bytes from CURR_BLOCK to standard output once for each
1113 of the N_SPEC format specs. CURRENT_OFFSET is the byte address of
1114 CURR_BLOCK in the concatenation of input files, and it is printed
1115 (optionally) only before the output line associated with the first
1116 format spec. When duplicate blocks are being abbreviated, the output
1117 for a sequence of identical input blocks is the output for the first
1118 block followed by an asterisk alone on a line. It is valid to compare
1119 the blocks PREV_BLOCK and CURR_BLOCK only when N_BYTES == BYTES_PER_BLOCK.
1120 That condition may be false only for the last input block -- and then
1121 only when it has not been padded to length BYTES_PER_BLOCK. */
1124 write_block (long unsigned int current_offset, long unsigned int n_bytes,
1125 const char *prev_block, const char *curr_block)
1127 static int first = 1;
1128 static int prev_pair_equal = 0;
1130 #define EQUAL_BLOCKS(b1, b2) (memcmp ((b1), (b2), bytes_per_block) == 0)
1132 if (abbreviate_duplicate_blocks
1133 && !first && n_bytes == bytes_per_block
1134 && EQUAL_BLOCKS (prev_block, curr_block))
1136 if (prev_pair_equal)
1138 /* The two preceding blocks were equal, and the current
1139 block is the same as the last one, so print nothing. */
1144 prev_pair_equal = 1;
1151 prev_pair_equal = 0;
1152 for (i = 0; i < n_specs; i++)
1154 const char *addr_or_pad = (i == 0
1155 ? format_address (current_offset)
1158 fputs (addr_or_pad, stdout);
1159 (*spec[i].print_function) (n_bytes, curr_block, spec[i].fmt_string);
1160 if (spec[i].hexl_mode_trailer)
1162 /* space-pad out to full line width, then dump the trailer */
1163 int datum_width = width_bytes[spec[i].size];
1164 int blank_fields = (bytes_per_block - n_bytes) / datum_width;
1165 int field_width = spec[i].field_width + 1;
1166 printf ("%*s", blank_fields * field_width, "");
1167 dump_hexl_mode_trailer (n_bytes, curr_block);
1175 /* Test whether there have been errors on in_stream, and close it if
1176 it is not standard input. Return nonzero if there has been an error
1177 on in_stream or stdout; return zero otherwise. This function will
1178 report more than one error only if both a read and a write error
1182 check_and_close (void)
1187 if (ferror (in_stream))
1189 error (0, errno, "%s", input_filename);
1190 if (in_stream != stdin)
1194 else if (in_stream != stdin && fclose (in_stream) == EOF)
1196 error (0, errno, "%s", input_filename);
1200 if (ferror (stdout))
1202 error (0, errno, _("standard output"));
1209 /* Read a single byte into *C from the concatenation of the input files
1210 named in the global array FILE_LIST. On the first call to this
1211 function, the global variable IN_STREAM is expected to be an open
1212 stream associated with the input file *FILE_LIST. If IN_STREAM is
1213 at end-of-file, close it and update the global variables IN_STREAM,
1214 FILE_LIST, and INPUT_FILENAME so they correspond to the next file in
1215 the list. Then try to read a byte from the newly opened file.
1216 Repeat if necessary until *FILE_LIST is NULL. When EOF is reached
1217 for the last file in FILE_LIST, set *C to EOF and return. Subsequent
1218 calls do likewise. The return value is nonzero if any errors
1219 occured, zero otherwise. */
1226 if (*file_list == NULL)
1235 *c = fgetc (in_stream);
1240 err |= check_and_close ();
1245 if (*file_list == NULL)
1248 if (STREQ (*file_list, "-"))
1250 input_filename = _("standard input");
1252 have_read_stdin = 1;
1256 input_filename = *file_list;
1257 in_stream = fopen (input_filename, "r");
1258 if (in_stream == NULL)
1260 error (0, errno, "%s", input_filename);
1264 WINDOWS_SETFILEMODE_BINARY (in_stream, input_filename);
1266 while (in_stream == NULL);
1270 /* Read N bytes into BLOCK from the concatenation of the input files
1271 named in the global array FILE_LIST. On the first call to this
1272 function, the global variable IN_STREAM is expected to be an open
1273 stream associated with the input file *FILE_LIST. On subsequent
1274 calls, if *FILE_LIST is NULL, don't modify BLOCK and return zero.
1275 If all N bytes cannot be read from IN_STREAM, close IN_STREAM and
1276 update the global variables IN_STREAM, FILE_LIST, and INPUT_FILENAME.
1277 Then try to read the remaining bytes from the newly opened file.
1278 Repeat if necessary until *FILE_LIST is NULL. Set *N_BYTES_IN_BUFFER
1279 to the number of bytes read. If an error occurs, it will be detected
1280 through ferror when the stream is about to be closed. If there is an
1281 error, give a message but continue reading as usual and return nonzero.
1282 Otherwise return zero. */
1285 read_block (size_t n, char *block, size_t *n_bytes_in_buffer)
1289 assert (n > 0 && n <= bytes_per_block);
1291 *n_bytes_in_buffer = 0;
1296 if (*file_list == NULL)
1297 return 0; /* EOF. */
1305 n_needed = n - *n_bytes_in_buffer;
1306 n_read = fread (block + *n_bytes_in_buffer, 1, n_needed, in_stream);
1308 *n_bytes_in_buffer += n_read;
1310 if (n_read == n_needed)
1313 err |= check_and_close ();
1318 if (*file_list == NULL)
1321 if (STREQ (*file_list, "-"))
1323 input_filename = _("standard input");
1325 have_read_stdin = 1;
1329 input_filename = *file_list;
1330 in_stream = fopen (input_filename, "r");
1331 if (in_stream == NULL)
1333 error (0, errno, "%s", input_filename);
1337 WINDOWS_SETFILEMODE_BINARY (in_stream, input_filename);
1339 while (in_stream == NULL);
1343 /* Return the least common multiple of the sizes associated
1344 with the format specs. */
1352 for (i = 0; i < n_specs; i++)
1353 l_c_m = lcm (l_c_m, width_bytes[(int) spec[i].size]);
1357 /* If S is a valid pre-POSIX offset specification with an optional leading '+'
1358 return the offset it denotes. Otherwise, return -1. */
1361 parse_old_offset (const char *s)
1365 enum strtol_error s_err;
1366 long unsigned int tmp;
1371 /* Skip over any leading '+'. */
1375 /* Determine the radix we'll use to interpret S. If there is a `.',
1376 it's decimal, otherwise, if the string begins with `0X'or `0x',
1377 it's hexadecimal, else octal. */
1378 if (strchr (s, '.') != NULL)
1382 if (s[0] == '0' && (s[1] == 'x' || s[1] == 'X'))
1388 s_err = xstrtoul (s, NULL, radix, &tmp, "Bb");
1389 if (s_err != LONGINT_OK)
1391 STRTOL_FAIL_WARN (s, _("old-style offset"), s_err);
1398 /* Read a chunk of size BYTES_PER_BLOCK from the input files, write the
1399 formatted block to standard output, and repeat until the specified
1400 maximum number of bytes has been read or until all input has been
1401 processed. If the last block read is smaller than BYTES_PER_BLOCK
1402 and its size is not a multiple of the size associated with a format
1403 spec, extend the input block with zero bytes until its length is a
1404 multiple of all format spec sizes. Write the final block. Finally,
1405 write on a line by itself the offset of the byte after the last byte
1406 read. Accumulate return values from calls to read_block and
1407 check_and_close, and if any was nonzero, return nonzero.
1408 Otherwise, return zero. */
1414 off_t current_offset;
1418 size_t n_bytes_read;
1420 #ifdef lint /* Suppress `used before initialized' warning. */
1424 block[0] = (char *) alloca (bytes_per_block);
1425 block[1] = (char *) alloca (bytes_per_block);
1427 current_offset = n_bytes_to_skip;
1431 if (limit_bytes_to_format)
1433 end_offset = n_bytes_to_skip + max_bytes_to_format;
1438 if (current_offset >= end_offset)
1443 n_needed = MIN (end_offset - current_offset,
1444 (off_t) bytes_per_block);
1445 err |= read_block (n_needed, block[idx], &n_bytes_read);
1446 if (n_bytes_read < bytes_per_block)
1448 assert (n_bytes_read == bytes_per_block);
1449 write_block (current_offset, n_bytes_read,
1450 block[!idx], block[idx]);
1451 current_offset += n_bytes_read;
1459 err |= read_block (bytes_per_block, block[idx], &n_bytes_read);
1460 if (n_bytes_read < bytes_per_block)
1462 assert (n_bytes_read == bytes_per_block);
1463 write_block (current_offset, n_bytes_read,
1464 block[!idx], block[idx]);
1465 current_offset += n_bytes_read;
1470 if (n_bytes_read > 0)
1473 size_t bytes_to_write;
1477 /* Make bytes_to_write the smallest multiple of l_c_m that
1478 is at least as large as n_bytes_read. */
1479 bytes_to_write = l_c_m * (int) ((n_bytes_read + l_c_m - 1) / l_c_m);
1481 memset (block[idx] + n_bytes_read, 0, bytes_to_write - n_bytes_read);
1482 write_block (current_offset, bytes_to_write,
1483 block[!idx], block[idx]);
1484 current_offset += n_bytes_read;
1487 if (output_address_fmt_string != NULL)
1488 printf ("%s\n", format_address (current_offset));
1490 if (limit_bytes_to_format && current_offset > end_offset)
1491 err |= check_and_close ();
1496 /* STRINGS mode. Find each "string constant" in the input.
1497 A string constant is a run of at least `string_min' ASCII
1498 graphic (or formatting) characters terminated by a null.
1499 Based on a function written by Richard Stallman for a
1500 pre-POSIX version of od. Return nonzero if an error
1501 occurs. Otherwise, return zero. */
1506 size_t bufsize = MAX (100, string_min);
1507 char *buf = xmalloc (bufsize);
1508 off_t address = n_bytes_to_skip;
1517 /* See if the next `string_min' chars are all printing chars. */
1520 if (limit_bytes_to_format
1521 && address >= (n_bytes_to_skip + max_bytes_to_format -
1522 (off_t) string_min))
1525 for (i = 0; i < string_min; i++)
1527 err |= read_char (&c);
1535 /* Found a non-printing. Try again starting with next char. */
1540 /* We found a run of `string_min' printable characters.
1541 Now see if it is terminated with a null byte. */
1542 while (!limit_bytes_to_format
1543 || address < n_bytes_to_skip + max_bytes_to_format)
1547 bufsize = 1 + 3 * bufsize / 2;
1548 buf = xrealloc (buf, bufsize);
1550 err |= read_char (&c);
1558 break; /* It is; print this string. */
1560 goto tryline; /* It isn't; give up on this string. */
1561 buf[i++] = c; /* String continues; store it all. */
1564 /* If we get here, the string is all printable and null-terminated,
1565 so print it. It is all in `buf' and `i' is its length. */
1567 if (output_address_fmt_string != NULL)
1569 printf ("%s ", format_address (address - i - 1));
1571 for (i = 0; (c = buf[i]); i++)
1576 fputs ("\\a", stdout);
1580 fputs ("\\b", stdout);
1584 fputs ("\\f", stdout);
1588 fputs ("\\n", stdout);
1592 fputs ("\\r", stdout);
1596 fputs ("\\t", stdout);
1600 fputs ("\\v", stdout);
1610 /* We reach this point only if we search through
1611 (max_bytes_to_format - string_min) bytes before reachine EOF. */
1615 err |= check_and_close ();
1620 main (int argc, char **argv)
1626 unsigned int address_pad_len;
1627 unsigned long int desired_width;
1628 int width_specified = 0;
1629 int n_failed_decodes = 0;
1632 /* The old-style `pseudo starting address' to be printed in parentheses
1633 after any true address. */
1634 long int pseudo_start;
1636 #ifdef lint /* Suppress `used before initialized' warning. */
1640 program_name = argv[0];
1641 setlocale (LC_ALL, "");
1642 bindtextdomain (PACKAGE, LOCALEDIR);
1643 textdomain (PACKAGE);
1647 for (i = 0; i <= MAX_INTEGRAL_TYPE_SIZE; i++)
1648 integral_type_size[i] = NO_SIZE;
1650 integral_type_size[sizeof (char)] = CHAR;
1651 integral_type_size[sizeof (short int)] = SHORT;
1652 integral_type_size[sizeof (int)] = INT;
1653 integral_type_size[sizeof (long int)] = LONG;
1655 for (i = 0; i <= MAX_FP_TYPE_SIZE; i++)
1656 fp_type_size[i] = NO_SIZE;
1658 fp_type_size[sizeof (float)] = FLOAT_SINGLE;
1659 /* The array entry for `double' is filled in after that for LONG_DOUBLE
1660 so that if `long double' is the same type or if long double isn't
1661 supported FLOAT_LONG_DOUBLE will never be used. */
1662 fp_type_size[sizeof (LONG_DOUBLE)] = FLOAT_LONG_DOUBLE;
1663 fp_type_size[sizeof (double)] = FLOAT_DOUBLE;
1666 n_specs_allocated = 5;
1667 spec = (struct tspec *) xmalloc (n_specs_allocated * sizeof (struct tspec));
1669 output_address_fmt_string = "%07o";
1670 format_address = format_address_std;
1671 address_pad_len = 7;
1672 flag_dump_strings = 0;
1674 while ((c = getopt_long (argc, argv, "abcdfhilos::xw::A:j:N:t:v",
1675 long_options, NULL)) != -1)
1677 unsigned long int tmp;
1678 enum strtol_error s_err;
1689 output_address_fmt_string = "%07d";
1690 format_address = format_address_std;
1691 address_pad_len = 7;
1694 output_address_fmt_string = "%07o";
1695 format_address = format_address_std;
1696 address_pad_len = 7;
1699 output_address_fmt_string = "%06x";
1700 format_address = format_address_std;
1701 address_pad_len = 6;
1704 output_address_fmt_string = NULL;
1705 format_address = format_address_none;
1706 address_pad_len = 0;
1709 error (EXIT_FAILURE, 0,
1710 _("invalid output address radix `%c'; \
1711 it must be one character from [doxn]"),
1718 s_err = xstrtoul (optarg, NULL, 0, &tmp, "bkm");
1719 n_bytes_to_skip = tmp;
1720 if (s_err != LONGINT_OK)
1721 STRTOL_FATAL_ERROR (optarg, _("skip argument"), s_err);
1725 limit_bytes_to_format = 1;
1727 /* FIXME: if off_t is long long and that's an 8-byte type,
1728 use xstrtouq here. */
1729 s_err = xstrtoul (optarg, NULL, 0, &tmp, "bkm");
1730 max_bytes_to_format = tmp;
1731 if (s_err != LONGINT_OK)
1732 STRTOL_FATAL_ERROR (optarg, _("limit argument"), s_err);
1735 error (EXIT_FAILURE, 0,
1736 _("specified number of bytes `%s' is larger than \
1737 the maximum\nrepresentable value of type `long'"), optarg);
1745 s_err = xstrtoul (optarg, NULL, 0, &string_min, "bkm");
1746 if (s_err != LONGINT_OK)
1747 STRTOL_FATAL_ERROR (optarg, _("minimum string length"), s_err);
1749 ++flag_dump_strings;
1753 if (decode_format_string (optarg))
1758 abbreviate_duplicate_blocks = 0;
1765 /* The next several cases map the old, pre-POSIX format
1766 specification options to the corresponding POSIX format
1767 specs. GNU od accepts any combination of old- and
1768 new-style options. Format specification options accumulate. */
1770 #define CASE_OLD_ARG(old_char,new_string) \
1773 if (decode_format_string (new_string)) \
1774 ++n_failed_decodes; \
1778 CASE_OLD_ARG ('a', "a");
1779 CASE_OLD_ARG ('b', "oC");
1780 CASE_OLD_ARG ('c', "c");
1781 CASE_OLD_ARG ('d', "u2");
1782 CASE_OLD_ARG ('f', "fF");
1783 CASE_OLD_ARG ('h', "x2");
1784 CASE_OLD_ARG ('i', "d2");
1785 CASE_OLD_ARG ('l', "d4");
1786 CASE_OLD_ARG ('o', "o2");
1787 CASE_OLD_ARG ('x', "x2");
1792 width_specified = 1;
1799 s_err = xstrtoul (optarg, NULL, 10, &desired_width, "");
1800 if (s_err != LONGINT_OK)
1801 STRTOL_FATAL_ERROR (optarg, _("width specification"), s_err);
1811 if (n_failed_decodes > 0)
1812 exit (EXIT_FAILURE);
1816 printf ("od (%s) %s\n", GNU_PACKAGE, VERSION);
1817 exit (EXIT_SUCCESS);
1823 if (flag_dump_strings && n_specs > 0)
1824 error (EXIT_FAILURE, 0,
1825 _("no type may be specified when dumping strings"));
1827 n_files = argc - optind;
1829 /* If the --backward-compatible option is used, there may be from
1830 0 to 3 remaining command line arguments; handle each case
1832 od [file] [[+]offset[.][b] [[+]label[.][b]]]
1833 The offset and pseudo_start have the same syntax. */
1841 if ((offset = parse_old_offset (argv[optind])) >= 0)
1843 n_bytes_to_skip = offset;
1848 else if (n_files == 2)
1851 if ((o1 = parse_old_offset (argv[optind])) >= 0
1852 && (o2 = parse_old_offset (argv[optind + 1])) >= 0)
1854 n_bytes_to_skip = o1;
1855 flag_pseudo_start = 1;
1860 else if ((o2 = parse_old_offset (argv[optind + 1])) >= 0)
1862 n_bytes_to_skip = o2;
1864 argv[optind + 1] = argv[optind];
1870 _("invalid second operand in compatibility mode `%s'"),
1875 else if (n_files == 3)
1878 if ((o1 = parse_old_offset (argv[optind + 1])) >= 0
1879 && (o2 = parse_old_offset (argv[optind + 2])) >= 0)
1881 n_bytes_to_skip = o1;
1882 flag_pseudo_start = 1;
1884 argv[optind + 2] = argv[optind];
1891 _("in compatibility mode, the last two arguments must be offsets"));
1895 else if (n_files > 3)
1898 _("compatibility mode supports at most three arguments"));
1902 if (flag_pseudo_start)
1904 static char buf[10];
1906 if (output_address_fmt_string == NULL)
1908 output_address_fmt_string = "(%07o)";
1909 format_address = format_address_std;
1913 sprintf (buf, "%s (%s)",
1914 output_address_fmt_string,
1915 output_address_fmt_string);
1916 output_address_fmt_string = buf;
1917 format_address = format_address_label;
1922 assert (address_pad_len <= MAX_ADDRESS_LENGTH);
1923 for (i = 0; i < address_pad_len; i++)
1924 address_pad[i] = ' ';
1925 address_pad[address_pad_len] = '\0';
1929 if (decode_one_format ("o2", "o2", NULL, &(spec[0])))
1931 /* This happens on Cray systems that don't have a 2-byte
1933 exit (EXIT_FAILURE);
1940 file_list = (char const *const *) &argv[optind];
1943 /* If no files were listed on the command line, set up the
1944 global array FILE_LIST so that it contains the null-terminated
1945 list of one name: "-". */
1946 static char const *const default_file_list[] = {"-", NULL};
1948 file_list = default_file_list;
1951 err |= skip (n_bytes_to_skip);
1952 if (in_stream == NULL)
1955 pseudo_offset = (flag_pseudo_start ? pseudo_start - n_bytes_to_skip : 0);
1957 /* Compute output block length. */
1960 if (width_specified)
1962 if (desired_width != 0 && desired_width % l_c_m == 0)
1963 bytes_per_block = desired_width;
1966 error (0, 0, _("warning: invalid width %lu; using %d instead"),
1967 desired_width, l_c_m);
1968 bytes_per_block = l_c_m;
1973 if (l_c_m < DEFAULT_BYTES_PER_BLOCK)
1974 bytes_per_block = l_c_m * (int) (DEFAULT_BYTES_PER_BLOCK / l_c_m);
1976 bytes_per_block = l_c_m;
1980 for (i = 0; i < n_specs; i++)
1982 printf (_("%d: fmt=\"%s\" width=%d\n"),
1983 i, spec[i].fmt_string, width_bytes[spec[i].size]);
1987 err |= (flag_dump_strings ? dump_strings () : dump ());
1991 if (have_read_stdin && fclose (stdin) == EOF)
1992 error (EXIT_FAILURE, errno, _("standard input"));
1994 if (fclose (stdout) == EOF)
1995 error (EXIT_FAILURE, errno, _("write error"));
1997 exit (err == 0 ? EXIT_SUCCESS : EXIT_FAILURE);