1 /* od -- dump files in octal and other formats
2 Copyright (C) 1992 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
16 Foundation, Inc., 675 Mass Ave, Cambridge, MA 02139, USA. */
18 /* Written by Jim Meyering. */
20 /* AIX requires this to be the first thing in the file. */
22 #define alloca __builtin_alloca
23 #else /* not __GNUC__ */
26 #else /* not HAVE_ALLOCA_H */
32 #endif /* not HAVE_ALLOCA_H */
33 #endif /* not __GNUC__ */
38 #include <sys/types.h>
41 #if defined(__GNUC__) || defined(STDC_HEADERS)
46 typedef long double LONG_DOUBLE;
48 typedef double LONG_DOUBLE;
58 #define SCHAR_MIN (-128)
61 #define SHRT_MAX 32767
64 #define SHRT_MIN (-32768)
67 #define ULONG_MAX ((unsigned long) ~(unsigned long) 0)
70 #define STREQ(a,b) (strcmp((a), (b)) == 0)
73 #define MAX(a, b) ((a) > (b) ? (a) : (b))
77 #define MIN(a,b) (((a) < (b)) ? (a) : (b))
80 /* The default number of input bytes per output line. */
81 #define DEFAULT_BYTES_PER_BLOCK 16
83 /* The number of decimal digits of precision in a float. */
88 /* The number of decimal digits of precision in a double. */
93 /* The number of decimal digits of precision in a long double. */
95 #define LDBL_DIG DBL_DIG
127 UINT_OK, UINT_INVALID, UINT_INVALID_SUFFIX_CHAR, UINT_OVERFLOW
129 typedef enum strtoul_error strtoul_error;
131 /* Each output format specification (from POSIX `-t spec' or from
132 old-style options) is represented by one of these structures. */
135 enum output_format fmt;
137 void (*print_function) ();
141 /* Convert the number of 8-bit bytes of a binary representation to
142 the number of characters (digits + sign if the type is signed)
143 required to represent the same quantity in the specified base/type.
144 For example, a 32-bit (4-byte) quantity may require a field width
145 as wide as the following for these types:
149 8 unsigned hexadecimal */
151 static const unsigned int bytes_to_oct_digits[] =
152 {0, 3, 6, 8, 11, 14, 16, 19, 22, 25, 27, 30, 32, 35, 38, 41, 43};
154 static const unsigned int bytes_to_signed_dec_digits[] =
155 {1, 4, 6, 8, 11, 13, 16, 18, 20, 23, 25, 28, 30, 33, 35, 37, 40};
157 static const unsigned int bytes_to_unsigned_dec_digits[] =
158 {0, 3, 5, 8, 10, 13, 15, 17, 20, 22, 25, 27, 29, 32, 34, 37, 39};
160 static const unsigned int bytes_to_hex_digits[] =
161 {0, 2, 4, 6, 8, 10, 12, 14, 16, 18, 20, 22, 24, 26, 28, 30, 32};
163 /* Convert enum size_spec to the size of the named type. */
164 static const int width_bytes[] =
176 /* Names for some non-printing characters. */
177 static const char *const charname[33] =
179 "nul", "soh", "stx", "etx", "eot", "enq", "ack", "bel",
180 "bs", "ht", "nl", "vt", "ff", "cr", "so", "si",
181 "dle", "dc1", "dc2", "dc3", "dc4", "nak", "syn", "etb",
182 "can", "em", "sub", "esc", "fs", "gs", "rs", "us",
186 /* A printf control string for printing a file offset. */
187 static const char *output_address_fmt_string;
189 /* FIXME: make this the number of octal digits in an unsigned long. */
190 #define MAX_ADDRESS_LENGTH 13
192 /* Space for a normal address, a space, a pseudo address, parentheses
193 around the pseudo address, and a trailing zero byte. */
194 static char address_fmt_buffer[2 * MAX_ADDRESS_LENGTH + 4];
195 static char address_pad[MAX_ADDRESS_LENGTH + 1];
197 static unsigned long int string_min;
198 static unsigned long int flag_dump_strings;
200 /* Non-zero if we should recognize the pre-POSIX non-option arguments
201 that specified at most one file and optional arguments specifying
202 offset and pseudo-start address. */
203 static int flag_compatibility;
205 /* Non-zero if an old-style `pseudo-address' was specified. */
206 static long int flag_pseudo_start;
208 /* The difference between the old-style pseudo starting address and
209 the number of bytes to skip. */
210 static long int pseudo_offset;
212 /* Function to format an address and optionally an additional parenthesized
213 pseudo-address; it returns the formatted string. */
214 static const char *(*format_address) (/* long unsigned int */);
216 /* The number of input bytes to skip before formatting and writing. */
217 static unsigned long int n_bytes_to_skip = 0;
219 /* When non-zero, MAX_BYTES_TO_FORMAT is the maximum number of bytes
220 to be read and formatted. Otherwise all input is formatted. */
221 static int limit_bytes_to_format = 0;
223 /* The maximum number of bytes that will be formatted. This
224 value is used only when LIMIT_BYTES_TO_FORMAT is non-zero. */
225 static unsigned long int max_bytes_to_format;
227 /* When non-zero and two or more consecutive blocks are equal, format
228 only the first block and output an asterisk alone on the following
229 line to indicate that identical blocks have been elided. */
230 static int abbreviate_duplicate_blocks = 1;
232 /* An array of specs describing how to format each input block. */
233 static struct tspec *spec;
235 /* The number of format specs. */
236 static unsigned int n_specs;
238 /* The allocated length of SPEC. */
239 static unsigned int n_specs_allocated;
241 /* The number of input bytes formatted per output line. It must be
242 a multiple of the least common multiple of the sizes associated with
243 the specified output types. It should be as large as possible, but
244 no larger than 16 -- unless specified with the -w option. */
245 static unsigned int bytes_per_block;
247 /* Human-readable representation of *file_list (for error messages).
248 It differs from *file_list only when *file_list is "-". */
249 static char const *input_filename;
251 /* A NULL-terminated list of the file-arguments from the command line.
252 If no file-arguments were specified, this variable is initialized
254 static char const *const *file_list;
256 /* The input stream associated with the current file. */
257 static FILE *in_stream;
259 /* If non-zero, at least one of the files we read was standard input. */
260 static int have_read_stdin;
262 #define LONGEST_INTEGRAL_TYPE long int
264 #define MAX_INTEGRAL_TYPE_SIZE sizeof(LONGEST_INTEGRAL_TYPE)
265 static enum size_spec integral_type_size[MAX_INTEGRAL_TYPE_SIZE + 1];
267 #define MAX_FP_TYPE_SIZE sizeof(LONG_DOUBLE)
268 static enum size_spec fp_type_size[MAX_FP_TYPE_SIZE + 1];
270 static struct option const long_options[] =
273 {"skip-bytes", required_argument, NULL, 'j'},
274 {"address-radix", required_argument, NULL, 'A'},
275 {"read-bytes", required_argument, NULL, 'N'},
276 {"format", required_argument, NULL, 't'},
277 {"output-duplicates", no_argument, NULL, 'v'},
279 /* non-POSIX options. */
280 {"compatible", no_argument, NULL, 'C'},
281 {"strings", optional_argument, NULL, 's'},
282 {"width", optional_argument, NULL, 'w'},
286 /* The name this program was run with. */
293 Usage: %s [-abcdfhiloxv] [-s[bytes]] [-w[bytes]] [-A radix] [-j bytes]\n\
294 [-N bytes] [-t type] [--skip-bytes=bytes] [--address-radix=radix]\n\
295 [--read-bytes=bytes] [--format=type] [--output-duplicates]\n\
296 [--strings[=bytes]] [--width[=bytes]] [file...]\n",
301 /* Compute the greatest common denominator of U and V
302 using Euclid's algorithm. */
319 /* Compute the least common multiple of U and V. */
326 unsigned int t = gcd (u, v);
333 my_strtoul (s, base, val, allow_bkm_suffix)
336 long unsigned int *val;
337 int allow_bkm_suffix;
340 unsigned long int tmp;
342 assert (0 <= base && base <= 36);
344 tmp = strtoul (s, &p, base);
346 return UINT_OVERFLOW;
349 if (!allow_bkm_suffix)
357 return UINT_INVALID_SUFFIX_CHAR;
365 #define BKM_SCALE(x,scale_factor,error_return) \
368 if (x > (double) ULONG_MAX / scale_factor) \
369 return error_return; \
375 BKM_SCALE (tmp, 512, UINT_OVERFLOW);
379 BKM_SCALE (tmp, 1024, UINT_OVERFLOW);
383 BKM_SCALE (tmp, 1024 * 1024, UINT_OVERFLOW);
387 return UINT_INVALID_SUFFIX_CHAR;
396 uint_fatal_error (str, argument_type_string, err)
398 const char *argument_type_string;
407 error (2, 0, "invalid %s `%s'", argument_type_string, str);
410 case UINT_INVALID_SUFFIX_CHAR:
411 error (2, 0, "invalid character following %s `%s'",
412 argument_type_string, str);
416 error (2, 0, "%s `%s' larger than maximum unsigned long",
417 argument_type_string, str);
423 print_s_char (n_bytes, block, fmt_string)
424 long unsigned int n_bytes;
426 const char *fmt_string;
429 for (i = n_bytes; i > 0; i--)
431 int tmp = (unsigned) *(const unsigned char *) block;
433 tmp -= SCHAR_MAX - SCHAR_MIN + 1;
434 assert (tmp <= SCHAR_MAX);
435 printf (fmt_string, tmp, (i == 1 ? '\n' : ' '));
436 block += sizeof (unsigned char);
441 print_char (n_bytes, block, fmt_string)
442 long unsigned int n_bytes;
444 const char *fmt_string;
447 for (i = n_bytes; i > 0; i--)
449 unsigned int tmp = *(const unsigned char *) block;
450 printf (fmt_string, tmp, (i == 1 ? '\n' : ' '));
451 block += sizeof (unsigned char);
456 print_s_short (n_bytes, block, fmt_string)
457 long unsigned int n_bytes;
459 const char *fmt_string;
462 for (i = n_bytes / sizeof (unsigned short); i > 0; i--)
464 int tmp = (unsigned) *(const unsigned short *) block;
466 tmp -= SHRT_MAX - SHRT_MIN + 1;
467 assert (tmp <= SHRT_MAX);
468 printf (fmt_string, tmp, (i == 1 ? '\n' : ' '));
469 block += sizeof (unsigned short);
473 print_short (n_bytes, block, fmt_string)
474 long unsigned int n_bytes;
476 const char *fmt_string;
479 for (i = n_bytes / sizeof (unsigned short); i > 0; i--)
481 unsigned int tmp = *(const unsigned short *) block;
482 printf (fmt_string, tmp, (i == 1 ? '\n' : ' '));
483 block += sizeof (unsigned short);
488 print_int (n_bytes, block, fmt_string)
489 long unsigned int n_bytes;
491 const char *fmt_string;
494 for (i = n_bytes / sizeof (unsigned int); i > 0; i--)
496 unsigned int tmp = *(const unsigned int *) block;
497 printf (fmt_string, tmp, (i == 1 ? '\n' : ' '));
498 block += sizeof (unsigned int);
503 print_long (n_bytes, block, fmt_string)
504 long unsigned int n_bytes;
506 const char *fmt_string;
509 for (i = n_bytes / sizeof (unsigned long); i > 0; i--)
511 unsigned long tmp = *(const unsigned long *) block;
512 printf (fmt_string, tmp, (i == 1 ? '\n' : ' '));
513 block += sizeof (unsigned long);
518 print_float (n_bytes, block, fmt_string)
519 long unsigned int n_bytes;
521 const char *fmt_string;
524 for (i = n_bytes / sizeof (float); i > 0; i--)
526 float tmp = *(const float *) block;
527 printf (fmt_string, tmp, (i == 1 ? '\n' : ' '));
528 block += sizeof (float);
533 print_double (n_bytes, block, fmt_string)
534 long unsigned int n_bytes;
536 const char *fmt_string;
539 for (i = n_bytes / sizeof (double); i > 0; i--)
541 double tmp = *(const double *) block;
542 printf (fmt_string, tmp, (i == 1 ? '\n' : ' '));
543 block += sizeof (double);
549 print_long_double (n_bytes, block, fmt_string)
550 long unsigned int n_bytes;
552 const char *fmt_string;
555 for (i = n_bytes / sizeof (LONG_DOUBLE); i > 0; i--)
557 LONG_DOUBLE tmp = *(const LONG_DOUBLE *) block;
558 printf (fmt_string, tmp, (i == 1 ? '\n' : ' '));
559 block += sizeof (LONG_DOUBLE);
566 print_named_ascii (n_bytes, block, unused_fmt_string)
567 long unsigned int n_bytes;
569 const char *unused_fmt_string;
572 for (i = n_bytes; i > 0; i--)
574 unsigned int c = *(const unsigned char *) block;
575 unsigned int masked_c = (0x7f & c);
581 else if (masked_c <= 040)
582 s = charname[masked_c];
585 sprintf (buf, " %c", masked_c);
589 printf ("%3s%c", s, (i == 1 ? '\n' : ' '));
590 block += sizeof (unsigned char);
595 print_ascii (n_bytes, block, unused_fmt_string)
596 long unsigned int n_bytes;
598 const char *unused_fmt_string;
601 for (i = n_bytes; i > 0; i--)
603 unsigned int c = *(const unsigned char *) block;
642 sprintf (buf, (ISPRINT (c) ? " %c" : "%03o"), c);
643 s = (const char *) buf;
646 printf ("%3s%c", s, (i == 1 ? '\n' : ' '));
647 block += sizeof (unsigned char);
651 /* Convert a null-terminated (possibly zero-length) string S to an
652 unsigned long integer value. If S points to a non-digit set *P to S,
653 *VAL to 0, and return 0. Otherwise, accumulate the integer value of
654 the string of digits. If the string of digits represents a value
655 larger than ULONG_MAX, don't modify *VAL or *P and return non-zero.
656 Otherwise, advance *P to the first non-digit after S, set *VAL to
657 the result of the conversion and return zero. */
660 simple_strtoul (s, p, val)
663 long unsigned int *val;
665 unsigned long int sum;
670 unsigned int c = *s++ - '0';
671 if (sum > (ULONG_MAX - c) / 10)
680 /* If S points to a single valid POSIX-style od format string, put a
681 description of that format in *TSPEC, make *NEXT point at the character
682 following the just-decoded format (if *NEXT is non-NULL), and return
683 zero. If S is not valid, don't modify *NEXT or *TSPEC and return
684 non-zero. For example, if S were "d4afL" *NEXT would be set to "afL"
687 fmt = SIGNED_DECIMAL;
688 size = INT or LONG; (whichever integral_type_size[4] resolves to)
689 print_function = print_int; (assuming size == INT)
690 fmt_string = "%011d%c";
695 decode_one_format (s, next, tspec)
700 enum size_spec size_spec;
701 unsigned long int size;
702 enum output_format fmt;
703 const char *pre_fmt_string;
705 void (*print_function) ();
709 assert (tspec != NULL);
723 size = sizeof (char);
728 size = sizeof (short);
738 size = sizeof (long int);
742 if (simple_strtoul (s, &p, &size) != 0)
748 if (size > MAX_INTEGRAL_TYPE_SIZE
749 || integral_type_size[size] == NO_SIZE)
756 #define FMT_BYTES_ALLOCATED 9
757 fmt_string = xmalloc (FMT_BYTES_ALLOCATED);
759 size_spec = integral_type_size[size];
764 fmt = SIGNED_DECIMAL;
765 sprintf (fmt_string, "%%%u%sd%%c",
766 bytes_to_signed_dec_digits[size],
767 (size_spec == LONG ? "l" : ""));
772 sprintf (fmt_string, "%%0%u%so%%c",
773 bytes_to_oct_digits[size],
774 (size_spec == LONG ? "l" : ""));
778 fmt = UNSIGNED_DECIMAL;
779 sprintf (fmt_string, "%%%u%su%%c",
780 bytes_to_unsigned_dec_digits[size],
781 (size_spec == LONG ? "l" : ""));
786 sprintf (fmt_string, "%%0%u%sx%%c",
787 bytes_to_hex_digits[size],
788 (size_spec == LONG ? "l" : ""));
795 assert (strlen (fmt_string) < FMT_BYTES_ALLOCATED);
800 print_function = (fmt == SIGNED_DECIMAL
806 print_function = (fmt == SIGNED_DECIMAL
812 print_function = print_int;
816 print_function = print_long;
825 fmt = FLOATING_POINT;
831 size = sizeof (float);
836 size = sizeof (double);
841 size = sizeof (LONG_DOUBLE);
845 if (simple_strtoul (s, &p, &size) != 0)
848 size = sizeof (double);
851 if (size > MAX_FP_TYPE_SIZE
852 || fp_type_size[size] == NO_SIZE)
858 size_spec = fp_type_size[size];
863 print_function = print_float;
864 /* Don't use %#e; not all systems support it. */
865 pre_fmt_string = "%%%d.%de%%c";
866 fmt_string = xmalloc (strlen (pre_fmt_string));
867 sprintf (fmt_string, pre_fmt_string,
868 FLT_DIG + 8, FLT_DIG);
872 print_function = print_double;
873 pre_fmt_string = "%%%d.%de%%c";
874 fmt_string = xmalloc (strlen (pre_fmt_string));
875 sprintf (fmt_string, pre_fmt_string,
876 DBL_DIG + 8, DBL_DIG);
881 print_function = print_long_double;
882 pre_fmt_string = "%%%d.%dle%%c";
883 fmt_string = xmalloc (strlen (pre_fmt_string));
884 sprintf (fmt_string, pre_fmt_string,
885 LDBL_DIG + 8, LDBL_DIG);
896 fmt = NAMED_CHARACTER;
899 print_function = print_named_ascii;
907 print_function = print_ascii;
914 tspec->size = size_spec;
916 tspec->print_function = print_function;
917 tspec->fmt_string = fmt_string;
925 /* Decode the POSIX-style od format string S. Append the decoded
926 representation to the global array SPEC, reallocating SPEC if
927 necessary. Return zero if S is valid, non-zero otherwise. */
930 decode_format_string (s)
940 if (decode_one_format (s, &next, &tspec))
946 if (n_specs >= n_specs_allocated)
948 n_specs_allocated = 1 + (3 * n_specs_allocated) / 2;
949 spec = (struct tspec *) xrealloc (spec, (n_specs_allocated
950 * sizeof (struct tspec)));
953 bcopy ((char *) &tspec, (char *) &spec[n_specs], sizeof (struct tspec));
960 /* Given a list of one or more input filenames FILE_LIST, set the global
961 file pointer IN_STREAM to position N_SKIP in the concatenation of
962 those files. If any file operation fails or if there are fewer than
963 N_SKIP bytes in the combined input, give an error message and exit.
964 When possible, use seek- rather than read operations to advance
965 IN_STREAM. A file name of "-" is interpreted as standard input. */
969 long unsigned int n_skip;
974 for ( /* empty */ ; *file_list != NULL; ++file_list)
976 struct stat file_stats;
979 if (STREQ (*file_list, "-"))
981 input_filename = "standard input";
987 input_filename = *file_list;
988 in_stream = fopen (input_filename, "r");
989 if (in_stream == NULL)
991 error (0, errno, "%s", input_filename);
1000 /* First try using fseek. For large offsets, this extra work is
1001 worthwhile. If the offset is below some threshold it may be
1002 more efficient to move the pointer by reading. There are two
1003 issues when trying to use fseek:
1004 - the file must be seekable.
1005 - before seeking to the specified position, make sure
1006 that the new position is in the current file.
1007 Try to do that by getting file's size using stat().
1008 But that will work only for regular files and dirs. */
1010 if (fstat (fileno (in_stream), &file_stats))
1012 error (0, errno, "%s", input_filename);
1017 /* The st_size field is valid only for regular files and
1018 directories. FIXME: is the preceding true?
1019 If the number of bytes left to skip is at least as large as
1020 the size of the current file, we can decrement
1021 n_skip and go on to the next file. */
1022 if (S_ISREG (file_stats.st_mode) || S_ISDIR (file_stats.st_mode))
1024 if (n_skip >= file_stats.st_size)
1026 n_skip -= file_stats.st_size;
1027 if (in_stream != stdin && fclose (in_stream) == EOF)
1029 error (0, errno, "%s", input_filename);
1036 if (fseek (in_stream, n_skip, SEEK_SET) == 0)
1044 /* fseek didn't work or wasn't attempted; do it the slow way. */
1046 for (j = n_skip / BUFSIZ; j >= 0; j--)
1049 size_t n_bytes_to_read = (j > 0
1052 size_t n_bytes_read;
1053 n_bytes_read = fread (buf, 1, n_bytes_to_read, in_stream);
1054 n_skip -= n_bytes_read;
1055 if (n_bytes_read != n_bytes_to_read)
1064 error (2, 0, "cannot skip past end of combined input");
1070 format_address_none (address)
1071 long unsigned int address;
1077 format_address_std (address)
1078 long unsigned int address;
1080 const char *address_string;
1082 sprintf (address_fmt_buffer, output_address_fmt_string, address);
1083 address_string = address_fmt_buffer;
1084 return address_string;
1088 format_address_label (address)
1089 long unsigned int address;
1091 const char *address_string;
1092 assert (output_address_fmt_string != NULL);
1094 sprintf (address_fmt_buffer, output_address_fmt_string,
1095 address, address + pseudo_offset);
1096 address_string = address_fmt_buffer;
1097 return address_string;
1100 /* Write N_BYTES bytes from CURR_BLOCK to standard output once for each
1101 of the N_SPEC format specs. CURRENT_OFFSET is the byte address of
1102 CURR_BLOCK in the concatenation of input files, and it is printed
1103 (optionally) only before the output line associated with the first
1104 format spec. When duplicate blocks are being abbreviated, the output
1105 for a sequence of identical input blocks is the output for the first
1106 block followed by an asterisk alone on a line. It is valid to compare
1107 the blocks PREV_BLOCK and CURR_BLOCK only when N_BYTES == BYTES_PER_BLOCK.
1108 That condition may be false only for the last input block -- and then
1109 only when it has not been padded to length BYTES_PER_BLOCK. */
1112 write_block (current_offset, n_bytes, prev_block, curr_block)
1113 long unsigned int current_offset;
1114 long unsigned int n_bytes;
1115 const char *prev_block;
1116 const char *curr_block;
1118 static int first = 1;
1119 static int prev_pair_equal = 0;
1121 #define EQUAL_BLOCKS(b1, b2) (bcmp ((b1), (b2), bytes_per_block) == 0)
1123 if (abbreviate_duplicate_blocks
1124 && !first && n_bytes == bytes_per_block
1125 && EQUAL_BLOCKS (prev_block, curr_block))
1127 if (prev_pair_equal)
1129 /* The two preceding blocks were equal, and the current
1130 block is the same as the last one, so print nothing. */
1135 prev_pair_equal = 1;
1142 prev_pair_equal = 0;
1143 for (i = 0; i < n_specs; i++)
1145 printf ("%s ", (i == 0
1146 ? format_address (current_offset)
1148 (*spec[i].print_function) (n_bytes, curr_block, spec[i].fmt_string);
1154 /* Test whether there have been errors on in_stream, and close it if
1155 it is not standard input. Return non-zero if there has been an error
1156 on in_stream or stdout; return zero otherwise. This function will
1157 report more than one error only if both a read and a write error
1166 if (ferror (in_stream))
1168 error (0, errno, "%s", input_filename);
1169 if (in_stream != stdin)
1173 else if (in_stream != stdin && fclose (in_stream) == EOF)
1175 error (0, errno, "%s", input_filename);
1179 if (ferror (stdout))
1181 error (0, errno, "standard output");
1188 /* Read a single byte into *C from the concatenation of the input files
1189 named in the global array FILE_LIST. On the first call to this
1190 function, the global variable IN_STREAM is expected to be an open
1191 stream associated with the input file *FILE_LIST. If IN_STREAM is
1192 at end-of-file, close it and update the global variables IN_STREAM,
1193 FILE_LIST, and INPUT_FILENAME so they correspond to the next file in
1194 the list. Then try to read a byte from the newly opened file.
1195 Repeat if necessary until *FILE_LIST is NULL. When EOF is reached
1196 for the last file in FILE_LIST, set *C to EOF and return. Subsequent
1197 calls do likewise. The return value is non-zero if any errors
1198 occured, zero otherwise. */
1206 if (*file_list == NULL)
1215 *c = fgetc (in_stream);
1220 err |= check_and_close ();
1225 if (*file_list == NULL)
1228 if (STREQ (*file_list, "-"))
1230 input_filename = "standard input";
1232 have_read_stdin = 1;
1236 input_filename = *file_list;
1237 in_stream = fopen (input_filename, "r");
1238 if (in_stream == NULL)
1240 error (0, errno, "%s", input_filename);
1245 while (in_stream == NULL);
1249 /* Read N bytes into BLOCK from the concatenation of the input files
1250 named in the global array FILE_LIST. On the first call to this
1251 function, the global variable IN_STREAM is expected to be an open
1252 stream associated with the input file *FILE_LIST. On subsequent
1253 calls, if *FILE_LIST is NULL, don't modify BLOCK and return zero.
1254 If all N bytes cannot be read from IN_STREAM, close IN_STREAM and
1255 update the global variables IN_STREAM, FILE_LIST, and INPUT_FILENAME.
1256 Then try to read the remaining bytes from the newly opened file.
1257 Repeat if necessary until *FILE_LIST is NULL. Set *N_BYTES_IN_BUFFER
1258 to the number of bytes read. If an error occurs, it will be detected
1259 through ferror when the stream is about to be closed. If there is an
1260 error, give a message but continue reading as usual and return non-zero.
1261 Otherwise return zero. */
1264 read_block (n, block, n_bytes_in_buffer)
1267 size_t *n_bytes_in_buffer;
1271 assert (n > 0 && n <= bytes_per_block);
1273 *n_bytes_in_buffer = 0;
1278 if (*file_list == NULL)
1279 return 0; /* EOF. */
1287 n_needed = n - *n_bytes_in_buffer;
1288 n_read = fread (block + *n_bytes_in_buffer, 1, n_needed, in_stream);
1290 *n_bytes_in_buffer += n_read;
1292 if (n_read == n_needed)
1295 err |= check_and_close ();
1300 if (*file_list == NULL)
1303 if (STREQ (*file_list, "-"))
1305 input_filename = "standard input";
1307 have_read_stdin = 1;
1311 input_filename = *file_list;
1312 in_stream = fopen (input_filename, "r");
1313 if (in_stream == NULL)
1315 error (0, errno, "%s", input_filename);
1320 while (in_stream == NULL);
1324 /* Return the least common multiple of the sizes associated
1325 with the format specs. */
1333 for (i = 0; i < n_specs; i++)
1334 l_c_m = lcm (l_c_m, width_bytes[(int) spec[i].size]);
1338 /* If S is a valid pre-POSIX offset specification with an optional leading '+'
1339 return the offset it denotes. Otherwise, return -1. */
1342 parse_old_offset (const char *s)
1351 /* Skip over any leading '+'. */
1355 /* Determine the radix we'll use to interpret S. If there is a `.',
1356 it's decimal, otherwise, if the string begins with `0x', it's
1357 hexadecimal, else octal. */
1358 if (index (s, '.') != NULL)
1362 if (strlen (s) >= 2 && s[0] == '0' && (s[1] == 'x' || s[1] == 'X'))
1367 offset = strtoul (s, &suffix, radix);
1368 if (suffix == s || errno != 0)
1375 BKM_SCALE (offset, 512, -1);
1380 BKM_SCALE (offset, 1024, -1);
1389 if (*suffix != '\0')
1395 /* Read a chunk of size BYTES_PER_BLOCK from the input files, write the
1396 formatted block to standard output, and repeat until the specified
1397 maximum number of bytes has been read or until all input has been
1398 processed. If the last block read is smaller than BYTES_PER_BLOCK
1399 and its size is not a multiple of the size associated with a format
1400 spec, extend the input block with zero bytes until its length is a
1401 multiple of all format spec sizes. Write the final block. Finally,
1402 write on a line by itself the offset of the byte after the last byte
1403 read. Accumulate return values from calls to read_block and
1404 check_and_close, and if any was non-zero, return non-zero.
1405 Otherwise, return zero. */
1411 unsigned long int current_offset;
1414 size_t n_bytes_read;
1417 block[0] = (char *) alloca (bytes_per_block);
1418 block[1] = (char *) alloca (bytes_per_block);
1420 current_offset = n_bytes_to_skip;
1424 if (limit_bytes_to_format)
1426 end_offset = n_bytes_to_skip + max_bytes_to_format;
1429 while (current_offset < end_offset)
1432 n_needed = MIN (end_offset - current_offset, bytes_per_block);
1433 err |= read_block (n_needed, block[idx], &n_bytes_read);
1434 if (n_bytes_read < bytes_per_block)
1436 assert (n_bytes_read == bytes_per_block);
1437 write_block (current_offset, n_bytes_read,
1438 block[!idx], block[idx]);
1439 current_offset += n_bytes_read;
1447 err |= read_block (bytes_per_block, block[idx], &n_bytes_read);
1448 if (n_bytes_read < bytes_per_block)
1450 assert (n_bytes_read == bytes_per_block);
1451 write_block (current_offset, n_bytes_read,
1452 block[!idx], block[idx]);
1453 current_offset += n_bytes_read;
1458 if (n_bytes_read > 0)
1461 size_t bytes_to_write;
1465 /* Make bytes_to_write the smallest multiple of l_c_m that
1466 is at least as large as n_bytes_read. */
1467 bytes_to_write = l_c_m * (int) ((n_bytes_read + l_c_m - 1) / l_c_m);
1469 bzero (block[idx] + n_bytes_read, bytes_to_write - n_bytes_read);
1470 write_block (current_offset, bytes_to_write,
1471 block[!idx], block[idx]);
1472 current_offset += n_bytes_read;
1475 if (output_address_fmt_string != NULL)
1476 printf ("%s\n", format_address (current_offset));
1478 if (limit_bytes_to_format && current_offset > end_offset)
1479 err |= check_and_close ();
1484 /* STRINGS mode. Find each "string constant" in the input.
1485 A string constant is a run of at least `string_min' ASCII
1486 graphic (or formatting) characters terminated by a null.
1487 Based on a function written by Richard Stallman for a
1488 pre-POSIX version of od. Return non-zero if an error
1489 occurs. Otherwise, return zero. */
1494 int bufsize = MAX (100, string_min);
1495 char *buf = xmalloc (bufsize);
1496 unsigned long address = n_bytes_to_skip;
1505 /* See if the next `string_min' chars are all printing chars. */
1508 if (limit_bytes_to_format
1509 && address >= (n_bytes_to_skip + max_bytes_to_format - string_min))
1512 for (i = 0; i < string_min; i++)
1514 err |= read_char (&c);
1522 /* Found a non-printing. Try again starting with next char. */
1527 /* We found a run of `string_min' printable characters.
1528 Now see if it is terminated with a null byte. */
1529 while (!limit_bytes_to_format
1530 || address < n_bytes_to_skip + max_bytes_to_format)
1534 bufsize = 1 + 3 * bufsize / 2;
1535 buf = xrealloc (buf, bufsize);
1537 err |= read_char (&c);
1545 break; /* It is; print this string. */
1547 goto tryline; /* It isn't; give up on this string. */
1548 buf[i++] = c; /* String continues; store it all. */
1551 /* If we get here, the string is all printable and null-terminated,
1552 so print it. It is all in `buf' and `i' is its length. */
1554 if (output_address_fmt_string != NULL)
1556 printf ("%s ", format_address (address - i - 1));
1558 for (i = 0; (c = buf[i]); i++)
1563 fputs ("\\a", stdout);
1567 fputs ("\\b", stdout);
1571 fputs ("\\f", stdout);
1575 fputs ("\\n", stdout);
1579 fputs ("\\r", stdout);
1583 fputs ("\\t", stdout);
1587 fputs ("\\v", stdout);
1597 /* We reach this point only if we search through
1598 (max_bytes_to_format - string_min) bytes before reachine EOF. */
1602 err |= check_and_close ();
1615 unsigned int address_pad_len;
1616 unsigned long int desired_width;
1617 int width_specified = 0;
1620 /* The old-style `pseudo starting address' to be printed in parentheses
1621 after any true address. */
1622 long int pseudo_start;
1624 program_name = argv[0];
1627 for (i = 0; i <= MAX_INTEGRAL_TYPE_SIZE; i++)
1628 integral_type_size[i] = NO_SIZE;
1630 integral_type_size[sizeof (char)] = CHAR;
1631 integral_type_size[sizeof (short int)] = SHORT;
1632 integral_type_size[sizeof (int)] = INT;
1633 integral_type_size[sizeof (long int)] = LONG;
1635 for (i = 0; i <= MAX_FP_TYPE_SIZE; i++)
1636 fp_type_size[i] = NO_SIZE;
1638 fp_type_size[sizeof (float)] = FP_SINGLE;
1639 /* The array entry for `double' is filled in after that for LONG_DOUBLE
1640 so that if `long double' is the same type or if long double isn't
1641 supported FP_LONG_DOUBLE will never be used. */
1642 fp_type_size[sizeof (LONG_DOUBLE)] = FP_LONG_DOUBLE;
1643 fp_type_size[sizeof (double)] = FP_DOUBLE;
1646 n_specs_allocated = 5;
1647 spec = (struct tspec *) xmalloc (n_specs_allocated * sizeof (struct tspec));
1649 output_address_fmt_string = "%07o";
1650 format_address = format_address_std;
1651 address_pad_len = 7;
1652 flag_dump_strings = 0;
1654 while ((c = getopt_long (argc, argv, "abcCdfhilos::xw::A:j:N:t:v",
1655 long_options, (int *) 0))
1658 strtoul_error s_err;
1666 output_address_fmt_string = "%07d";
1667 format_address = format_address_std;
1668 address_pad_len = 7;
1671 output_address_fmt_string = "%07o";
1672 format_address = format_address_std;
1673 address_pad_len = 7;
1676 output_address_fmt_string = "%06x";
1677 format_address = format_address_std;
1678 address_pad_len = 6;
1681 output_address_fmt_string = NULL;
1682 format_address = format_address_none;
1683 address_pad_len = 0;
1687 "invalid output address radix `%c'; it must be one character from [doxn]",
1694 s_err = my_strtoul (optarg, 0, &n_bytes_to_skip, 1);
1695 if (s_err != UINT_OK)
1696 uint_fatal_error (optarg, "skip argument", s_err);
1700 limit_bytes_to_format = 1;
1702 s_err = my_strtoul (optarg, 0, &max_bytes_to_format, 1);
1703 if (s_err != UINT_OK)
1704 uint_fatal_error (optarg, "limit argument", s_err);
1712 s_err = my_strtoul (optarg, 0, &string_min, 1);
1713 if (s_err != UINT_OK)
1714 uint_fatal_error (optarg, "minimum string length", s_err);
1716 ++flag_dump_strings;
1720 if (decode_format_string (optarg))
1721 error (2, 0, "invalid type string `%s'", optarg);
1725 abbreviate_duplicate_blocks = 0;
1729 flag_compatibility = 1;
1732 /* The next several cases map the old, pre-POSIX format
1733 specification options to the corresponding POSIX format
1734 specs. GNU od accepts any combination of old- and
1735 new-style options. Format specification options accumulate. */
1737 #define CASE_OLD_ARG(old_char,new_string) \
1741 tmp = decode_format_string (new_string); \
1742 assert (tmp == 0); \
1746 CASE_OLD_ARG ('a', "a");
1747 CASE_OLD_ARG ('b', "oC");
1748 CASE_OLD_ARG ('c', "c");
1749 CASE_OLD_ARG ('d', "u2");
1750 CASE_OLD_ARG ('f', "fF");
1751 CASE_OLD_ARG ('h', "x2");
1752 CASE_OLD_ARG ('i', "d2");
1753 CASE_OLD_ARG ('l', "d4");
1754 CASE_OLD_ARG ('o', "o2");
1755 CASE_OLD_ARG ('x', "x2");
1760 width_specified = 1;
1767 s_err = my_strtoul (optarg, 10, &desired_width, 0);
1768 if (s_err != UINT_OK)
1769 error (2, 0, "invalid width specification `%s'", optarg);
1779 if (flag_dump_strings && n_specs > 0)
1780 error (2, 0, "no type may be specified when dumping strings");
1782 n_files = argc - optind;
1784 /* If the --compatible option is used, there may be from 0 to 3
1785 remaining command line arguments; handle each case separately.
1786 od [file] [[+]offset[.][b] [[+]label[.][b]]]
1787 The offset and pseudo_start have the same syntax. */
1789 if (flag_compatibility)
1792 int usage_error = 0;
1796 if ((offset = parse_old_offset (argv[optind])) >= 0)
1798 n_bytes_to_skip = offset;
1803 else if (n_files == 2)
1806 if ((o1 = parse_old_offset (argv[optind])) >= 0
1807 && (o2 = parse_old_offset (argv[optind + 1])) >= 0)
1809 n_bytes_to_skip = o1;
1810 flag_pseudo_start = 1;
1815 else if ((o2 = parse_old_offset (argv[optind + 1])) >= 0)
1817 n_bytes_to_skip = o2;
1819 argv[optind + 1] = argv[optind];
1826 "invalid second operand in compatibility mode `%s'",
1831 else if (n_files == 3)
1834 if ((o1 = parse_old_offset (argv[optind + 1])) >= 0
1835 && (o2 = parse_old_offset (argv[optind + 2])) >= 0)
1837 n_bytes_to_skip = o1;
1838 flag_pseudo_start = 1;
1840 argv[optind + 2] = argv[optind];
1847 "in compatibility mode the last 2 arguments must be offsets");
1854 "in compatibility mode there may be no more than 3 arguments");
1858 if (flag_pseudo_start)
1860 static char buf[10];
1862 if (output_address_fmt_string == NULL)
1864 output_address_fmt_string = "(%07o)";
1865 format_address = format_address_std;
1869 sprintf (buf, "%s (%s)",
1870 output_address_fmt_string,
1871 output_address_fmt_string);
1872 output_address_fmt_string = buf;
1873 format_address = format_address_label;
1878 assert (address_pad_len <= MAX_ADDRESS_LENGTH);
1879 for (i = 0; i < address_pad_len; i++)
1880 address_pad[i] = ' ';
1881 address_pad[address_pad_len] = '\0';
1885 int d_err = decode_one_format ("o2", NULL, &(spec[0]));
1887 assert (d_err == 0);
1892 file_list = (char const *const *) &argv[optind];
1895 /* If no files were listed on the command line, set up the
1896 global array FILE_LIST so that it contains the null-terminated
1897 list of one name: "-". */
1898 static char const *const default_file_list[] = {"-", NULL};
1900 file_list = default_file_list;
1903 err |= skip (n_bytes_to_skip);
1905 pseudo_offset = (flag_pseudo_start ? pseudo_start - n_bytes_to_skip : 0);
1907 /* Compute output block length. */
1910 if (width_specified)
1912 if (desired_width != 0 && desired_width % l_c_m == 0)
1913 bytes_per_block = desired_width;
1916 error (0, 0, "warning: invalid width %d; using %d instead",
1917 desired_width, l_c_m);
1918 bytes_per_block = l_c_m;
1923 if (l_c_m < DEFAULT_BYTES_PER_BLOCK)
1924 bytes_per_block = l_c_m * (int) (DEFAULT_BYTES_PER_BLOCK / l_c_m);
1926 bytes_per_block = l_c_m;
1930 for (i = 0; i < n_specs; i++)
1932 printf ("%d: fmt=\"%s\" width=%d\n",
1933 i, spec[i].fmt_string, width_bytes[spec[i].size]);
1937 err |= (flag_dump_strings ? dump_strings () : dump ());
1939 if (have_read_stdin && fclose (stdin) == EOF)
1940 error (2, errno, "standard input");
1942 if (fclose (stdout) == EOF)
1943 error (2, errno, "write error");