1 /* od -- dump files in octal and other formats
2 Copyright (C) 92, 95, 96, 1997, 1998 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;
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 /* If nonzero, display usage information and exit. */
244 static int show_help;
246 /* If nonzero, print the version on standard output then exit. */
247 static int show_version;
249 static struct option const long_options[] =
252 {"skip-bytes", required_argument, NULL, 'j'},
253 {"address-radix", required_argument, NULL, 'A'},
254 {"read-bytes", required_argument, NULL, 'N'},
255 {"format", required_argument, NULL, 't'},
256 {"output-duplicates", no_argument, NULL, 'v'},
258 /* non-POSIX options. */
259 {"strings", optional_argument, NULL, 's'},
260 {"traditional", no_argument, NULL, 'B'},
261 {"width", optional_argument, NULL, 'w'},
262 {"help", no_argument, &show_help, 1},
263 {"version", no_argument, &show_version, 1},
271 fprintf (stderr, _("Try `%s --help' for more information.\n"),
276 Usage: %s [OPTION]... [FILE]...\n\
277 or: %s --traditional [FILE] [[+]OFFSET [[+]LABEL]]\n\
279 program_name, program_name);
281 Write an unambiguous representation, octal bytes by default, of FILE\n\
282 to standard output. With no FILE, or when FILE is -, read standard input.\n\
284 -A, --address-radix=RADIX decide how file offsets are printed\n\
285 -j, --skip-bytes=BYTES skip BYTES input bytes first on each file\n\
286 -N, --read-bytes=BYTES limit dump to BYTES input bytes per file\n\
287 -s, --strings[=BYTES] output strings of at least BYTES graphic chars\n\
288 -t, --format=TYPE select output format or formats\n\
289 -v, --output-duplicates do not use * to mark line suppression\n\
290 -w, --width[=BYTES] output BYTES bytes per output line\n\
291 --traditional accept arguments in pre-POSIX form\n\
292 --help display this help and exit\n\
293 --version output version information and exit\n\
295 Pre-POSIX format specifications may be intermixed, they accumulate:\n\
296 -a same as -t a, select named characters\n\
297 -b same as -t oC, select octal bytes\n\
298 -c same as -t c, select ASCII characters or backslash escapes\n\
299 -d same as -t u2, select unsigned decimal shorts\n\
300 -f same as -t fF, select floats\n\
301 -h same as -t x2, select hexadecimal shorts\n\
302 -i same as -t d2, select decimal shorts\n\
303 -l same as -t d4, select decimal longs\n\
304 -o same as -t o2, select octal shorts\n\
305 -x same as -t x2, select hexadecimal shorts\n\
309 For older syntax (second call format), OFFSET means -j OFFSET. LABEL\n\
310 is the pseudo-address at first byte printed, incremented when dump is\n\
311 progressing. For OFFSET and LABEL, a 0x or 0X prefix indicates\n\
312 hexadecimal, suffixes maybe . for octal and b multiply by 512.\n\
314 TYPE is made up of one or more of these specifications:\n\
317 c ASCII character or backslash escape\n\
318 d[SIZE] signed decimal, SIZE bytes per integer\n\
319 f[SIZE] floating point, SIZE bytes per integer\n\
320 o[SIZE] octal, SIZE bytes per integer\n\
321 u[SIZE] unsigned decimal, SIZE bytes per integer\n\
322 x[SIZE] hexadecimal, SIZE bytes per integer\n\
324 SIZE is a number. For TYPE in doux, SIZE may also be C for\n\
325 sizeof(char), S for sizeof(short), I for sizeof(int) or L for\n\
326 sizeof(long). If TYPE is f, SIZE may also be F for sizeof(float), D\n\
327 for sizeof(double) or L for sizeof(long double).\n\
329 RADIX is d for decimal, o for octal, x for hexadecimal or n for none.\n\
330 BYTES is hexadecimal with 0x or 0X prefix, it is multiplied by 512\n\
331 with b suffix, by 1024 with k and by 1048576 with m. Adding a z suffix to\n\
332 any type adds a display of printable characters to the end of each line\n\
333 of output. -s without a number implies 3. -w without a number implies 32.\n\
334 By default, od uses -A o -t d2 -w 16.\n\
336 puts (_("\nReport bugs to <bug-textutils@gnu.org>."));
338 exit (status == 0 ? EXIT_SUCCESS : EXIT_FAILURE);
341 /* Compute the greatest common denominator of U and V
342 using Euclid's algorithm. */
345 gcd (unsigned int u, unsigned int v)
357 /* Compute the least common multiple of U and V. */
360 lcm (unsigned int u, unsigned int v)
362 unsigned int t = gcd (u, v);
369 print_s_char (long unsigned int n_bytes, const char *block,
370 const char *fmt_string)
373 for (i = n_bytes; i > 0; i--)
375 int tmp = (unsigned) *(const unsigned char *) block;
377 tmp -= SCHAR_MAX - SCHAR_MIN + 1;
378 assert (tmp <= SCHAR_MAX);
379 printf (fmt_string, tmp);
380 block += sizeof (unsigned char);
385 print_char (long unsigned int n_bytes, const char *block,
386 const char *fmt_string)
389 for (i = n_bytes; i > 0; i--)
391 unsigned int tmp = *(const unsigned char *) block;
392 printf (fmt_string, tmp);
393 block += sizeof (unsigned char);
398 print_s_short (long unsigned int n_bytes, const char *block,
399 const char *fmt_string)
402 for (i = n_bytes / sizeof (unsigned short); i > 0; i--)
404 int tmp = (unsigned) *(const unsigned short *) block;
406 tmp -= SHRT_MAX - SHRT_MIN + 1;
407 assert (tmp <= SHRT_MAX);
408 printf (fmt_string, tmp);
409 block += sizeof (unsigned short);
414 print_short (long unsigned int n_bytes, const char *block,
415 const char *fmt_string)
418 for (i = n_bytes / sizeof (unsigned short); i > 0; i--)
420 unsigned int tmp = *(const unsigned short *) block;
421 printf (fmt_string, tmp);
422 block += sizeof (unsigned short);
427 print_int (long unsigned int n_bytes, const char *block,
428 const char *fmt_string)
431 for (i = n_bytes / sizeof (unsigned int); i > 0; i--)
433 unsigned int tmp = *(const unsigned int *) block;
434 printf (fmt_string, tmp);
435 block += sizeof (unsigned int);
440 print_long (long unsigned int n_bytes, const char *block,
441 const char *fmt_string)
444 for (i = n_bytes / sizeof (unsigned long); i > 0; i--)
446 unsigned long tmp = *(const unsigned long *) block;
447 printf (fmt_string, tmp);
448 block += sizeof (unsigned long);
453 print_float (long unsigned int n_bytes, const char *block,
454 const char *fmt_string)
457 for (i = n_bytes / sizeof (float); i > 0; i--)
459 float tmp = *(const float *) block;
460 printf (fmt_string, tmp);
461 block += sizeof (float);
466 print_double (long unsigned int n_bytes, const char *block,
467 const char *fmt_string)
470 for (i = n_bytes / sizeof (double); i > 0; i--)
472 double tmp = *(const double *) block;
473 printf (fmt_string, tmp);
474 block += sizeof (double);
478 #ifdef HAVE_LONG_DOUBLE
480 print_long_double (long unsigned int n_bytes, const char *block,
481 const char *fmt_string)
484 for (i = n_bytes / sizeof (LONG_DOUBLE); i > 0; i--)
486 LONG_DOUBLE tmp = *(const LONG_DOUBLE *) block;
487 printf (fmt_string, tmp);
488 block += sizeof (LONG_DOUBLE);
495 dump_hexl_mode_trailer (long unsigned int n_bytes, const char *block)
498 fputs (" >", stdout);
499 for (i = n_bytes; i > 0; i--)
501 unsigned int c = *(const unsigned char *) block;
502 unsigned int c2 = (ISPRINT(c) ? c : '.');
504 block += sizeof (unsigned char);
510 print_named_ascii (long unsigned int n_bytes, const char *block,
511 const char *unused_fmt_string)
514 for (i = n_bytes; i > 0; i--)
516 unsigned int c = *(const unsigned char *) block;
517 unsigned int masked_c = (0x7f & c);
523 else if (masked_c <= 040)
524 s = charname[masked_c];
527 sprintf (buf, " %c", masked_c);
532 block += sizeof (unsigned char);
537 print_ascii (long unsigned int n_bytes, const char *block,
538 const char *unused_fmt_string)
541 for (i = n_bytes; i > 0; i--)
543 unsigned int c = *(const unsigned char *) block;
582 sprintf (buf, (ISPRINT (c) ? " %c" : "%03o"), c);
583 s = (const char *) buf;
587 block += sizeof (unsigned char);
591 /* Convert a null-terminated (possibly zero-length) string S to an
592 unsigned long integer value. If S points to a non-digit set *P to S,
593 *VAL to 0, and return 0. Otherwise, accumulate the integer value of
594 the string of digits. If the string of digits represents a value
595 larger than ULONG_MAX, don't modify *VAL or *P and return nonzero.
596 Otherwise, advance *P to the first non-digit after S, set *VAL to
597 the result of the conversion and return zero. */
600 simple_strtoul (const char *s, const char **p, long unsigned int *val)
602 unsigned long int sum;
607 unsigned int c = *s++ - '0';
608 if (sum > (ULONG_MAX - c) / 10)
617 /* If S points to a single valid POSIX-style od format string, put
618 a description of that format in *TSPEC, make *NEXT point at the
619 character following the just-decoded format (if *NEXT is non-NULL),
620 and return zero. If S is not valid, don't modify *NEXT or *TSPEC,
621 give a diagnostic, and return nonzero. For example, if S were
622 "d4afL" *NEXT would be set to "afL" and *TSPEC would be
624 fmt = SIGNED_DECIMAL;
625 size = INT or LONG; (whichever integral_type_size[4] resolves to)
626 print_function = print_int; (assuming size == INT)
627 fmt_string = "%011d%c";
629 S_ORIG is solely for reporting errors. It should be the full format
634 decode_one_format (const char *s_orig, const char *s, const char **next,
637 enum size_spec size_spec;
638 unsigned long int size;
639 enum output_format fmt;
640 const char *pre_fmt_string;
642 void (*print_function) ();
645 unsigned int field_width = 0;
647 assert (tspec != NULL);
661 size = sizeof (char);
666 size = sizeof (short);
676 size = sizeof (long int);
680 if (simple_strtoul (s, &p, &size) != 0)
682 /* The integer at P in S would overflow an unsigned long.
683 A digit string that long is sufficiently odd looking
684 that the following diagnostic is sufficient. */
685 error (0, 0, _("invalid type string `%s'"), s_orig);
692 if (size > MAX_INTEGRAL_TYPE_SIZE
693 || integral_type_size[size] == NO_SIZE)
695 error (0, 0, _("invalid type string `%s';\n\
696 this system doesn't provide a %lu-byte integral type"), s_orig, size);
704 #define FMT_BYTES_ALLOCATED 9
705 fmt_string = xmalloc (FMT_BYTES_ALLOCATED);
707 size_spec = integral_type_size[size];
712 fmt = SIGNED_DECIMAL;
713 sprintf (fmt_string, " %%%u%sd",
714 (field_width = bytes_to_signed_dec_digits[size]),
715 (size_spec == LONG ? "l" : ""));
720 sprintf (fmt_string, " %%0%u%so",
721 (field_width = bytes_to_oct_digits[size]),
722 (size_spec == LONG ? "l" : ""));
726 fmt = UNSIGNED_DECIMAL;
727 sprintf (fmt_string, " %%%u%su",
728 (field_width = bytes_to_unsigned_dec_digits[size]),
729 (size_spec == LONG ? "l" : ""));
734 sprintf (fmt_string, " %%0%u%sx",
735 (field_width = bytes_to_hex_digits[size]),
736 (size_spec == LONG ? "l" : ""));
743 assert (strlen (fmt_string) < FMT_BYTES_ALLOCATED);
748 print_function = (fmt == SIGNED_DECIMAL
754 print_function = (fmt == SIGNED_DECIMAL
760 print_function = print_int;
764 print_function = print_long;
773 fmt = FLOATING_POINT;
779 size = sizeof (float);
784 size = sizeof (double);
789 size = sizeof (LONG_DOUBLE);
793 if (simple_strtoul (s, &p, &size) != 0)
795 /* The integer at P in S would overflow an unsigned long.
796 A digit string that long is sufficiently odd looking
797 that the following diagnostic is sufficient. */
798 error (0, 0, _("invalid type string `%s'"), s_orig);
802 size = sizeof (double);
805 if (size > MAX_FP_TYPE_SIZE
806 || fp_type_size[size] == NO_SIZE)
808 error (0, 0, _("invalid type string `%s';\n\
809 this system doesn't provide a %lu-byte floating point type"), s_orig, size);
816 size_spec = fp_type_size[size];
821 print_function = print_float;
822 /* Don't use %#e; not all systems support it. */
823 pre_fmt_string = " %%%d.%de";
824 fmt_string = xmalloc (strlen (pre_fmt_string));
825 sprintf (fmt_string, pre_fmt_string,
826 (field_width = FLT_DIG + 8), FLT_DIG);
830 print_function = print_double;
831 pre_fmt_string = " %%%d.%de";
832 fmt_string = xmalloc (strlen (pre_fmt_string));
833 sprintf (fmt_string, pre_fmt_string,
834 (field_width = DBL_DIG + 8), DBL_DIG);
837 #ifdef HAVE_LONG_DOUBLE
838 case FLOAT_LONG_DOUBLE:
839 print_function = print_long_double;
840 pre_fmt_string = " %%%d.%dLe";
841 fmt_string = xmalloc (strlen (pre_fmt_string));
842 sprintf (fmt_string, pre_fmt_string,
843 (field_width = LDBL_DIG + 8), LDBL_DIG);
854 fmt = NAMED_CHARACTER;
857 print_function = print_named_ascii;
866 print_function = print_ascii;
871 error (0, 0, _("invalid character `%c' in type string `%s'"),
876 tspec->size = size_spec;
878 tspec->print_function = print_function;
879 tspec->fmt_string = fmt_string;
881 tspec->field_width = field_width;
882 tspec->hexl_mode_trailer = (*s == 'z');
883 if (tspec->hexl_mode_trailer)
892 /* Decode the POSIX-style od format string S. Append the decoded
893 representation to the global array SPEC, reallocating SPEC if
894 necessary. Return zero if S is valid, nonzero otherwise. */
897 decode_format_string (const char *s)
899 const char *s_orig = s;
907 if (decode_one_format (s_orig, s, &next, &tspec))
913 if (n_specs >= n_specs_allocated)
915 n_specs_allocated = 1 + (3 * n_specs_allocated) / 2;
916 spec = (struct tspec *) xrealloc ((char *) spec,
918 * sizeof (struct tspec)));
921 memcpy ((char *) &spec[n_specs], (char *) &tspec,
922 sizeof (struct tspec));
929 /* Given a list of one or more input filenames FILE_LIST, set the global
930 file pointer IN_STREAM to position N_SKIP in the concatenation of
931 those files. If any file operation fails or if there are fewer than
932 N_SKIP bytes in the combined input, give an error message and return
933 nonzero. When possible, use seek- rather than read operations to
934 advance IN_STREAM. A file name of "-" is interpreted as standard
943 for ( /* empty */ ; *file_list != NULL; ++file_list)
945 struct stat file_stats;
948 if (STREQ (*file_list, "-"))
950 input_filename = _("standard input");
956 input_filename = *file_list;
957 in_stream = fopen (input_filename, "r");
958 if (in_stream == NULL)
960 error (0, errno, "%s", input_filename);
965 SET_BINARY (fileno (in_stream));
970 /* First try using fseek. For large offsets, this extra work is
971 worthwhile. If the offset is below some threshold it may be
972 more efficient to move the pointer by reading. There are two
973 issues when trying to use fseek:
974 - the file must be seekable.
975 - before seeking to the specified position, make sure
976 that the new position is in the current file.
977 Try to do that by getting file's size using fstat().
978 But that will work only for regular files and dirs. */
980 if (fstat (fileno (in_stream), &file_stats))
982 error (0, errno, "%s", input_filename);
987 /* The st_size field is valid only for regular files and
988 directories. FIXME: is the preceding true?
989 If the number of bytes left to skip is at least as large as
990 the size of the current file, we can decrement
991 n_skip and go on to the next file. */
992 if (S_ISREG (file_stats.st_mode) || S_ISDIR (file_stats.st_mode))
994 if (n_skip >= file_stats.st_size)
996 n_skip -= file_stats.st_size;
997 if (in_stream != stdin && fclose (in_stream) == EOF)
999 error (0, errno, "%s", input_filename);
1006 /* Try fseeko if available, fseek otherwise. */
1007 if (fseeko (in_stream, n_skip, SEEK_SET) == 0
1008 || (n_skip <= LONG_MAX
1009 && fseek (in_stream, (long) n_skip, SEEK_SET) == 0))
1017 /* Seek didn't work or wasn't attempted; position the file pointer
1020 for (j = n_skip / BUFSIZ; j >= 0; j--)
1023 size_t n_bytes_to_read = (j > 0
1026 size_t n_bytes_read;
1027 n_bytes_read = fread (buf, 1, n_bytes_to_read, in_stream);
1028 n_skip -= n_bytes_read;
1029 if (n_bytes_read != n_bytes_to_read)
1038 error (EXIT_FAILURE, 0, _("cannot skip past end of combined input"));
1044 format_address_none (long unsigned int address)
1050 format_address_std (long unsigned int address)
1052 const char *address_string;
1054 sprintf (address_fmt_buffer, output_address_fmt_string, address);
1055 address_string = address_fmt_buffer;
1056 return address_string;
1060 format_address_label (long unsigned int address)
1062 const char *address_string;
1063 assert (output_address_fmt_string != NULL);
1065 sprintf (address_fmt_buffer, output_address_fmt_string,
1066 address, address + pseudo_offset);
1067 address_string = address_fmt_buffer;
1068 return address_string;
1071 /* Write N_BYTES bytes from CURR_BLOCK to standard output once for each
1072 of the N_SPEC format specs. CURRENT_OFFSET is the byte address of
1073 CURR_BLOCK in the concatenation of input files, and it is printed
1074 (optionally) only before the output line associated with the first
1075 format spec. When duplicate blocks are being abbreviated, the output
1076 for a sequence of identical input blocks is the output for the first
1077 block followed by an asterisk alone on a line. It is valid to compare
1078 the blocks PREV_BLOCK and CURR_BLOCK only when N_BYTES == BYTES_PER_BLOCK.
1079 That condition may be false only for the last input block -- and then
1080 only when it has not been padded to length BYTES_PER_BLOCK. */
1083 write_block (long unsigned int current_offset, long unsigned int n_bytes,
1084 const char *prev_block, const char *curr_block)
1086 static int first = 1;
1087 static int prev_pair_equal = 0;
1089 #define EQUAL_BLOCKS(b1, b2) (memcmp ((b1), (b2), bytes_per_block) == 0)
1091 if (abbreviate_duplicate_blocks
1092 && !first && n_bytes == bytes_per_block
1093 && EQUAL_BLOCKS (prev_block, curr_block))
1095 if (prev_pair_equal)
1097 /* The two preceding blocks were equal, and the current
1098 block is the same as the last one, so print nothing. */
1103 prev_pair_equal = 1;
1110 prev_pair_equal = 0;
1111 for (i = 0; i < n_specs; i++)
1113 const char *addr_or_pad = (i == 0
1114 ? format_address (current_offset)
1117 fputs (addr_or_pad, stdout);
1118 (*spec[i].print_function) (n_bytes, curr_block, spec[i].fmt_string);
1119 if (spec[i].hexl_mode_trailer)
1121 /* space-pad out to full line width, then dump the trailer */
1122 int datum_width = width_bytes[spec[i].size];
1123 int blank_fields = (bytes_per_block - n_bytes) / datum_width;
1124 int field_width = spec[i].field_width + 1;
1125 printf ("%*s", blank_fields * field_width, "");
1126 dump_hexl_mode_trailer (n_bytes, curr_block);
1134 /* Test whether there have been errors on in_stream, and close it if
1135 it is not standard input. Return nonzero if there has been an error
1136 on in_stream or stdout; return zero otherwise. This function will
1137 report more than one error only if both a read and a write error
1141 check_and_close (void)
1146 if (ferror (in_stream))
1148 error (0, errno, "%s", input_filename);
1149 if (in_stream != stdin)
1153 else if (in_stream != stdin && fclose (in_stream) == EOF)
1155 error (0, errno, "%s", input_filename);
1159 if (ferror (stdout))
1161 error (0, errno, _("standard output"));
1168 /* Read a single byte into *C from the concatenation of the input files
1169 named in the global array FILE_LIST. On the first call to this
1170 function, the global variable IN_STREAM is expected to be an open
1171 stream associated with the input file *FILE_LIST. If IN_STREAM is
1172 at end-of-file, close it and update the global variables IN_STREAM,
1173 FILE_LIST, and INPUT_FILENAME so they correspond to the next file in
1174 the list. Then try to read a byte from the newly opened file.
1175 Repeat if necessary until *FILE_LIST is NULL. When EOF is reached
1176 for the last file in FILE_LIST, set *C to EOF and return. Subsequent
1177 calls do likewise. The return value is nonzero if any errors
1178 occured, zero otherwise. */
1185 if (*file_list == NULL)
1194 *c = fgetc (in_stream);
1199 err |= check_and_close ();
1204 if (*file_list == NULL)
1207 if (STREQ (*file_list, "-"))
1209 input_filename = _("standard input");
1211 have_read_stdin = 1;
1215 input_filename = *file_list;
1216 in_stream = fopen (input_filename, "r");
1217 if (in_stream == NULL)
1219 error (0, errno, "%s", input_filename);
1223 SET_BINARY (fileno (in_stream));
1225 while (in_stream == NULL);
1229 /* Read N bytes into BLOCK from the concatenation of the input files
1230 named in the global array FILE_LIST. On the first call to this
1231 function, the global variable IN_STREAM is expected to be an open
1232 stream associated with the input file *FILE_LIST. On subsequent
1233 calls, if *FILE_LIST is NULL, don't modify BLOCK and return zero.
1234 If all N bytes cannot be read from IN_STREAM, close IN_STREAM and
1235 update the global variables IN_STREAM, FILE_LIST, and INPUT_FILENAME.
1236 Then try to read the remaining bytes from the newly opened file.
1237 Repeat if necessary until *FILE_LIST is NULL. Set *N_BYTES_IN_BUFFER
1238 to the number of bytes read. If an error occurs, it will be detected
1239 through ferror when the stream is about to be closed. If there is an
1240 error, give a message but continue reading as usual and return nonzero.
1241 Otherwise return zero. */
1244 read_block (size_t n, char *block, size_t *n_bytes_in_buffer)
1248 assert (n > 0 && n <= bytes_per_block);
1250 *n_bytes_in_buffer = 0;
1255 if (*file_list == NULL)
1256 return 0; /* EOF. */
1264 n_needed = n - *n_bytes_in_buffer;
1265 n_read = fread (block + *n_bytes_in_buffer, 1, n_needed, in_stream);
1267 *n_bytes_in_buffer += n_read;
1269 if (n_read == n_needed)
1272 err |= check_and_close ();
1277 if (*file_list == NULL)
1280 if (STREQ (*file_list, "-"))
1282 input_filename = _("standard input");
1284 have_read_stdin = 1;
1288 input_filename = *file_list;
1289 in_stream = fopen (input_filename, "r");
1290 if (in_stream == NULL)
1292 error (0, errno, "%s", input_filename);
1296 SET_BINARY (fileno (in_stream));
1298 while (in_stream == NULL);
1302 /* Return the least common multiple of the sizes associated
1303 with the format specs. */
1311 for (i = 0; i < n_specs; i++)
1312 l_c_m = lcm (l_c_m, width_bytes[(int) spec[i].size]);
1316 /* If S is a valid pre-POSIX offset specification with an optional leading '+'
1317 return the offset it denotes. Otherwise, return -1. */
1320 parse_old_offset (const char *s)
1324 enum strtol_error s_err;
1325 long unsigned int tmp;
1330 /* Skip over any leading '+'. */
1334 /* Determine the radix we'll use to interpret S. If there is a `.',
1335 it's decimal, otherwise, if the string begins with `0X'or `0x',
1336 it's hexadecimal, else octal. */
1337 if (strchr (s, '.') != NULL)
1341 if (s[0] == '0' && (s[1] == 'x' || s[1] == 'X'))
1347 s_err = xstrtoul (s, NULL, radix, &tmp, "Bb");
1348 if (s_err != LONGINT_OK)
1350 STRTOL_FAIL_WARN (s, _("old-style offset"), s_err);
1357 /* Read a chunk of size BYTES_PER_BLOCK from the input files, write the
1358 formatted block to standard output, and repeat until the specified
1359 maximum number of bytes has been read or until all input has been
1360 processed. If the last block read is smaller than BYTES_PER_BLOCK
1361 and its size is not a multiple of the size associated with a format
1362 spec, extend the input block with zero bytes until its length is a
1363 multiple of all format spec sizes. Write the final block. Finally,
1364 write on a line by itself the offset of the byte after the last byte
1365 read. Accumulate return values from calls to read_block and
1366 check_and_close, and if any was nonzero, return nonzero.
1367 Otherwise, return zero. */
1373 off_t current_offset;
1377 size_t n_bytes_read;
1379 #ifdef lint /* Suppress `used before initialized' warning. */
1383 block[0] = (char *) alloca (bytes_per_block);
1384 block[1] = (char *) alloca (bytes_per_block);
1386 current_offset = n_bytes_to_skip;
1390 if (limit_bytes_to_format)
1392 end_offset = n_bytes_to_skip + max_bytes_to_format;
1397 if (current_offset >= end_offset)
1402 n_needed = MIN (end_offset - current_offset,
1403 (off_t) bytes_per_block);
1404 err |= read_block (n_needed, block[idx], &n_bytes_read);
1405 if (n_bytes_read < bytes_per_block)
1407 assert (n_bytes_read == bytes_per_block);
1408 write_block (current_offset, n_bytes_read,
1409 block[!idx], block[idx]);
1410 current_offset += n_bytes_read;
1418 err |= read_block (bytes_per_block, block[idx], &n_bytes_read);
1419 if (n_bytes_read < bytes_per_block)
1421 assert (n_bytes_read == bytes_per_block);
1422 write_block (current_offset, n_bytes_read,
1423 block[!idx], block[idx]);
1424 current_offset += n_bytes_read;
1429 if (n_bytes_read > 0)
1432 size_t bytes_to_write;
1436 /* Make bytes_to_write the smallest multiple of l_c_m that
1437 is at least as large as n_bytes_read. */
1438 bytes_to_write = l_c_m * (int) ((n_bytes_read + l_c_m - 1) / l_c_m);
1440 memset (block[idx] + n_bytes_read, 0, bytes_to_write - n_bytes_read);
1441 write_block (current_offset, bytes_to_write,
1442 block[!idx], block[idx]);
1443 current_offset += n_bytes_read;
1446 if (output_address_fmt_string != NULL)
1447 printf ("%s\n", format_address (current_offset));
1449 if (limit_bytes_to_format && current_offset > end_offset)
1450 err |= check_and_close ();
1455 /* STRINGS mode. Find each "string constant" in the input.
1456 A string constant is a run of at least `string_min' ASCII
1457 graphic (or formatting) characters terminated by a null.
1458 Based on a function written by Richard Stallman for a
1459 pre-POSIX version of od. Return nonzero if an error
1460 occurs. Otherwise, return zero. */
1465 size_t bufsize = MAX (100, string_min);
1466 char *buf = xmalloc (bufsize);
1467 off_t address = n_bytes_to_skip;
1476 /* See if the next `string_min' chars are all printing chars. */
1479 if (limit_bytes_to_format
1480 && address >= (n_bytes_to_skip + max_bytes_to_format -
1481 (off_t) string_min))
1484 for (i = 0; i < string_min; i++)
1486 err |= read_char (&c);
1494 /* Found a non-printing. Try again starting with next char. */
1499 /* We found a run of `string_min' printable characters.
1500 Now see if it is terminated with a null byte. */
1501 while (!limit_bytes_to_format
1502 || address < n_bytes_to_skip + max_bytes_to_format)
1506 bufsize = 1 + 3 * bufsize / 2;
1507 buf = xrealloc (buf, bufsize);
1509 err |= read_char (&c);
1517 break; /* It is; print this string. */
1519 goto tryline; /* It isn't; give up on this string. */
1520 buf[i++] = c; /* String continues; store it all. */
1523 /* If we get here, the string is all printable and null-terminated,
1524 so print it. It is all in `buf' and `i' is its length. */
1526 if (output_address_fmt_string != NULL)
1528 printf ("%s ", format_address (address - i - 1));
1530 for (i = 0; (c = buf[i]); i++)
1535 fputs ("\\a", stdout);
1539 fputs ("\\b", stdout);
1543 fputs ("\\f", stdout);
1547 fputs ("\\n", stdout);
1551 fputs ("\\r", stdout);
1555 fputs ("\\t", stdout);
1559 fputs ("\\v", stdout);
1569 /* We reach this point only if we search through
1570 (max_bytes_to_format - string_min) bytes before reachine EOF. */
1574 err |= check_and_close ();
1579 main (int argc, char **argv)
1585 unsigned int address_pad_len;
1586 unsigned long int desired_width;
1587 int width_specified = 0;
1588 int n_failed_decodes = 0;
1591 /* The old-style `pseudo starting address' to be printed in parentheses
1592 after any true address. */
1593 long int pseudo_start;
1595 #ifdef lint /* Suppress `used before initialized' warning. */
1599 program_name = argv[0];
1600 setlocale (LC_ALL, "");
1601 bindtextdomain (PACKAGE, LOCALEDIR);
1602 textdomain (PACKAGE);
1606 for (i = 0; i <= MAX_INTEGRAL_TYPE_SIZE; i++)
1607 integral_type_size[i] = NO_SIZE;
1609 integral_type_size[sizeof (char)] = CHAR;
1610 integral_type_size[sizeof (short int)] = SHORT;
1611 integral_type_size[sizeof (int)] = INT;
1612 integral_type_size[sizeof (long int)] = LONG;
1614 for (i = 0; i <= MAX_FP_TYPE_SIZE; i++)
1615 fp_type_size[i] = NO_SIZE;
1617 fp_type_size[sizeof (float)] = FLOAT_SINGLE;
1618 /* The array entry for `double' is filled in after that for LONG_DOUBLE
1619 so that if `long double' is the same type or if long double isn't
1620 supported FLOAT_LONG_DOUBLE will never be used. */
1621 fp_type_size[sizeof (LONG_DOUBLE)] = FLOAT_LONG_DOUBLE;
1622 fp_type_size[sizeof (double)] = FLOAT_DOUBLE;
1625 n_specs_allocated = 5;
1626 spec = (struct tspec *) xmalloc (n_specs_allocated * sizeof (struct tspec));
1628 output_address_fmt_string = "%07o";
1629 format_address = format_address_std;
1630 address_pad_len = 7;
1631 flag_dump_strings = 0;
1633 while ((c = getopt_long (argc, argv, "abcdfhilos::xw::A:j:N:t:v",
1634 long_options, NULL)) != -1)
1636 unsigned long int tmp;
1637 enum strtol_error s_err;
1648 output_address_fmt_string = "%07d";
1649 format_address = format_address_std;
1650 address_pad_len = 7;
1653 output_address_fmt_string = "%07o";
1654 format_address = format_address_std;
1655 address_pad_len = 7;
1658 output_address_fmt_string = "%06x";
1659 format_address = format_address_std;
1660 address_pad_len = 6;
1663 output_address_fmt_string = NULL;
1664 format_address = format_address_none;
1665 address_pad_len = 0;
1668 error (EXIT_FAILURE, 0,
1669 _("invalid output address radix `%c'; \
1670 it must be one character from [doxn]"),
1677 s_err = xstrtoul (optarg, NULL, 0, &tmp, "bkm");
1678 n_bytes_to_skip = tmp;
1679 if (s_err != LONGINT_OK)
1680 STRTOL_FATAL_ERROR (optarg, _("skip argument"), s_err);
1684 limit_bytes_to_format = 1;
1686 /* FIXME: if off_t is long long and that's an 8-byte type,
1687 use xstrtouq here. */
1688 s_err = xstrtoul (optarg, NULL, 0, &tmp, "bkm");
1689 max_bytes_to_format = tmp;
1690 if (s_err != LONGINT_OK)
1691 STRTOL_FATAL_ERROR (optarg, _("limit argument"), s_err);
1694 error (EXIT_FAILURE, 0,
1695 _("specified number of bytes `%s' is larger than \
1696 the maximum\nrepresentable value of type `long'"), optarg);
1704 s_err = xstrtoul (optarg, NULL, 0, &string_min, "bkm");
1705 if (s_err != LONGINT_OK)
1706 STRTOL_FATAL_ERROR (optarg, _("minimum string length"), s_err);
1708 ++flag_dump_strings;
1712 if (decode_format_string (optarg))
1717 abbreviate_duplicate_blocks = 0;
1724 /* The next several cases map the old, pre-POSIX format
1725 specification options to the corresponding POSIX format
1726 specs. GNU od accepts any combination of old- and
1727 new-style options. Format specification options accumulate. */
1729 #define CASE_OLD_ARG(old_char,new_string) \
1732 if (decode_format_string (new_string)) \
1733 ++n_failed_decodes; \
1737 CASE_OLD_ARG ('a', "a");
1738 CASE_OLD_ARG ('b', "oC");
1739 CASE_OLD_ARG ('c', "c");
1740 CASE_OLD_ARG ('d', "u2");
1741 CASE_OLD_ARG ('f', "fF");
1742 CASE_OLD_ARG ('h', "x2");
1743 CASE_OLD_ARG ('i', "d2");
1744 CASE_OLD_ARG ('l', "d4");
1745 CASE_OLD_ARG ('o', "o2");
1746 CASE_OLD_ARG ('x', "x2");
1751 width_specified = 1;
1758 s_err = xstrtoul (optarg, NULL, 10, &desired_width, "");
1759 if (s_err != LONGINT_OK)
1760 STRTOL_FATAL_ERROR (optarg, _("width specification"), s_err);
1770 if (n_failed_decodes > 0)
1771 exit (EXIT_FAILURE);
1775 printf ("od (%s) %s\n", GNU_PACKAGE, VERSION);
1776 exit (EXIT_SUCCESS);
1782 if (flag_dump_strings && n_specs > 0)
1783 error (EXIT_FAILURE, 0,
1784 _("no type may be specified when dumping strings"));
1786 n_files = argc - optind;
1788 /* If the --backward-compatible option is used, there may be from
1789 0 to 3 remaining command line arguments; handle each case
1791 od [file] [[+]offset[.][b] [[+]label[.][b]]]
1792 The offset and pseudo_start have the same syntax. */
1800 if ((offset = parse_old_offset (argv[optind])) >= 0)
1802 n_bytes_to_skip = offset;
1807 else if (n_files == 2)
1810 if ((o1 = parse_old_offset (argv[optind])) >= 0
1811 && (o2 = parse_old_offset (argv[optind + 1])) >= 0)
1813 n_bytes_to_skip = o1;
1814 flag_pseudo_start = 1;
1819 else if ((o2 = parse_old_offset (argv[optind + 1])) >= 0)
1821 n_bytes_to_skip = o2;
1823 argv[optind + 1] = argv[optind];
1829 _("invalid second operand in compatibility mode `%s'"),
1834 else if (n_files == 3)
1837 if ((o1 = parse_old_offset (argv[optind + 1])) >= 0
1838 && (o2 = parse_old_offset (argv[optind + 2])) >= 0)
1840 n_bytes_to_skip = o1;
1841 flag_pseudo_start = 1;
1843 argv[optind + 2] = argv[optind];
1850 _("in compatibility mode, the last two arguments must be offsets"));
1854 else if (n_files > 3)
1857 _("compatibility mode supports at most three arguments"));
1861 if (flag_pseudo_start)
1863 static char buf[10];
1865 if (output_address_fmt_string == NULL)
1867 output_address_fmt_string = "(%07o)";
1868 format_address = format_address_std;
1872 sprintf (buf, "%s (%s)",
1873 output_address_fmt_string,
1874 output_address_fmt_string);
1875 output_address_fmt_string = buf;
1876 format_address = format_address_label;
1881 assert (address_pad_len <= MAX_ADDRESS_LENGTH);
1882 for (i = 0; i < address_pad_len; i++)
1883 address_pad[i] = ' ';
1884 address_pad[address_pad_len] = '\0';
1888 if (decode_one_format ("o2", "o2", NULL, &(spec[0])))
1890 /* This happens on Cray systems that don't have a 2-byte
1892 exit (EXIT_FAILURE);
1899 file_list = (char const *const *) &argv[optind];
1902 /* If no files were listed on the command line, set up the
1903 global array FILE_LIST so that it contains the null-terminated
1904 list of one name: "-". */
1905 static char const *const default_file_list[] = {"-", NULL};
1907 file_list = default_file_list;
1910 err |= skip (n_bytes_to_skip);
1911 if (in_stream == NULL)
1914 pseudo_offset = (flag_pseudo_start ? pseudo_start - n_bytes_to_skip : 0);
1916 /* Compute output block length. */
1919 if (width_specified)
1921 if (desired_width != 0 && desired_width % l_c_m == 0)
1922 bytes_per_block = desired_width;
1925 error (0, 0, _("warning: invalid width %lu; using %d instead"),
1926 desired_width, l_c_m);
1927 bytes_per_block = l_c_m;
1932 if (l_c_m < DEFAULT_BYTES_PER_BLOCK)
1933 bytes_per_block = l_c_m * (int) (DEFAULT_BYTES_PER_BLOCK / l_c_m);
1935 bytes_per_block = l_c_m;
1939 for (i = 0; i < n_specs; i++)
1941 printf (_("%d: fmt=\"%s\" width=%d\n"),
1942 i, spec[i].fmt_string, width_bytes[spec[i].size]);
1946 err |= (flag_dump_strings ? dump_strings () : dump ());
1950 if (have_read_stdin && fclose (stdin) == EOF)
1951 error (EXIT_FAILURE, errno, _("standard input"));
1953 if (fclose (stdout) == EOF)
1954 error (EXIT_FAILURE, errno, _("write error"));
1956 exit (err == 0 ? EXIT_SUCCESS : EXIT_FAILURE);