1 /* od -- dump files in octal and other formats
2 Copyright (C) 92, 1995-2001 Free Software Foundation, Inc.
4 This program is free software; you can redistribute it and/or modify
5 it under the terms of the GNU General Public License as published by
6 the Free Software Foundation; either version 2, or (at your option)
9 This program is distributed in the hope that it will be useful,
10 but WITHOUT ANY WARRANTY; without even the implied warranty of
11 MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
12 GNU General Public License for more details.
14 You should have received a copy of the GNU General Public License
15 along with this program; if not, write to the Free Software Foundation,
16 Inc., 59 Temple Place - Suite 330, Boston, MA 02111-1307, USA. */
18 /* Written by Jim Meyering. */
25 #include <sys/types.h>
31 /* The official name of this program (e.g., no `g' prefix). */
32 #define PROGRAM_NAME "od"
34 #define AUTHORS "Jim Meyering"
36 #if defined(__GNUC__) || defined(STDC_HEADERS)
40 #ifdef HAVE_LONG_DOUBLE
41 typedef long double LONG_DOUBLE;
43 typedef double LONG_DOUBLE;
50 /* The default number of input bytes per output line. */
51 #define DEFAULT_BYTES_PER_BLOCK 16
53 /* The number of decimal digits of precision in a float. */
58 /* The number of decimal digits of precision in a double. */
63 /* The number of decimal digits of precision in a long double. */
65 # define LDBL_DIG DBL_DIG
76 /* FIXME: add INTMAX support, too */
93 /* Each output format specification (from POSIX `-t spec' or from
94 old-style options) is represented by one of these structures. */
97 enum output_format fmt;
99 void (*print_function) ();
101 int hexl_mode_trailer;
105 /* The name this program was run with. */
108 /* Convert the number of 8-bit bytes of a binary representation to
109 the number of characters (digits + sign if the type is signed)
110 required to represent the same quantity in the specified base/type.
111 For example, a 32-bit (4-byte) quantity may require a field width
112 as wide as the following for these types:
116 8 unsigned hexadecimal */
118 static const unsigned int bytes_to_oct_digits[] =
119 {0, 3, 6, 8, 11, 14, 16, 19, 22, 25, 27, 30, 32, 35, 38, 41, 43};
121 static const unsigned int bytes_to_signed_dec_digits[] =
122 {1, 4, 6, 8, 11, 13, 16, 18, 20, 23, 25, 28, 30, 33, 35, 37, 40};
124 static const unsigned int bytes_to_unsigned_dec_digits[] =
125 {0, 3, 5, 8, 10, 13, 15, 17, 20, 22, 25, 27, 29, 32, 34, 37, 39};
127 static const unsigned int bytes_to_hex_digits[] =
128 {0, 2, 4, 6, 8, 10, 12, 14, 16, 18, 20, 22, 24, 26, 28, 30, 32};
130 /* Convert enum size_spec to the size of the named type. */
131 static const int width_bytes[] =
143 /* Names for some non-printing characters. */
144 static const char *const charname[33] =
146 "nul", "soh", "stx", "etx", "eot", "enq", "ack", "bel",
147 "bs", "ht", "nl", "vt", "ff", "cr", "so", "si",
148 "dle", "dc1", "dc2", "dc3", "dc4", "nak", "syn", "etb",
149 "can", "em", "sub", "esc", "fs", "gs", "rs", "us",
153 /* Address base (8, 10 or 16). */
154 static int address_base;
156 /* The number of octal digits required to represent the largest
158 #define MAX_ADDRESS_LENGTH \
159 ((sizeof (uintmax_t) * CHAR_BIT + CHAR_BIT - 1) / 3)
161 /* Width of a normal address. */
162 static int address_pad_len;
164 static size_t string_min;
165 static int flag_dump_strings;
167 /* Non-zero if we should recognize the pre-POSIX non-option arguments
168 that specified at most one file and optional arguments specifying
169 offset and pseudo-start address. */
170 static int traditional;
172 /* Non-zero if an old-style `pseudo-address' was specified. */
173 static int flag_pseudo_start;
175 /* The difference between the old-style pseudo starting address and
176 the number of bytes to skip. */
177 static uintmax_t pseudo_offset;
179 /* Function that accepts an address and an optional following char,
180 and prints the address and char to stdout. */
181 static void (*format_address) PARAMS ((uintmax_t, char));
183 /* The number of input bytes to skip before formatting and writing. */
184 static uintmax_t n_bytes_to_skip = 0;
186 /* When zero, MAX_BYTES_TO_FORMAT and END_OFFSET are ignored, and all
187 input is formatted. */
188 static int limit_bytes_to_format = 0;
190 /* The maximum number of bytes that will be formatted. */
191 static uintmax_t max_bytes_to_format;
193 /* The offset of the first byte after the last byte to be formatted. */
194 static uintmax_t end_offset;
196 /* When nonzero and two or more consecutive blocks are equal, format
197 only the first block and output an asterisk alone on the following
198 line to indicate that identical blocks have been elided. */
199 static int abbreviate_duplicate_blocks = 1;
201 /* An array of specs describing how to format each input block. */
202 static struct tspec *spec;
204 /* The number of format specs. */
205 static size_t n_specs;
207 /* The allocated length of SPEC. */
208 static size_t n_specs_allocated;
210 /* The number of input bytes formatted per output line. It must be
211 a multiple of the least common multiple of the sizes associated with
212 the specified output types. It should be as large as possible, but
213 no larger than 16 -- unless specified with the -w option. */
214 static size_t bytes_per_block;
216 /* Human-readable representation of *file_list (for error messages).
217 It differs from *file_list only when *file_list is "-". */
218 static char const *input_filename;
220 /* A NULL-terminated list of the file-arguments from the command line. */
221 static char const *const *file_list;
223 /* Initializer for file_list if no file-arguments
224 were specified on the command line. */
225 static char const *const default_file_list[] = {"-", NULL};
227 /* The input stream associated with the current file. */
228 static FILE *in_stream;
230 /* If nonzero, at least one of the files we read was standard input. */
231 static int have_read_stdin;
233 #if HAVE_UNSIGNED_LONG_LONG
234 typedef unsigned long long ulonglong_t;
236 /* This is just a place-holder to avoid a few `#if' directives.
237 In this case, the type isn't actually used. */
238 typedef unsigned long int ulonglong_t;
241 #define MAX_INTEGRAL_TYPE_SIZE sizeof (ulonglong_t)
242 static enum size_spec integral_type_size[MAX_INTEGRAL_TYPE_SIZE + 1];
244 #define MAX_FP_TYPE_SIZE sizeof(LONG_DOUBLE)
245 static enum size_spec fp_type_size[MAX_FP_TYPE_SIZE + 1];
247 static struct option const long_options[] =
250 {"skip-bytes", required_argument, NULL, 'j'},
251 {"address-radix", required_argument, NULL, 'A'},
252 {"read-bytes", required_argument, NULL, 'N'},
253 {"format", required_argument, NULL, 't'},
254 {"output-duplicates", no_argument, NULL, 'v'},
256 /* non-POSIX options. */
257 {"strings", optional_argument, NULL, 's'},
258 {"traditional", no_argument, NULL, 'B'},
259 {"width", optional_argument, NULL, 'w'},
261 {GETOPT_HELP_OPTION_DECL},
262 {GETOPT_VERSION_OPTION_DECL},
270 fprintf (stderr, _("Try `%s --help' for more information.\n"),
275 Usage: %s [OPTION]... [FILE]...\n\
276 or: %s --traditional [FILE] [[+]OFFSET [[+]LABEL]]\n\
278 program_name, program_name);
280 Write an unambiguous representation, octal bytes by default,\n\
281 of FILE to standard output. With more than one FILE argument,\n\
282 concatenate them in the listed order to form the input.\n\
283 With no FILE, or when FILE is -, read standard input.\n\
285 -A, --address-radix=RADIX decide how file offsets are printed\n\
286 -j, --skip-bytes=BYTES skip BYTES input bytes first\n\
287 -N, --read-bytes=BYTES limit dump to BYTES input bytes\n\
288 -s, --strings[=BYTES] output strings of at least BYTES graphic chars\n\
289 -t, --format=TYPE select output format or formats\n\
290 -v, --output-duplicates do not use * to mark line suppression\n\
291 -w, --width[=BYTES] output BYTES bytes per output line\n\
292 --traditional accept arguments in pre-POSIX form\n\
293 --help display this help and exit\n\
294 --version output version information and exit\n\
296 Pre-POSIX format specifications may be intermixed, they accumulate:\n\
297 -a same as -t a, select named characters\n\
298 -b same as -t oC, select octal bytes\n\
299 -c same as -t c, select ASCII characters or backslash escapes\n\
300 -d same as -t u2, select unsigned decimal shorts\n\
301 -f same as -t fF, select floats\n\
302 -h same as -t x2, select hexadecimal shorts\n\
303 -i same as -t d2, select decimal shorts\n\
304 -l same as -t d4, select decimal longs\n\
305 -o same as -t o2, select octal shorts\n\
306 -x same as -t x2, select hexadecimal shorts\n\
310 For older syntax (second call format), OFFSET means -j OFFSET. LABEL\n\
311 is the pseudo-address at first byte printed, incremented when dump is\n\
312 progressing. For OFFSET and LABEL, a 0x or 0X prefix indicates\n\
313 hexadecimal, suffixes maybe . for octal and b multiply by 512.\n\
315 TYPE is made up of one or more of these specifications:\n\
318 c ASCII character or backslash escape\n\
319 d[SIZE] signed decimal, SIZE bytes per integer\n\
320 f[SIZE] floating point, SIZE bytes per integer\n\
321 o[SIZE] octal, SIZE bytes per integer\n\
322 u[SIZE] unsigned decimal, SIZE bytes per integer\n\
323 x[SIZE] hexadecimal, SIZE bytes per integer\n\
325 SIZE is a number. For TYPE in doux, SIZE may also be C for\n\
326 sizeof(char), S for sizeof(short), I for sizeof(int) or L for\n\
327 sizeof(long). If TYPE is f, SIZE may also be F for sizeof(float), D\n\
328 for sizeof(double) or L for sizeof(long double).\n\
330 RADIX is d for decimal, o for octal, x for hexadecimal or n for none.\n\
331 BYTES is hexadecimal with 0x or 0X prefix, it is multiplied by 512\n\
332 with b suffix, by 1024 with k and by 1048576 with m. Adding a z suffix to\n\
333 any type adds a display of printable characters to the end of each line\n\
334 of output. -s without a number implies 3. -w without a number implies 32.\n\
335 By default, od uses -A o -t d2 -w 16.\n\
337 puts (_("\nReport bugs to <bug-textutils@gnu.org>."));
339 exit (status == 0 ? EXIT_SUCCESS : EXIT_FAILURE);
342 /* Compute the greatest common denominator of U and V
343 using Euclid's algorithm. */
346 gcd (unsigned int u, unsigned int v)
358 /* Compute the least common multiple of U and V. */
361 lcm (unsigned int u, unsigned int v)
363 unsigned int t = gcd (u, v);
370 print_s_char (size_t n_bytes, const char *block, 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 (size_t n_bytes, const char *block, const char *fmt_string)
388 for (i = n_bytes; i > 0; i--)
390 unsigned int tmp = *(const unsigned char *) block;
391 printf (fmt_string, tmp);
392 block += sizeof (unsigned char);
397 print_s_short (size_t n_bytes, const char *block, const char *fmt_string)
400 for (i = n_bytes / sizeof (unsigned short); i > 0; i--)
402 int tmp = (unsigned) *(const unsigned short *) block;
404 tmp -= SHRT_MAX - SHRT_MIN + 1;
405 assert (tmp <= SHRT_MAX);
406 printf (fmt_string, tmp);
407 block += sizeof (unsigned short);
412 print_short (size_t n_bytes, const char *block, const char *fmt_string)
415 for (i = n_bytes / sizeof (unsigned short); i > 0; i--)
417 unsigned int tmp = *(const unsigned short *) block;
418 printf (fmt_string, tmp);
419 block += sizeof (unsigned short);
424 print_int (size_t n_bytes, const char *block, const char *fmt_string)
427 for (i = n_bytes / sizeof (unsigned int); i > 0; i--)
429 unsigned int tmp = *(const unsigned int *) block;
430 printf (fmt_string, tmp);
431 block += sizeof (unsigned int);
436 print_long (size_t n_bytes, const char *block, const char *fmt_string)
439 for (i = n_bytes / sizeof (unsigned long); i > 0; i--)
441 unsigned long tmp = *(const unsigned long *) block;
442 printf (fmt_string, tmp);
443 block += sizeof (unsigned long);
448 print_long_long (size_t n_bytes, const char *block, const char *fmt_string)
451 for (i = n_bytes / sizeof (ulonglong_t); i > 0; i--)
453 ulonglong_t tmp = *(const ulonglong_t *) block;
454 printf (fmt_string, tmp);
455 block += sizeof (ulonglong_t);
460 print_float (size_t n_bytes, const char *block, const char *fmt_string)
463 for (i = n_bytes / sizeof (float); i > 0; i--)
465 float tmp = *(const float *) block;
466 printf (fmt_string, tmp);
467 block += sizeof (float);
472 print_double (size_t n_bytes, const char *block, const char *fmt_string)
475 for (i = n_bytes / sizeof (double); i > 0; i--)
477 double tmp = *(const double *) block;
478 printf (fmt_string, tmp);
479 block += sizeof (double);
483 #ifdef HAVE_LONG_DOUBLE
485 print_long_double (size_t n_bytes, const char *block, const char *fmt_string)
488 for (i = n_bytes / sizeof (LONG_DOUBLE); i > 0; i--)
490 LONG_DOUBLE tmp = *(const LONG_DOUBLE *) block;
491 printf (fmt_string, tmp);
492 block += sizeof (LONG_DOUBLE);
499 dump_hexl_mode_trailer (size_t n_bytes, const char *block)
502 fputs (" >", stdout);
503 for (i = n_bytes; i > 0; i--)
505 unsigned int c = *(const unsigned char *) block;
506 unsigned int c2 = (ISPRINT(c) ? c : '.');
508 block += sizeof (unsigned char);
514 print_named_ascii (size_t n_bytes, const char *block,
515 const char *unused_fmt_string ATTRIBUTE_UNUSED)
518 for (i = n_bytes; i > 0; i--)
520 unsigned int c = *(const unsigned char *) block;
521 unsigned int masked_c = (0x7f & c);
527 else if (masked_c <= 040)
528 s = charname[masked_c];
531 sprintf (buf, " %c", masked_c);
536 block += sizeof (unsigned char);
541 print_ascii (size_t n_bytes, const char *block,
542 const char *unused_fmt_string ATTRIBUTE_UNUSED)
545 for (i = n_bytes; i > 0; i--)
547 unsigned int c = *(const unsigned char *) block;
586 sprintf (buf, (ISPRINT (c) ? " %c" : "%03o"), c);
587 s = (const char *) buf;
591 block += sizeof (unsigned char);
595 /* Convert a null-terminated (possibly zero-length) string S to an
596 unsigned long integer value. If S points to a non-digit set *P to S,
597 *VAL to 0, and return 0. Otherwise, accumulate the integer value of
598 the string of digits. If the string of digits represents a value
599 larger than ULONG_MAX, don't modify *VAL or *P and return nonzero.
600 Otherwise, advance *P to the first non-digit after S, set *VAL to
601 the result of the conversion and return zero. */
604 simple_strtoul (const char *s, const char **p, long unsigned int *val)
606 unsigned long int sum;
611 unsigned int c = *s++ - '0';
612 if (sum > (ULONG_MAX - c) / 10)
621 /* If S points to a single valid POSIX-style od format string, put
622 a description of that format in *TSPEC, make *NEXT point at the
623 character following the just-decoded format (if *NEXT is non-NULL),
624 and return zero. If S is not valid, don't modify *NEXT or *TSPEC,
625 give a diagnostic, and return nonzero. For example, if S were
626 "d4afL" *NEXT would be set to "afL" and *TSPEC would be
628 fmt = SIGNED_DECIMAL;
629 size = INT or LONG; (whichever integral_type_size[4] resolves to)
630 print_function = print_int; (assuming size == INT)
631 fmt_string = "%011d%c";
633 S_ORIG is solely for reporting errors. It should be the full format
638 decode_one_format (const char *s_orig, const char *s, const char **next,
641 enum size_spec size_spec;
642 unsigned long int size;
643 enum output_format fmt;
644 const char *pre_fmt_string;
646 void (*print_function) PARAMS ((size_t, const char *, const char *));
649 unsigned int field_width = 0;
651 assert (tspec != NULL);
665 size = sizeof (char);
670 size = sizeof (short);
680 size = sizeof (long int);
684 if (simple_strtoul (s, &p, &size) != 0)
686 /* The integer at P in S would overflow an unsigned long.
687 A digit string that long is sufficiently odd looking
688 that the following diagnostic is sufficient. */
689 error (0, 0, _("invalid type string `%s'"), s_orig);
696 if (MAX_INTEGRAL_TYPE_SIZE < size
697 || integral_type_size[size] == NO_SIZE)
699 error (0, 0, _("invalid type string `%s';\n\
700 this system doesn't provide a %lu-byte integral type"), s_orig, size);
708 #define FMT_BYTES_ALLOCATED 9
709 fmt_string = xmalloc (FMT_BYTES_ALLOCATED);
711 size_spec = integral_type_size[size];
716 fmt = SIGNED_DECIMAL;
717 sprintf (fmt_string, " %%%u%sd",
718 (field_width = bytes_to_signed_dec_digits[size]),
719 (size_spec == LONG ? "l"
720 : (size_spec == LONG_LONG ? "ll"
726 sprintf (fmt_string, " %%0%u%so",
727 (field_width = bytes_to_oct_digits[size]),
728 (size_spec == LONG ? "l" : ""));
732 fmt = UNSIGNED_DECIMAL;
733 sprintf (fmt_string, " %%%u%su",
734 (field_width = bytes_to_unsigned_dec_digits[size]),
735 (size_spec == LONG ? "l" : ""));
740 sprintf (fmt_string, " %%0%u%sx",
741 (field_width = bytes_to_hex_digits[size]),
742 (size_spec == LONG ? "l" : ""));
749 assert (strlen (fmt_string) < FMT_BYTES_ALLOCATED);
754 print_function = (fmt == SIGNED_DECIMAL
760 print_function = (fmt == SIGNED_DECIMAL
766 print_function = print_int;
770 print_function = print_long;
774 print_function = print_long_long;
783 fmt = FLOATING_POINT;
789 size = sizeof (float);
794 size = sizeof (double);
799 size = sizeof (LONG_DOUBLE);
803 if (simple_strtoul (s, &p, &size) != 0)
805 /* The integer at P in S would overflow an unsigned long.
806 A digit string that long is sufficiently odd looking
807 that the following diagnostic is sufficient. */
808 error (0, 0, _("invalid type string `%s'"), s_orig);
812 size = sizeof (double);
815 if (size > MAX_FP_TYPE_SIZE
816 || fp_type_size[size] == NO_SIZE)
818 error (0, 0, _("invalid type string `%s';\n\
819 this system doesn't provide a %lu-byte floating point type"), s_orig, size);
826 size_spec = fp_type_size[size];
831 print_function = print_float;
832 /* Don't use %#e; not all systems support it. */
833 pre_fmt_string = " %%%d.%de";
834 fmt_string = xmalloc (strlen (pre_fmt_string));
835 sprintf (fmt_string, pre_fmt_string,
836 (field_width = FLT_DIG + 8), FLT_DIG);
840 print_function = print_double;
841 pre_fmt_string = " %%%d.%de";
842 fmt_string = xmalloc (strlen (pre_fmt_string));
843 sprintf (fmt_string, pre_fmt_string,
844 (field_width = DBL_DIG + 8), DBL_DIG);
847 #ifdef HAVE_LONG_DOUBLE
848 case FLOAT_LONG_DOUBLE:
849 print_function = print_long_double;
850 pre_fmt_string = " %%%d.%dLe";
851 fmt_string = xmalloc (strlen (pre_fmt_string));
852 sprintf (fmt_string, pre_fmt_string,
853 (field_width = LDBL_DIG + 8), LDBL_DIG);
864 fmt = NAMED_CHARACTER;
867 print_function = print_named_ascii;
876 print_function = print_ascii;
881 error (0, 0, _("invalid character `%c' in type string `%s'"),
886 tspec->size = size_spec;
888 tspec->print_function = print_function;
889 tspec->fmt_string = fmt_string;
891 tspec->field_width = field_width;
892 tspec->hexl_mode_trailer = (*s == 'z');
893 if (tspec->hexl_mode_trailer)
902 /* Given a list of one or more input filenames FILE_LIST, set the global
903 file pointer IN_STREAM and the global string INPUT_FILENAME to the
904 first one that can be successfully opened. Modify FILE_LIST to
905 reference the next filename in the list. A file name of "-" is
906 interpreted as standard input. If any file open fails, give an error
907 message and return nonzero. */
910 open_next_file (void)
916 input_filename = *file_list;
917 if (input_filename == NULL)
921 if (STREQ (input_filename, "-"))
923 input_filename = _("standard input");
929 in_stream = fopen (input_filename, "r");
930 if (in_stream == NULL)
932 error (0, errno, "%s", input_filename);
937 while (in_stream == NULL);
939 if (limit_bytes_to_format && !flag_dump_strings)
940 SETVBUF (in_stream, NULL, _IONBF, 0);
941 SET_BINARY (fileno (in_stream));
946 /* Test whether there have been errors on in_stream, and close it if
947 it is not standard input. Return nonzero if there has been an error
948 on in_stream or stdout; return zero otherwise. This function will
949 report more than one error only if both a read and a write error
953 check_and_close (void)
957 if (in_stream != NULL)
959 if (ferror (in_stream))
961 error (0, errno, "%s", input_filename);
962 if (in_stream != stdin)
966 else if (in_stream != stdin && fclose (in_stream) == EOF)
968 error (0, errno, "%s", input_filename);
977 error (0, errno, _("standard output"));
984 /* Decode the POSIX-style od format string S. Append the decoded
985 representation to the global array SPEC, reallocating SPEC if
986 necessary. Return zero if S is valid, nonzero otherwise. */
989 decode_format_string (const char *s)
991 const char *s_orig = s;
999 if (decode_one_format (s_orig, s, &next, &tspec))
1005 if (n_specs >= n_specs_allocated)
1007 n_specs_allocated = 1 + (3 * n_specs_allocated) / 2;
1008 spec = (struct tspec *) xrealloc ((char *) spec,
1010 * sizeof (struct tspec)));
1013 memcpy ((char *) &spec[n_specs], (char *) &tspec,
1014 sizeof (struct tspec));
1021 /* Given a list of one or more input filenames FILE_LIST, set the global
1022 file pointer IN_STREAM to position N_SKIP in the concatenation of
1023 those files. If any file operation fails or if there are fewer than
1024 N_SKIP bytes in the combined input, give an error message and return
1025 nonzero. When possible, use seek rather than read operations to
1026 advance IN_STREAM. */
1029 skip (uintmax_t n_skip)
1036 while (in_stream != NULL) /* EOF. */
1038 struct stat file_stats;
1040 /* First try seeking. For large offsets, this extra work is
1041 worthwhile. If the offset is below some threshold it may be
1042 more efficient to move the pointer by reading. There are two
1043 issues when trying to seek:
1044 - the file must be seekable.
1045 - before seeking to the specified position, make sure
1046 that the new position is in the current file.
1047 Try to do that by getting file's size using fstat.
1048 But that will work only for regular files. */
1050 if (fstat (fileno (in_stream), &file_stats) == 0)
1052 /* The st_size field is valid only for regular files
1053 (and for symbolic links, which cannot occur here).
1054 If the number of bytes left to skip is at least
1055 as large as the size of the current file, we can
1056 decrement n_skip and go on to the next file. */
1058 if (S_ISREG (file_stats.st_mode) && 0 <= file_stats.st_size)
1060 if (file_stats.st_size <= n_skip)
1061 n_skip -= file_stats.st_size;
1064 if (lseek (fileno (in_stream), n_skip, SEEK_CUR) < 0)
1066 error (0, errno, "%s", input_filename);
1073 /* If it's not a regular file with nonnegative size,
1074 position the file pointer by reading. */
1079 size_t n_bytes_read, n_bytes_to_read = BUFSIZ;
1083 if (n_skip < n_bytes_to_read)
1084 n_bytes_to_read = n_skip;
1085 n_bytes_read = fread (buf, 1, n_bytes_to_read, in_stream);
1086 n_skip -= n_bytes_read;
1087 if (n_bytes_read != n_bytes_to_read)
1096 else /* cannot fstat() file */
1098 error (0, errno, "%s", input_filename);
1102 err |= check_and_close ();
1104 err |= open_next_file ();
1108 error (EXIT_FAILURE, 0, _("cannot skip past end of combined input"));
1114 format_address_none (uintmax_t address ATTRIBUTE_UNUSED, char c ATTRIBUTE_UNUSED)
1119 format_address_std (uintmax_t address, char c)
1121 char buf[MAX_ADDRESS_LENGTH + 2];
1122 char *p = buf + sizeof buf;
1127 pbound = p - address_pad_len;
1129 /* Use a special case of the code for each base. This is measurably
1130 faster than generic code. */
1131 switch (address_base)
1135 *--p = '0' + (address & 7);
1136 while ((address >>= 3) != 0);
1141 *--p = '0' + (address % 10);
1142 while ((address /= 10) != 0);
1147 *--p = "0123456789abcdef"[address & 15];
1148 while ((address >>= 4) != 0);
1159 format_address_paren (uintmax_t address, char c)
1162 format_address_std (address, ')');
1167 format_address_label (uintmax_t address, char c)
1169 format_address_std (address, ' ');
1170 format_address_paren (address + pseudo_offset, c);
1173 /* Write N_BYTES bytes from CURR_BLOCK to standard output once for each
1174 of the N_SPEC format specs. CURRENT_OFFSET is the byte address of
1175 CURR_BLOCK in the concatenation of input files, and it is printed
1176 (optionally) only before the output line associated with the first
1177 format spec. When duplicate blocks are being abbreviated, the output
1178 for a sequence of identical input blocks is the output for the first
1179 block followed by an asterisk alone on a line. It is valid to compare
1180 the blocks PREV_BLOCK and CURR_BLOCK only when N_BYTES == BYTES_PER_BLOCK.
1181 That condition may be false only for the last input block -- and then
1182 only when it has not been padded to length BYTES_PER_BLOCK. */
1185 write_block (uintmax_t current_offset, size_t n_bytes,
1186 const char *prev_block, const char *curr_block)
1188 static int first = 1;
1189 static int prev_pair_equal = 0;
1191 #define EQUAL_BLOCKS(b1, b2) (memcmp ((b1), (b2), bytes_per_block) == 0)
1193 if (abbreviate_duplicate_blocks
1194 && !first && n_bytes == bytes_per_block
1195 && EQUAL_BLOCKS (prev_block, curr_block))
1197 if (prev_pair_equal)
1199 /* The two preceding blocks were equal, and the current
1200 block is the same as the last one, so print nothing. */
1205 prev_pair_equal = 1;
1212 prev_pair_equal = 0;
1213 for (i = 0; i < n_specs; i++)
1216 format_address (current_offset, '\0');
1218 printf ("%*s", address_pad_len, "");
1219 (*spec[i].print_function) (n_bytes, curr_block, spec[i].fmt_string);
1220 if (spec[i].hexl_mode_trailer)
1222 /* space-pad out to full line width, then dump the trailer */
1223 int datum_width = width_bytes[spec[i].size];
1224 int blank_fields = (bytes_per_block - n_bytes) / datum_width;
1225 int field_width = spec[i].field_width + 1;
1226 printf ("%*s", blank_fields * field_width, "");
1227 dump_hexl_mode_trailer (n_bytes, curr_block);
1235 /* Read a single byte into *C from the concatenation of the input files
1236 named in the global array FILE_LIST. On the first call to this
1237 function, the global variable IN_STREAM is expected to be an open
1238 stream associated with the input file INPUT_FILENAME. If IN_STREAM
1239 is at end-of-file, close it and update the global variables IN_STREAM
1240 and INPUT_FILENAME so they correspond to the next file in the list.
1241 Then try to read a byte from the newly opened file. Repeat if
1242 necessary until EOF is reached for the last file in FILE_LIST, then
1243 set *C to EOF and return. Subsequent calls do likewise. The return
1244 value is nonzero if any errors occured, zero otherwise. */
1253 while (in_stream != NULL) /* EOF. */
1255 *c = fgetc (in_stream);
1260 err |= check_and_close ();
1262 err |= open_next_file ();
1268 /* Read N bytes into BLOCK from the concatenation of the input files
1269 named in the global array FILE_LIST. On the first call to this
1270 function, the global variable IN_STREAM is expected to be an open
1271 stream associated with the input file INPUT_FILENAME. If all N
1272 bytes cannot be read from IN_STREAM, close IN_STREAM and update
1273 the global variables IN_STREAM and INPUT_FILENAME. Then try to
1274 read the remaining bytes from the newly opened file. Repeat if
1275 necessary until EOF is reached for the last file in FILE_LIST.
1276 On subsequent calls, don't modify BLOCK and return zero. Set
1277 *N_BYTES_IN_BUFFER to the number of bytes read. If an error occurs,
1278 it will be detected through ferror when the stream is about to be
1279 closed. If there is an error, give a message but continue reading
1280 as usual and return nonzero. Otherwise return zero. */
1283 read_block (size_t n, char *block, size_t *n_bytes_in_buffer)
1287 assert (0 < n && n <= bytes_per_block);
1289 *n_bytes_in_buffer = 0;
1294 while (in_stream != NULL) /* EOF. */
1299 n_needed = n - *n_bytes_in_buffer;
1300 n_read = fread (block + *n_bytes_in_buffer, 1, n_needed, in_stream);
1302 *n_bytes_in_buffer += n_read;
1304 if (n_read == n_needed)
1307 err |= check_and_close ();
1309 err |= open_next_file ();
1315 /* Return the least common multiple of the sizes associated
1316 with the format specs. */
1324 for (i = 0; i < n_specs; i++)
1325 l_c_m = lcm (l_c_m, width_bytes[(int) spec[i].size]);
1329 /* If S is a valid pre-POSIX offset specification with an optional leading '+'
1330 return nonzero and set *OFFSET to the offset it denotes. */
1333 parse_old_offset (const char *s, uintmax_t *offset)
1336 enum strtol_error s_err;
1341 /* Skip over any leading '+'. */
1345 /* Determine the radix we'll use to interpret S. If there is a `.',
1346 it's decimal, otherwise, if the string begins with `0X'or `0x',
1347 it's hexadecimal, else octal. */
1348 if (strchr (s, '.') != NULL)
1352 if (s[0] == '0' && (s[1] == 'x' || s[1] == 'X'))
1358 s_err = xstrtoumax (s, NULL, radix, offset, "Bb");
1359 if (s_err != LONGINT_OK)
1361 STRTOL_FAIL_WARN (s, _("old-style offset"), s_err);
1367 /* Read a chunk of size BYTES_PER_BLOCK from the input files, write the
1368 formatted block to standard output, and repeat until the specified
1369 maximum number of bytes has been read or until all input has been
1370 processed. If the last block read is smaller than BYTES_PER_BLOCK
1371 and its size is not a multiple of the size associated with a format
1372 spec, extend the input block with zero bytes until its length is a
1373 multiple of all format spec sizes. Write the final block. Finally,
1374 write on a line by itself the offset of the byte after the last byte
1375 read. Accumulate return values from calls to read_block and
1376 check_and_close, and if any was nonzero, return nonzero.
1377 Otherwise, return zero. */
1383 uintmax_t current_offset;
1386 size_t n_bytes_read;
1388 block[0] = (char *) alloca (bytes_per_block);
1389 block[1] = (char *) alloca (bytes_per_block);
1391 current_offset = n_bytes_to_skip;
1395 if (limit_bytes_to_format)
1400 if (current_offset >= end_offset)
1405 n_needed = MIN (end_offset - current_offset,
1406 (uintmax_t) bytes_per_block);
1407 err |= read_block (n_needed, block[idx], &n_bytes_read);
1408 if (n_bytes_read < bytes_per_block)
1410 assert (n_bytes_read == bytes_per_block);
1411 write_block (current_offset, n_bytes_read,
1412 block[!idx], block[idx]);
1413 current_offset += n_bytes_read;
1421 err |= read_block (bytes_per_block, block[idx], &n_bytes_read);
1422 if (n_bytes_read < bytes_per_block)
1424 assert (n_bytes_read == bytes_per_block);
1425 write_block (current_offset, n_bytes_read,
1426 block[!idx], block[idx]);
1427 current_offset += n_bytes_read;
1432 if (n_bytes_read > 0)
1435 size_t bytes_to_write;
1439 /* Make bytes_to_write the smallest multiple of l_c_m that
1440 is at least as large as n_bytes_read. */
1441 bytes_to_write = l_c_m * ((n_bytes_read + l_c_m - 1) / l_c_m);
1443 memset (block[idx] + n_bytes_read, 0, bytes_to_write - n_bytes_read);
1444 write_block (current_offset, bytes_to_write,
1445 block[!idx], block[idx]);
1446 current_offset += n_bytes_read;
1449 format_address (current_offset, '\n');
1451 if (limit_bytes_to_format && current_offset >= end_offset)
1452 err |= check_and_close ();
1457 /* STRINGS mode. Find each "string constant" in the input.
1458 A string constant is a run of at least `string_min' ASCII
1459 graphic (or formatting) characters terminated by a null.
1460 Based on a function written by Richard Stallman for a
1461 pre-POSIX version of od. Return nonzero if an error
1462 occurs. Otherwise, return zero. */
1467 size_t bufsize = MAX (100, string_min);
1468 char *buf = xmalloc (bufsize);
1469 uintmax_t address = n_bytes_to_skip;
1478 /* See if the next `string_min' chars are all printing chars. */
1481 if (limit_bytes_to_format
1482 && (end_offset < string_min || end_offset - string_min <= address))
1485 for (i = 0; i < string_min; i++)
1487 err |= read_char (&c);
1495 /* Found a non-printing. Try again starting with next char. */
1500 /* We found a run of `string_min' printable characters.
1501 Now see if it is terminated with a null byte. */
1502 while (!limit_bytes_to_format || address < end_offset)
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 format_address (address - i - 1, ' ');
1528 for (i = 0; (c = buf[i]); i++)
1533 fputs ("\\a", stdout);
1537 fputs ("\\b", stdout);
1541 fputs ("\\f", stdout);
1545 fputs ("\\n", stdout);
1549 fputs ("\\r", stdout);
1553 fputs ("\\t", stdout);
1557 fputs ("\\v", stdout);
1567 /* We reach this point only if we search through
1568 (max_bytes_to_format - string_min) bytes before reaching EOF. */
1572 err |= check_and_close ();
1577 main (int argc, char **argv)
1583 size_t desired_width IF_LINT (= 0);
1584 int width_specified = 0;
1585 int n_failed_decodes = 0;
1588 /* The old-style `pseudo starting address' to be printed in parentheses
1589 after any true address. */
1590 uintmax_t pseudo_start IF_LINT (= 0);
1592 program_name = argv[0];
1593 setlocale (LC_ALL, "");
1594 bindtextdomain (PACKAGE, LOCALEDIR);
1595 textdomain (PACKAGE);
1597 atexit (close_stdout);
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;
1608 #if HAVE_UNSIGNED_LONG_LONG
1609 integral_type_size[sizeof (ulonglong_t)] = LONG_LONG;
1612 for (i = 0; i <= MAX_FP_TYPE_SIZE; i++)
1613 fp_type_size[i] = NO_SIZE;
1615 fp_type_size[sizeof (float)] = FLOAT_SINGLE;
1616 /* The array entry for `double' is filled in after that for LONG_DOUBLE
1617 so that if `long double' is the same type or if long double isn't
1618 supported FLOAT_LONG_DOUBLE will never be used. */
1619 fp_type_size[sizeof (LONG_DOUBLE)] = FLOAT_LONG_DOUBLE;
1620 fp_type_size[sizeof (double)] = FLOAT_DOUBLE;
1623 n_specs_allocated = 5;
1624 spec = (struct tspec *) xmalloc (n_specs_allocated * sizeof (struct tspec));
1626 format_address = format_address_std;
1628 address_pad_len = 7;
1629 flag_dump_strings = 0;
1631 while ((c = getopt_long (argc, argv, "abcdfhilos::xw::A:j:N:t:v",
1632 long_options, NULL)) != -1)
1635 enum strtol_error s_err;
1646 format_address = format_address_std;
1648 address_pad_len = 7;
1651 format_address = format_address_std;
1653 address_pad_len = 7;
1656 format_address = format_address_std;
1658 address_pad_len = 6;
1661 format_address = format_address_none;
1662 address_pad_len = 0;
1665 error (EXIT_FAILURE, 0,
1666 _("invalid output address radix `%c'; \
1667 it must be one character from [doxn]"),
1674 s_err = xstrtoumax (optarg, NULL, 0, &n_bytes_to_skip, "bkm");
1675 if (s_err != LONGINT_OK)
1676 STRTOL_FATAL_ERROR (optarg, _("skip argument"), s_err);
1680 limit_bytes_to_format = 1;
1682 s_err = xstrtoumax (optarg, NULL, 0, &max_bytes_to_format, "bkm");
1683 if (s_err != LONGINT_OK)
1684 STRTOL_FATAL_ERROR (optarg, _("limit argument"), s_err);
1692 s_err = xstrtoumax (optarg, NULL, 0, &tmp, "bkm");
1693 if (s_err != LONGINT_OK)
1694 STRTOL_FATAL_ERROR (optarg, _("minimum string length"), s_err);
1696 /* The minimum string length may be no larger than SIZE_MAX,
1697 since we may allocate a buffer of this size. */
1699 error (EXIT_FAILURE, 0, _("%s is too large"), optarg);
1703 flag_dump_strings = 1;
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;
1754 s_err = xstrtoumax (optarg, NULL, 10, &w_tmp, "");
1755 if (s_err != LONGINT_OK)
1756 STRTOL_FATAL_ERROR (optarg, _("width specification"), s_err);
1757 if (SIZE_MAX < w_tmp)
1758 error (EXIT_FAILURE, 0, _("%s is too large"), optarg);
1759 desired_width = w_tmp;
1763 case_GETOPT_HELP_CHAR;
1765 case_GETOPT_VERSION_CHAR (PROGRAM_NAME, AUTHORS);
1773 if (n_failed_decodes > 0)
1774 exit (EXIT_FAILURE);
1776 if (flag_dump_strings && n_specs > 0)
1777 error (EXIT_FAILURE, 0,
1778 _("no type may be specified when dumping strings"));
1780 n_files = argc - optind;
1782 /* If the --backward-compatible option is used, there may be from
1783 0 to 3 remaining command line arguments; handle each case
1785 od [file] [[+]offset[.][b] [[+]label[.][b]]]
1786 The offset and pseudo_start have the same syntax. */
1794 if (parse_old_offset (argv[optind], &offset))
1796 n_bytes_to_skip = offset;
1801 else if (n_files == 2)
1804 if (parse_old_offset (argv[optind], &o1)
1805 && parse_old_offset (argv[optind + 1], &o2))
1807 n_bytes_to_skip = o1;
1808 flag_pseudo_start = 1;
1813 else if (parse_old_offset (argv[optind + 1], &o2))
1815 n_bytes_to_skip = o2;
1817 argv[optind + 1] = argv[optind];
1823 _("invalid second operand in compatibility mode `%s'"),
1828 else if (n_files == 3)
1831 if (parse_old_offset (argv[optind + 1], &o1)
1832 && parse_old_offset (argv[optind + 2], &o2))
1834 n_bytes_to_skip = o1;
1835 flag_pseudo_start = 1;
1837 argv[optind + 2] = argv[optind];
1844 _("in compatibility mode, the last two arguments must be offsets"));
1848 else if (n_files > 3)
1851 _("compatibility mode supports at most three arguments"));
1855 if (flag_pseudo_start)
1857 if (format_address == format_address_none)
1860 address_pad_len = 7;
1861 format_address = format_address_paren;
1864 format_address = format_address_label;
1868 if (limit_bytes_to_format)
1870 end_offset = n_bytes_to_skip + max_bytes_to_format;
1871 if (end_offset < n_bytes_to_skip)
1872 error (EXIT_FAILURE, 0, "skip-bytes + read-bytes is too large");
1877 if (decode_one_format ("o2", "o2", NULL, &(spec[0])))
1879 /* This happens on Cray systems that don't have a 2-byte
1881 exit (EXIT_FAILURE);
1889 /* Set the global pointer FILE_LIST so that it
1890 references the first file-argument on the command-line. */
1892 file_list = (char const *const *) &argv[optind];
1896 /* No files were listed on the command line.
1897 Set the global pointer FILE_LIST so that it
1898 references the null-terminated list of one name: "-". */
1900 file_list = default_file_list;
1903 /* open the first input file */
1904 err |= open_next_file ();
1905 if (in_stream == NULL)
1908 /* skip over any unwanted header bytes */
1909 err |= skip (n_bytes_to_skip);
1910 if (in_stream == NULL)
1913 pseudo_offset = (flag_pseudo_start ? pseudo_start - n_bytes_to_skip : 0);
1915 /* Compute output block length. */
1918 if (width_specified)
1920 if (desired_width != 0 && desired_width % l_c_m == 0)
1921 bytes_per_block = desired_width;
1924 error (0, 0, _("warning: invalid width %lu; using %d instead"),
1925 (unsigned long) desired_width, l_c_m);
1926 bytes_per_block = l_c_m;
1931 if (l_c_m < DEFAULT_BYTES_PER_BLOCK)
1932 bytes_per_block = l_c_m * (DEFAULT_BYTES_PER_BLOCK / l_c_m);
1934 bytes_per_block = l_c_m;
1938 for (i = 0; i < n_specs; i++)
1940 printf (_("%d: fmt=\"%s\" width=%d\n"),
1941 i, spec[i].fmt_string, width_bytes[spec[i].size]);
1945 err |= (flag_dump_strings ? dump_strings () : dump ());
1949 if (have_read_stdin && fclose (stdin) == EOF)
1950 error (EXIT_FAILURE, errno, _("standard input"));
1952 exit (err == 0 ? EXIT_SUCCESS : EXIT_FAILURE);