1 /* od -- dump files in octal and other formats
2 Copyright (C) 92, 1995-1999 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>
28 #include "long-options.h"
31 #if defined(__GNUC__) || defined(STDC_HEADERS)
35 #ifdef HAVE_LONG_DOUBLE
36 typedef long double LONG_DOUBLE;
38 typedef double LONG_DOUBLE;
46 # define MAX(a, b) ((a) > (b) ? (a) : (b))
50 # define MIN(a,b) (((a) < (b)) ? (a) : (b))
53 /* The default number of input bytes per output line. */
54 #define DEFAULT_BYTES_PER_BLOCK 16
56 /* The number of decimal digits of precision in a float. */
61 /* The number of decimal digits of precision in a double. */
66 /* The number of decimal digits of precision in a long double. */
68 # define LDBL_DIG DBL_DIG
73 # define fseeko(Stream, Offset, Whence) (-1)
99 /* Each output format specification (from POSIX `-t spec' or from
100 old-style options) is represented by one of these structures. */
103 enum output_format fmt;
105 void (*print_function) ();
107 int hexl_mode_trailer;
111 /* The name this program was run with. */
114 /* Convert the number of 8-bit bytes of a binary representation to
115 the number of characters (digits + sign if the type is signed)
116 required to represent the same quantity in the specified base/type.
117 For example, a 32-bit (4-byte) quantity may require a field width
118 as wide as the following for these types:
122 8 unsigned hexadecimal */
124 static const unsigned int bytes_to_oct_digits[] =
125 {0, 3, 6, 8, 11, 14, 16, 19, 22, 25, 27, 30, 32, 35, 38, 41, 43};
127 static const unsigned int bytes_to_signed_dec_digits[] =
128 {1, 4, 6, 8, 11, 13, 16, 18, 20, 23, 25, 28, 30, 33, 35, 37, 40};
130 static const unsigned int bytes_to_unsigned_dec_digits[] =
131 {0, 3, 5, 8, 10, 13, 15, 17, 20, 22, 25, 27, 29, 32, 34, 37, 39};
133 static const unsigned int bytes_to_hex_digits[] =
134 {0, 2, 4, 6, 8, 10, 12, 14, 16, 18, 20, 22, 24, 26, 28, 30, 32};
136 /* Convert enum size_spec to the size of the named type. */
137 static const int width_bytes[] =
149 /* Names for some non-printing characters. */
150 static const char *const charname[33] =
152 "nul", "soh", "stx", "etx", "eot", "enq", "ack", "bel",
153 "bs", "ht", "nl", "vt", "ff", "cr", "so", "si",
154 "dle", "dc1", "dc2", "dc3", "dc4", "nak", "syn", "etb",
155 "can", "em", "sub", "esc", "fs", "gs", "rs", "us",
159 /* A printf control string for printing a file offset. */
160 static const char *output_address_fmt_string;
162 /* FIXME: make this the number of octal digits in an unsigned long. */
163 #define MAX_ADDRESS_LENGTH 13
165 /* Space for a normal address, a space, a pseudo address, parentheses
166 around the pseudo address, and a trailing zero byte. */
167 static char address_fmt_buffer[2 * MAX_ADDRESS_LENGTH + 4];
168 static char address_pad[MAX_ADDRESS_LENGTH + 1];
170 static unsigned long int string_min;
171 static unsigned long int flag_dump_strings;
173 /* Non-zero if we should recognize the pre-POSIX non-option arguments
174 that specified at most one file and optional arguments specifying
175 offset and pseudo-start address. */
176 static int traditional;
178 /* Non-zero if an old-style `pseudo-address' was specified. */
179 static long int flag_pseudo_start;
181 /* The difference between the old-style pseudo starting address and
182 the number of bytes to skip. */
183 static long int pseudo_offset;
185 /* Function to format an address and optionally an additional parenthesized
186 pseudo-address; it returns the formatted string. */
187 static const char *(*format_address) PARAMS ((long unsigned int));
189 /* The number of input bytes to skip before formatting and writing. */
190 static off_t n_bytes_to_skip = 0;
192 /* When nonzero, MAX_BYTES_TO_FORMAT is the maximum number of bytes
193 to be read and formatted. Otherwise all input is formatted. */
194 static int limit_bytes_to_format = 0;
196 /* The maximum number of bytes that will be formatted. This
197 value is used only when LIMIT_BYTES_TO_FORMAT is nonzero. */
198 static off_t max_bytes_to_format;
200 /* When nonzero and two or more consecutive blocks are equal, format
201 only the first block and output an asterisk alone on the following
202 line to indicate that identical blocks have been elided. */
203 static int abbreviate_duplicate_blocks = 1;
205 /* An array of specs describing how to format each input block. */
206 static struct tspec *spec;
208 /* The number of format specs. */
209 static unsigned int n_specs;
211 /* The allocated length of SPEC. */
212 static unsigned int n_specs_allocated;
214 /* The number of input bytes formatted per output line. It must be
215 a multiple of the least common multiple of the sizes associated with
216 the specified output types. It should be as large as possible, but
217 no larger than 16 -- unless specified with the -w option. */
218 static unsigned int bytes_per_block;
220 /* Human-readable representation of *file_list (for error messages).
221 It differs from *file_list only when *file_list is "-". */
222 static char const *input_filename;
224 /* A NULL-terminated list of the file-arguments from the command line.
225 If no file-arguments were specified, this variable is initialized
227 static char const *const *file_list;
229 /* The input stream associated with the current file. */
230 static FILE *in_stream;
232 /* If nonzero, at least one of the files we read was standard input. */
233 static int have_read_stdin;
235 #define LONGEST_INTEGRAL_TYPE long int
237 #define MAX_INTEGRAL_TYPE_SIZE sizeof(LONGEST_INTEGRAL_TYPE)
238 static enum size_spec integral_type_size[MAX_INTEGRAL_TYPE_SIZE + 1];
240 #define MAX_FP_TYPE_SIZE sizeof(LONG_DOUBLE)
241 static enum size_spec fp_type_size[MAX_FP_TYPE_SIZE + 1];
243 static struct option const long_options[] =
246 {"skip-bytes", required_argument, NULL, 'j'},
247 {"address-radix", required_argument, NULL, 'A'},
248 {"read-bytes", required_argument, NULL, 'N'},
249 {"format", required_argument, NULL, 't'},
250 {"output-duplicates", no_argument, NULL, 'v'},
252 /* non-POSIX options. */
253 {"strings", optional_argument, NULL, 's'},
254 {"traditional", no_argument, NULL, 'B'},
255 {"width", optional_argument, NULL, 'w'},
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 (long unsigned int n_bytes, const char *block,
362 const char *fmt_string)
365 for (i = n_bytes; i > 0; i--)
367 int tmp = (unsigned) *(const unsigned char *) block;
369 tmp -= SCHAR_MAX - SCHAR_MIN + 1;
370 assert (tmp <= SCHAR_MAX);
371 printf (fmt_string, tmp);
372 block += sizeof (unsigned char);
377 print_char (long unsigned int n_bytes, const char *block,
378 const char *fmt_string)
381 for (i = n_bytes; i > 0; i--)
383 unsigned int tmp = *(const unsigned char *) block;
384 printf (fmt_string, tmp);
385 block += sizeof (unsigned char);
390 print_s_short (long unsigned int n_bytes, const char *block,
391 const char *fmt_string)
394 for (i = n_bytes / sizeof (unsigned short); i > 0; i--)
396 int tmp = (unsigned) *(const unsigned short *) block;
398 tmp -= SHRT_MAX - SHRT_MIN + 1;
399 assert (tmp <= SHRT_MAX);
400 printf (fmt_string, tmp);
401 block += sizeof (unsigned short);
406 print_short (long unsigned int n_bytes, const char *block,
407 const char *fmt_string)
410 for (i = n_bytes / sizeof (unsigned short); i > 0; i--)
412 unsigned int tmp = *(const unsigned short *) block;
413 printf (fmt_string, tmp);
414 block += sizeof (unsigned short);
419 print_int (long unsigned int n_bytes, const char *block,
420 const char *fmt_string)
423 for (i = n_bytes / sizeof (unsigned int); i > 0; i--)
425 unsigned int tmp = *(const unsigned int *) block;
426 printf (fmt_string, tmp);
427 block += sizeof (unsigned int);
432 print_long (long unsigned int n_bytes, const char *block,
433 const char *fmt_string)
436 for (i = n_bytes / sizeof (unsigned long); i > 0; i--)
438 unsigned long tmp = *(const unsigned long *) block;
439 printf (fmt_string, tmp);
440 block += sizeof (unsigned long);
445 print_float (long unsigned int n_bytes, const char *block,
446 const char *fmt_string)
449 for (i = n_bytes / sizeof (float); i > 0; i--)
451 float tmp = *(const float *) block;
452 printf (fmt_string, tmp);
453 block += sizeof (float);
458 print_double (long unsigned int n_bytes, const char *block,
459 const char *fmt_string)
462 for (i = n_bytes / sizeof (double); i > 0; i--)
464 double tmp = *(const double *) block;
465 printf (fmt_string, tmp);
466 block += sizeof (double);
470 #ifdef HAVE_LONG_DOUBLE
472 print_long_double (long unsigned int n_bytes, const char *block,
473 const char *fmt_string)
476 for (i = n_bytes / sizeof (LONG_DOUBLE); i > 0; i--)
478 LONG_DOUBLE tmp = *(const LONG_DOUBLE *) block;
479 printf (fmt_string, tmp);
480 block += sizeof (LONG_DOUBLE);
487 dump_hexl_mode_trailer (long unsigned int n_bytes, const char *block)
490 fputs (" >", stdout);
491 for (i = n_bytes; i > 0; i--)
493 unsigned int c = *(const unsigned char *) block;
494 unsigned int c2 = (ISPRINT(c) ? c : '.');
496 block += sizeof (unsigned char);
502 print_named_ascii (long unsigned int n_bytes, const char *block,
503 const char *unused_fmt_string)
506 for (i = n_bytes; i > 0; i--)
508 unsigned int c = *(const unsigned char *) block;
509 unsigned int masked_c = (0x7f & c);
515 else if (masked_c <= 040)
516 s = charname[masked_c];
519 sprintf (buf, " %c", masked_c);
524 block += sizeof (unsigned char);
529 print_ascii (long unsigned int n_bytes, const char *block,
530 const char *unused_fmt_string)
533 for (i = n_bytes; i > 0; i--)
535 unsigned int c = *(const unsigned char *) block;
574 sprintf (buf, (ISPRINT (c) ? " %c" : "%03o"), c);
575 s = (const char *) buf;
579 block += sizeof (unsigned char);
583 /* Convert a null-terminated (possibly zero-length) string S to an
584 unsigned long integer value. If S points to a non-digit set *P to S,
585 *VAL to 0, and return 0. Otherwise, accumulate the integer value of
586 the string of digits. If the string of digits represents a value
587 larger than ULONG_MAX, don't modify *VAL or *P and return nonzero.
588 Otherwise, advance *P to the first non-digit after S, set *VAL to
589 the result of the conversion and return zero. */
592 simple_strtoul (const char *s, const char **p, long unsigned int *val)
594 unsigned long int sum;
599 unsigned int c = *s++ - '0';
600 if (sum > (ULONG_MAX - c) / 10)
609 /* If S points to a single valid POSIX-style od format string, put
610 a description of that format in *TSPEC, make *NEXT point at the
611 character following the just-decoded format (if *NEXT is non-NULL),
612 and return zero. If S is not valid, don't modify *NEXT or *TSPEC,
613 give a diagnostic, and return nonzero. For example, if S were
614 "d4afL" *NEXT would be set to "afL" and *TSPEC would be
616 fmt = SIGNED_DECIMAL;
617 size = INT or LONG; (whichever integral_type_size[4] resolves to)
618 print_function = print_int; (assuming size == INT)
619 fmt_string = "%011d%c";
621 S_ORIG is solely for reporting errors. It should be the full format
626 decode_one_format (const char *s_orig, const char *s, const char **next,
629 enum size_spec size_spec;
630 unsigned long int size;
631 enum output_format fmt;
632 const char *pre_fmt_string;
634 void (*print_function) ();
637 unsigned int field_width = 0;
639 assert (tspec != NULL);
653 size = sizeof (char);
658 size = sizeof (short);
668 size = sizeof (long int);
672 if (simple_strtoul (s, &p, &size) != 0)
674 /* The integer at P in S would overflow an unsigned long.
675 A digit string that long is sufficiently odd looking
676 that the following diagnostic is sufficient. */
677 error (0, 0, _("invalid type string `%s'"), s_orig);
684 if (size > MAX_INTEGRAL_TYPE_SIZE
685 || integral_type_size[size] == NO_SIZE)
687 error (0, 0, _("invalid type string `%s';\n\
688 this system doesn't provide a %lu-byte integral type"), s_orig, size);
696 #define FMT_BYTES_ALLOCATED 9
697 fmt_string = xmalloc (FMT_BYTES_ALLOCATED);
699 size_spec = integral_type_size[size];
704 fmt = SIGNED_DECIMAL;
705 sprintf (fmt_string, " %%%u%sd",
706 (field_width = bytes_to_signed_dec_digits[size]),
707 (size_spec == LONG ? "l" : ""));
712 sprintf (fmt_string, " %%0%u%so",
713 (field_width = bytes_to_oct_digits[size]),
714 (size_spec == LONG ? "l" : ""));
718 fmt = UNSIGNED_DECIMAL;
719 sprintf (fmt_string, " %%%u%su",
720 (field_width = bytes_to_unsigned_dec_digits[size]),
721 (size_spec == LONG ? "l" : ""));
726 sprintf (fmt_string, " %%0%u%sx",
727 (field_width = bytes_to_hex_digits[size]),
728 (size_spec == LONG ? "l" : ""));
735 assert (strlen (fmt_string) < FMT_BYTES_ALLOCATED);
740 print_function = (fmt == SIGNED_DECIMAL
746 print_function = (fmt == SIGNED_DECIMAL
752 print_function = print_int;
756 print_function = print_long;
765 fmt = FLOATING_POINT;
771 size = sizeof (float);
776 size = sizeof (double);
781 size = sizeof (LONG_DOUBLE);
785 if (simple_strtoul (s, &p, &size) != 0)
787 /* The integer at P in S would overflow an unsigned long.
788 A digit string that long is sufficiently odd looking
789 that the following diagnostic is sufficient. */
790 error (0, 0, _("invalid type string `%s'"), s_orig);
794 size = sizeof (double);
797 if (size > MAX_FP_TYPE_SIZE
798 || fp_type_size[size] == NO_SIZE)
800 error (0, 0, _("invalid type string `%s';\n\
801 this system doesn't provide a %lu-byte floating point type"), s_orig, size);
808 size_spec = fp_type_size[size];
813 print_function = print_float;
814 /* Don't use %#e; not all systems support it. */
815 pre_fmt_string = " %%%d.%de";
816 fmt_string = xmalloc (strlen (pre_fmt_string));
817 sprintf (fmt_string, pre_fmt_string,
818 (field_width = FLT_DIG + 8), FLT_DIG);
822 print_function = print_double;
823 pre_fmt_string = " %%%d.%de";
824 fmt_string = xmalloc (strlen (pre_fmt_string));
825 sprintf (fmt_string, pre_fmt_string,
826 (field_width = DBL_DIG + 8), DBL_DIG);
829 #ifdef HAVE_LONG_DOUBLE
830 case FLOAT_LONG_DOUBLE:
831 print_function = print_long_double;
832 pre_fmt_string = " %%%d.%dLe";
833 fmt_string = xmalloc (strlen (pre_fmt_string));
834 sprintf (fmt_string, pre_fmt_string,
835 (field_width = LDBL_DIG + 8), LDBL_DIG);
846 fmt = NAMED_CHARACTER;
849 print_function = print_named_ascii;
858 print_function = print_ascii;
863 error (0, 0, _("invalid character `%c' in type string `%s'"),
868 tspec->size = size_spec;
870 tspec->print_function = print_function;
871 tspec->fmt_string = fmt_string;
873 tspec->field_width = field_width;
874 tspec->hexl_mode_trailer = (*s == 'z');
875 if (tspec->hexl_mode_trailer)
884 /* Decode the POSIX-style od format string S. Append the decoded
885 representation to the global array SPEC, reallocating SPEC if
886 necessary. Return zero if S is valid, nonzero otherwise. */
889 decode_format_string (const char *s)
891 const char *s_orig = s;
899 if (decode_one_format (s_orig, s, &next, &tspec))
905 if (n_specs >= n_specs_allocated)
907 n_specs_allocated = 1 + (3 * n_specs_allocated) / 2;
908 spec = (struct tspec *) xrealloc ((char *) spec,
910 * sizeof (struct tspec)));
913 memcpy ((char *) &spec[n_specs], (char *) &tspec,
914 sizeof (struct tspec));
921 /* Given a list of one or more input filenames FILE_LIST, set the global
922 file pointer IN_STREAM to position N_SKIP in the concatenation of
923 those files. If any file operation fails or if there are fewer than
924 N_SKIP bytes in the combined input, give an error message and return
925 nonzero. When possible, use seek- rather than read operations to
926 advance IN_STREAM. A file name of "-" is interpreted as standard
935 for ( /* empty */ ; *file_list != NULL; ++file_list)
937 struct stat file_stats;
940 if (STREQ (*file_list, "-"))
942 input_filename = _("standard input");
948 input_filename = *file_list;
949 in_stream = fopen (input_filename, "r");
950 if (in_stream == NULL)
952 error (0, errno, "%s", input_filename);
957 SET_BINARY (fileno (in_stream));
962 /* First try using fseek. For large offsets, this extra work is
963 worthwhile. If the offset is below some threshold it may be
964 more efficient to move the pointer by reading. There are two
965 issues when trying to use fseek:
966 - the file must be seekable.
967 - before seeking to the specified position, make sure
968 that the new position is in the current file.
969 Try to do that by getting file's size using fstat().
970 But that will work only for regular files and dirs. */
972 if (fstat (fileno (in_stream), &file_stats))
974 error (0, errno, "%s", input_filename);
979 /* The st_size field is valid only for regular files and
980 directories. FIXME: is the preceding true?
981 If the number of bytes left to skip is at least as large as
982 the size of the current file, we can decrement
983 n_skip and go on to the next file. */
984 if (S_ISREG (file_stats.st_mode) || S_ISDIR (file_stats.st_mode))
986 if (n_skip >= file_stats.st_size)
988 n_skip -= file_stats.st_size;
989 if (in_stream != stdin && fclose (in_stream) == EOF)
991 error (0, errno, "%s", input_filename);
998 /* Try fseeko if available, fseek otherwise. */
999 if (fseeko (in_stream, n_skip, SEEK_SET) == 0
1000 || (n_skip <= LONG_MAX
1001 && fseek (in_stream, (long) n_skip, SEEK_SET) == 0))
1009 /* Seek didn't work or wasn't attempted; position the file pointer
1012 for (j = n_skip / BUFSIZ; j >= 0; j--)
1015 size_t n_bytes_to_read = (j > 0
1018 size_t n_bytes_read;
1019 n_bytes_read = fread (buf, 1, n_bytes_to_read, in_stream);
1020 n_skip -= n_bytes_read;
1021 if (n_bytes_read != n_bytes_to_read)
1030 error (EXIT_FAILURE, 0, _("cannot skip past end of combined input"));
1036 format_address_none (long unsigned int address)
1042 format_address_std (long unsigned int address)
1044 const char *address_string;
1046 sprintf (address_fmt_buffer, output_address_fmt_string, address);
1047 address_string = address_fmt_buffer;
1048 return address_string;
1052 format_address_label (long unsigned int address)
1054 const char *address_string;
1055 assert (output_address_fmt_string != NULL);
1057 sprintf (address_fmt_buffer, output_address_fmt_string,
1058 address, address + pseudo_offset);
1059 address_string = address_fmt_buffer;
1060 return address_string;
1063 /* Write N_BYTES bytes from CURR_BLOCK to standard output once for each
1064 of the N_SPEC format specs. CURRENT_OFFSET is the byte address of
1065 CURR_BLOCK in the concatenation of input files, and it is printed
1066 (optionally) only before the output line associated with the first
1067 format spec. When duplicate blocks are being abbreviated, the output
1068 for a sequence of identical input blocks is the output for the first
1069 block followed by an asterisk alone on a line. It is valid to compare
1070 the blocks PREV_BLOCK and CURR_BLOCK only when N_BYTES == BYTES_PER_BLOCK.
1071 That condition may be false only for the last input block -- and then
1072 only when it has not been padded to length BYTES_PER_BLOCK. */
1075 write_block (long unsigned int current_offset, long unsigned int n_bytes,
1076 const char *prev_block, const char *curr_block)
1078 static int first = 1;
1079 static int prev_pair_equal = 0;
1081 #define EQUAL_BLOCKS(b1, b2) (memcmp ((b1), (b2), bytes_per_block) == 0)
1083 if (abbreviate_duplicate_blocks
1084 && !first && n_bytes == bytes_per_block
1085 && EQUAL_BLOCKS (prev_block, curr_block))
1087 if (prev_pair_equal)
1089 /* The two preceding blocks were equal, and the current
1090 block is the same as the last one, so print nothing. */
1095 prev_pair_equal = 1;
1102 prev_pair_equal = 0;
1103 for (i = 0; i < n_specs; i++)
1105 const char *addr_or_pad = (i == 0
1106 ? format_address (current_offset)
1109 fputs (addr_or_pad, stdout);
1110 (*spec[i].print_function) (n_bytes, curr_block, spec[i].fmt_string);
1111 if (spec[i].hexl_mode_trailer)
1113 /* space-pad out to full line width, then dump the trailer */
1114 int datum_width = width_bytes[spec[i].size];
1115 int blank_fields = (bytes_per_block - n_bytes) / datum_width;
1116 int field_width = spec[i].field_width + 1;
1117 printf ("%*s", blank_fields * field_width, "");
1118 dump_hexl_mode_trailer (n_bytes, curr_block);
1126 /* Test whether there have been errors on in_stream, and close it if
1127 it is not standard input. Return nonzero if there has been an error
1128 on in_stream or stdout; return zero otherwise. This function will
1129 report more than one error only if both a read and a write error
1133 check_and_close (void)
1138 if (ferror (in_stream))
1140 error (0, errno, "%s", input_filename);
1141 if (in_stream != stdin)
1145 else if (in_stream != stdin && fclose (in_stream) == EOF)
1147 error (0, errno, "%s", input_filename);
1151 if (ferror (stdout))
1153 error (0, errno, _("standard output"));
1160 /* Read a single byte into *C from the concatenation of the input files
1161 named in the global array FILE_LIST. On the first call to this
1162 function, the global variable IN_STREAM is expected to be an open
1163 stream associated with the input file *FILE_LIST. If IN_STREAM is
1164 at end-of-file, close it and update the global variables IN_STREAM,
1165 FILE_LIST, and INPUT_FILENAME so they correspond to the next file in
1166 the list. Then try to read a byte from the newly opened file.
1167 Repeat if necessary until *FILE_LIST is NULL. When EOF is reached
1168 for the last file in FILE_LIST, set *C to EOF and return. Subsequent
1169 calls do likewise. The return value is nonzero if any errors
1170 occured, zero otherwise. */
1177 if (*file_list == NULL)
1186 *c = fgetc (in_stream);
1191 err |= check_and_close ();
1196 if (*file_list == NULL)
1199 if (STREQ (*file_list, "-"))
1201 input_filename = _("standard input");
1203 have_read_stdin = 1;
1207 input_filename = *file_list;
1208 in_stream = fopen (input_filename, "r");
1209 if (in_stream == NULL)
1211 error (0, errno, "%s", input_filename);
1215 SET_BINARY (fileno (in_stream));
1217 while (in_stream == NULL);
1221 /* Read N bytes into BLOCK from the concatenation of the input files
1222 named in the global array FILE_LIST. On the first call to this
1223 function, the global variable IN_STREAM is expected to be an open
1224 stream associated with the input file *FILE_LIST. On subsequent
1225 calls, if *FILE_LIST is NULL, don't modify BLOCK and return zero.
1226 If all N bytes cannot be read from IN_STREAM, close IN_STREAM and
1227 update the global variables IN_STREAM, FILE_LIST, and INPUT_FILENAME.
1228 Then try to read the remaining bytes from the newly opened file.
1229 Repeat if necessary until *FILE_LIST is NULL. Set *N_BYTES_IN_BUFFER
1230 to the number of bytes read. If an error occurs, it will be detected
1231 through ferror when the stream is about to be closed. If there is an
1232 error, give a message but continue reading as usual and return nonzero.
1233 Otherwise return zero. */
1236 read_block (size_t n, char *block, size_t *n_bytes_in_buffer)
1240 assert (n > 0 && n <= bytes_per_block);
1242 *n_bytes_in_buffer = 0;
1247 if (*file_list == NULL)
1248 return 0; /* EOF. */
1256 n_needed = n - *n_bytes_in_buffer;
1257 n_read = fread (block + *n_bytes_in_buffer, 1, n_needed, in_stream);
1259 *n_bytes_in_buffer += n_read;
1261 if (n_read == n_needed)
1264 err |= check_and_close ();
1269 if (*file_list == NULL)
1272 if (STREQ (*file_list, "-"))
1274 input_filename = _("standard input");
1276 have_read_stdin = 1;
1280 input_filename = *file_list;
1281 in_stream = fopen (input_filename, "r");
1282 if (in_stream == NULL)
1284 error (0, errno, "%s", input_filename);
1288 SET_BINARY (fileno (in_stream));
1290 while (in_stream == NULL);
1294 /* Return the least common multiple of the sizes associated
1295 with the format specs. */
1303 for (i = 0; i < n_specs; i++)
1304 l_c_m = lcm (l_c_m, width_bytes[(int) spec[i].size]);
1308 /* If S is a valid pre-POSIX offset specification with an optional leading '+'
1309 return the offset it denotes. Otherwise, return -1. */
1312 parse_old_offset (const char *s)
1316 enum strtol_error s_err;
1317 long unsigned int tmp;
1322 /* Skip over any leading '+'. */
1326 /* Determine the radix we'll use to interpret S. If there is a `.',
1327 it's decimal, otherwise, if the string begins with `0X'or `0x',
1328 it's hexadecimal, else octal. */
1329 if (strchr (s, '.') != NULL)
1333 if (s[0] == '0' && (s[1] == 'x' || s[1] == 'X'))
1339 s_err = xstrtoul (s, NULL, radix, &tmp, "Bb");
1340 if (s_err != LONGINT_OK)
1342 STRTOL_FAIL_WARN (s, _("old-style offset"), s_err);
1349 /* Read a chunk of size BYTES_PER_BLOCK from the input files, write the
1350 formatted block to standard output, and repeat until the specified
1351 maximum number of bytes has been read or until all input has been
1352 processed. If the last block read is smaller than BYTES_PER_BLOCK
1353 and its size is not a multiple of the size associated with a format
1354 spec, extend the input block with zero bytes until its length is a
1355 multiple of all format spec sizes. Write the final block. Finally,
1356 write on a line by itself the offset of the byte after the last byte
1357 read. Accumulate return values from calls to read_block and
1358 check_and_close, and if any was nonzero, return nonzero.
1359 Otherwise, return zero. */
1365 off_t current_offset;
1369 size_t n_bytes_read;
1371 #ifdef lint /* Suppress `used before initialized' warning. */
1375 block[0] = (char *) alloca (bytes_per_block);
1376 block[1] = (char *) alloca (bytes_per_block);
1378 current_offset = n_bytes_to_skip;
1382 if (limit_bytes_to_format)
1384 end_offset = n_bytes_to_skip + max_bytes_to_format;
1389 if (current_offset >= end_offset)
1394 n_needed = MIN (end_offset - current_offset,
1395 (off_t) bytes_per_block);
1396 err |= read_block (n_needed, block[idx], &n_bytes_read);
1397 if (n_bytes_read < bytes_per_block)
1399 assert (n_bytes_read == bytes_per_block);
1400 write_block (current_offset, n_bytes_read,
1401 block[!idx], block[idx]);
1402 current_offset += n_bytes_read;
1410 err |= read_block (bytes_per_block, block[idx], &n_bytes_read);
1411 if (n_bytes_read < bytes_per_block)
1413 assert (n_bytes_read == bytes_per_block);
1414 write_block (current_offset, n_bytes_read,
1415 block[!idx], block[idx]);
1416 current_offset += n_bytes_read;
1421 if (n_bytes_read > 0)
1424 size_t bytes_to_write;
1428 /* Make bytes_to_write the smallest multiple of l_c_m that
1429 is at least as large as n_bytes_read. */
1430 bytes_to_write = l_c_m * (int) ((n_bytes_read + l_c_m - 1) / l_c_m);
1432 memset (block[idx] + n_bytes_read, 0, bytes_to_write - n_bytes_read);
1433 write_block (current_offset, bytes_to_write,
1434 block[!idx], block[idx]);
1435 current_offset += n_bytes_read;
1438 if (output_address_fmt_string != NULL)
1439 printf ("%s\n", format_address (current_offset));
1441 if (limit_bytes_to_format && current_offset > end_offset)
1442 err |= check_and_close ();
1447 /* STRINGS mode. Find each "string constant" in the input.
1448 A string constant is a run of at least `string_min' ASCII
1449 graphic (or formatting) characters terminated by a null.
1450 Based on a function written by Richard Stallman for a
1451 pre-POSIX version of od. Return nonzero if an error
1452 occurs. Otherwise, return zero. */
1457 size_t bufsize = MAX (100, string_min);
1458 char *buf = xmalloc (bufsize);
1459 off_t address = n_bytes_to_skip;
1468 /* See if the next `string_min' chars are all printing chars. */
1471 if (limit_bytes_to_format
1472 && address >= (n_bytes_to_skip + max_bytes_to_format -
1473 (off_t) string_min))
1476 for (i = 0; i < string_min; i++)
1478 err |= read_char (&c);
1486 /* Found a non-printing. Try again starting with next char. */
1491 /* We found a run of `string_min' printable characters.
1492 Now see if it is terminated with a null byte. */
1493 while (!limit_bytes_to_format
1494 || address < n_bytes_to_skip + max_bytes_to_format)
1498 bufsize = 1 + 3 * bufsize / 2;
1499 buf = xrealloc (buf, bufsize);
1501 err |= read_char (&c);
1509 break; /* It is; print this string. */
1511 goto tryline; /* It isn't; give up on this string. */
1512 buf[i++] = c; /* String continues; store it all. */
1515 /* If we get here, the string is all printable and null-terminated,
1516 so print it. It is all in `buf' and `i' is its length. */
1518 if (output_address_fmt_string != NULL)
1520 printf ("%s ", format_address (address - i - 1));
1522 for (i = 0; (c = buf[i]); i++)
1527 fputs ("\\a", stdout);
1531 fputs ("\\b", stdout);
1535 fputs ("\\f", stdout);
1539 fputs ("\\n", stdout);
1543 fputs ("\\r", stdout);
1547 fputs ("\\t", stdout);
1551 fputs ("\\v", stdout);
1561 /* We reach this point only if we search through
1562 (max_bytes_to_format - string_min) bytes before reachine EOF. */
1566 err |= check_and_close ();
1571 main (int argc, char **argv)
1577 unsigned int address_pad_len;
1578 unsigned long int desired_width;
1579 int width_specified = 0;
1580 int n_failed_decodes = 0;
1583 /* The old-style `pseudo starting address' to be printed in parentheses
1584 after any true address. */
1585 long int pseudo_start;
1587 #ifdef lint /* Suppress `used before initialized' warning. */
1591 program_name = argv[0];
1592 setlocale (LC_ALL, "");
1593 bindtextdomain (PACKAGE, LOCALEDIR);
1594 textdomain (PACKAGE);
1596 parse_long_options (argc, argv, "od", GNU_PACKAGE, VERSION,
1597 "Jim Meyering", usage);
1601 for (i = 0; i <= MAX_INTEGRAL_TYPE_SIZE; i++)
1602 integral_type_size[i] = NO_SIZE;
1604 integral_type_size[sizeof (char)] = CHAR;
1605 integral_type_size[sizeof (short int)] = SHORT;
1606 integral_type_size[sizeof (int)] = INT;
1607 integral_type_size[sizeof (long int)] = LONG;
1609 for (i = 0; i <= MAX_FP_TYPE_SIZE; i++)
1610 fp_type_size[i] = NO_SIZE;
1612 fp_type_size[sizeof (float)] = FLOAT_SINGLE;
1613 /* The array entry for `double' is filled in after that for LONG_DOUBLE
1614 so that if `long double' is the same type or if long double isn't
1615 supported FLOAT_LONG_DOUBLE will never be used. */
1616 fp_type_size[sizeof (LONG_DOUBLE)] = FLOAT_LONG_DOUBLE;
1617 fp_type_size[sizeof (double)] = FLOAT_DOUBLE;
1620 n_specs_allocated = 5;
1621 spec = (struct tspec *) xmalloc (n_specs_allocated * sizeof (struct tspec));
1623 output_address_fmt_string = "%07o";
1624 format_address = format_address_std;
1625 address_pad_len = 7;
1626 flag_dump_strings = 0;
1628 while ((c = getopt_long (argc, argv, "abcdfhilos::xw::A:j:N:t:v",
1629 long_options, NULL)) != -1)
1631 unsigned long int tmp;
1632 enum strtol_error s_err;
1643 output_address_fmt_string = "%07d";
1644 format_address = format_address_std;
1645 address_pad_len = 7;
1648 output_address_fmt_string = "%07o";
1649 format_address = format_address_std;
1650 address_pad_len = 7;
1653 output_address_fmt_string = "%06x";
1654 format_address = format_address_std;
1655 address_pad_len = 6;
1658 output_address_fmt_string = NULL;
1659 format_address = format_address_none;
1660 address_pad_len = 0;
1663 error (EXIT_FAILURE, 0,
1664 _("invalid output address radix `%c'; \
1665 it must be one character from [doxn]"),
1672 s_err = xstrtoul (optarg, NULL, 0, &tmp, "bkm");
1673 n_bytes_to_skip = tmp;
1674 if (s_err != LONGINT_OK)
1675 STRTOL_FATAL_ERROR (optarg, _("skip argument"), s_err);
1679 limit_bytes_to_format = 1;
1681 /* FIXME: if off_t is long long and that's an 8-byte type,
1682 use xstrtouq here. */
1683 s_err = xstrtoul (optarg, NULL, 0, &tmp, "bkm");
1684 max_bytes_to_format = tmp;
1685 if (s_err != LONGINT_OK)
1686 STRTOL_FATAL_ERROR (optarg, _("limit argument"), s_err);
1689 error (EXIT_FAILURE, 0,
1690 _("specified number of bytes `%s' is larger than \
1691 the maximum\nrepresentable value of type `long'"), optarg);
1699 s_err = xstrtoul (optarg, NULL, 0, &string_min, "bkm");
1700 if (s_err != LONGINT_OK)
1701 STRTOL_FATAL_ERROR (optarg, _("minimum string length"), s_err);
1703 ++flag_dump_strings;
1707 if (decode_format_string (optarg))
1712 abbreviate_duplicate_blocks = 0;
1719 /* The next several cases map the old, pre-POSIX format
1720 specification options to the corresponding POSIX format
1721 specs. GNU od accepts any combination of old- and
1722 new-style options. Format specification options accumulate. */
1724 #define CASE_OLD_ARG(old_char,new_string) \
1727 if (decode_format_string (new_string)) \
1728 ++n_failed_decodes; \
1732 CASE_OLD_ARG ('a', "a");
1733 CASE_OLD_ARG ('b', "oC");
1734 CASE_OLD_ARG ('c', "c");
1735 CASE_OLD_ARG ('d', "u2");
1736 CASE_OLD_ARG ('f', "fF");
1737 CASE_OLD_ARG ('h', "x2");
1738 CASE_OLD_ARG ('i', "d2");
1739 CASE_OLD_ARG ('l', "d4");
1740 CASE_OLD_ARG ('o', "o2");
1741 CASE_OLD_ARG ('x', "x2");
1746 width_specified = 1;
1753 s_err = xstrtoul (optarg, NULL, 10, &desired_width, "");
1754 if (s_err != LONGINT_OK)
1755 STRTOL_FATAL_ERROR (optarg, _("width specification"), s_err);
1765 if (n_failed_decodes > 0)
1766 exit (EXIT_FAILURE);
1768 if (flag_dump_strings && n_specs > 0)
1769 error (EXIT_FAILURE, 0,
1770 _("no type may be specified when dumping strings"));
1772 n_files = argc - optind;
1774 /* If the --backward-compatible option is used, there may be from
1775 0 to 3 remaining command line arguments; handle each case
1777 od [file] [[+]offset[.][b] [[+]label[.][b]]]
1778 The offset and pseudo_start have the same syntax. */
1786 if ((offset = parse_old_offset (argv[optind])) >= 0)
1788 n_bytes_to_skip = offset;
1793 else if (n_files == 2)
1796 if ((o1 = parse_old_offset (argv[optind])) >= 0
1797 && (o2 = parse_old_offset (argv[optind + 1])) >= 0)
1799 n_bytes_to_skip = o1;
1800 flag_pseudo_start = 1;
1805 else if ((o2 = parse_old_offset (argv[optind + 1])) >= 0)
1807 n_bytes_to_skip = o2;
1809 argv[optind + 1] = argv[optind];
1815 _("invalid second operand in compatibility mode `%s'"),
1820 else if (n_files == 3)
1823 if ((o1 = parse_old_offset (argv[optind + 1])) >= 0
1824 && (o2 = parse_old_offset (argv[optind + 2])) >= 0)
1826 n_bytes_to_skip = o1;
1827 flag_pseudo_start = 1;
1829 argv[optind + 2] = argv[optind];
1836 _("in compatibility mode, the last two arguments must be offsets"));
1840 else if (n_files > 3)
1843 _("compatibility mode supports at most three arguments"));
1847 if (flag_pseudo_start)
1849 static char buf[10];
1851 if (output_address_fmt_string == NULL)
1853 output_address_fmt_string = "(%07o)";
1854 format_address = format_address_std;
1858 sprintf (buf, "%s (%s)",
1859 output_address_fmt_string,
1860 output_address_fmt_string);
1861 output_address_fmt_string = buf;
1862 format_address = format_address_label;
1867 assert (address_pad_len <= MAX_ADDRESS_LENGTH);
1868 for (i = 0; i < address_pad_len; i++)
1869 address_pad[i] = ' ';
1870 address_pad[address_pad_len] = '\0';
1874 if (decode_one_format ("o2", "o2", NULL, &(spec[0])))
1876 /* This happens on Cray systems that don't have a 2-byte
1878 exit (EXIT_FAILURE);
1885 file_list = (char const *const *) &argv[optind];
1888 /* If no files were listed on the command line, set up the
1889 global array FILE_LIST so that it contains the null-terminated
1890 list of one name: "-". */
1891 static char const *const default_file_list[] = {"-", NULL};
1893 file_list = default_file_list;
1896 err |= skip (n_bytes_to_skip);
1897 if (in_stream == NULL)
1900 pseudo_offset = (flag_pseudo_start ? pseudo_start - n_bytes_to_skip : 0);
1902 /* Compute output block length. */
1905 if (width_specified)
1907 if (desired_width != 0 && desired_width % l_c_m == 0)
1908 bytes_per_block = desired_width;
1911 error (0, 0, _("warning: invalid width %lu; using %d instead"),
1912 desired_width, l_c_m);
1913 bytes_per_block = l_c_m;
1918 if (l_c_m < DEFAULT_BYTES_PER_BLOCK)
1919 bytes_per_block = l_c_m * (int) (DEFAULT_BYTES_PER_BLOCK / l_c_m);
1921 bytes_per_block = l_c_m;
1925 for (i = 0; i < n_specs; i++)
1927 printf (_("%d: fmt=\"%s\" width=%d\n"),
1928 i, spec[i].fmt_string, width_bytes[spec[i].size]);
1932 err |= (flag_dump_strings ? dump_strings () : dump ());
1936 if (have_read_stdin && fclose (stdin) == EOF)
1937 error (EXIT_FAILURE, errno, _("standard input"));
1939 if (fclose (stdout) == EOF)
1940 error (EXIT_FAILURE, errno, _("write error"));
1942 exit (err == 0 ? EXIT_SUCCESS : EXIT_FAILURE);