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) PARAMS ((size_t, const char *, const char *));
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 Mandatory arguments to long options are mandatory for short options too.\n\
286 -A, --address-radix=RADIX decide how file offsets are printed\n\
287 -j, --skip-bytes=BYTES skip BYTES input bytes first\n\
290 -N, --read-bytes=BYTES limit dump to BYTES input bytes\n\
291 -s, --strings[=BYTES] output strings of at least BYTES graphic chars\n\
292 -t, --format=TYPE select output format or formats\n\
293 -v, --output-duplicates do not use * to mark line suppression\n\
294 -w, --width[=BYTES] output BYTES bytes per output line\n\
295 --traditional accept arguments in pre-POSIX form\n\
298 --help display this help and exit\n\
299 --version output version information and exit\n\
301 Pre-POSIX format specifications may be intermixed, they accumulate:\n\
302 -a same as -t a, select named characters\n\
303 -b same as -t oC, select octal bytes\n\
304 -c same as -t c, select ASCII characters or backslash escapes\n\
305 -d same as -t u2, select unsigned decimal shorts\n\
308 -f same as -t fF, select floats\n\
309 -h same as -t x2, select hexadecimal shorts\n\
310 -i same as -t d2, select decimal shorts\n\
311 -l same as -t d4, select decimal longs\n\
312 -o same as -t o2, select octal shorts\n\
313 -x same as -t x2, select hexadecimal shorts\n\
317 For older syntax (second call format), OFFSET means -j OFFSET. LABEL\n\
318 is the pseudo-address at first byte printed, incremented when dump is\n\
319 progressing. For OFFSET and LABEL, a 0x or 0X prefix indicates\n\
320 hexadecimal, suffixes maybe . for octal and b multiply by 512.\n\
322 TYPE is made up of one or more of these specifications:\n\
325 c ASCII character or backslash escape\n\
328 d[SIZE] signed decimal, SIZE bytes per integer\n\
329 f[SIZE] floating point, SIZE bytes per integer\n\
330 o[SIZE] octal, SIZE bytes per integer\n\
331 u[SIZE] unsigned decimal, SIZE bytes per integer\n\
332 x[SIZE] hexadecimal, SIZE bytes per integer\n\
334 SIZE is a number. For TYPE in doux, SIZE may also be C for\n\
335 sizeof(char), S for sizeof(short), I for sizeof(int) or L for\n\
338 sizeof(long). If TYPE is f, SIZE may also be F for sizeof(float), D\n\
339 for sizeof(double) or L for sizeof(long double).\n\
341 RADIX is d for decimal, o for octal, x for hexadecimal or n for none.\n\
342 BYTES is hexadecimal with 0x or 0X prefix, it is multiplied by 512\n\
345 with b suffix, by 1024 with k and by 1048576 with m. Adding a z suffix to\n\
346 any type adds a display of printable characters to the end of each line\n\
347 of output. -s without a number implies 3. -w without a number implies 32.\n\
348 By default, od uses -A o -t d2 -w 16.\n\
350 puts (_("\nReport bugs to <bug-textutils@gnu.org>."));
352 exit (status == 0 ? EXIT_SUCCESS : EXIT_FAILURE);
355 /* Compute the greatest common denominator of U and V
356 using Euclid's algorithm. */
359 gcd (unsigned int u, unsigned int v)
371 /* Compute the least common multiple of U and V. */
374 lcm (unsigned int u, unsigned int v)
376 unsigned int t = gcd (u, v);
383 print_s_char (size_t n_bytes, const char *block, const char *fmt_string)
386 for (i = n_bytes; i > 0; i--)
388 int tmp = (unsigned) *(const unsigned char *) block;
390 tmp -= SCHAR_MAX - SCHAR_MIN + 1;
391 assert (tmp <= SCHAR_MAX);
392 printf (fmt_string, tmp);
393 block += sizeof (unsigned char);
398 print_char (size_t n_bytes, const char *block, const char *fmt_string)
401 for (i = n_bytes; i > 0; i--)
403 unsigned int tmp = *(const unsigned char *) block;
404 printf (fmt_string, tmp);
405 block += sizeof (unsigned char);
410 print_s_short (size_t n_bytes, const char *block, const char *fmt_string)
413 for (i = n_bytes / sizeof (unsigned short); i > 0; i--)
415 int tmp = (unsigned) *(const unsigned short *) block;
417 tmp -= SHRT_MAX - SHRT_MIN + 1;
418 assert (tmp <= SHRT_MAX);
419 printf (fmt_string, tmp);
420 block += sizeof (unsigned short);
425 print_short (size_t n_bytes, const char *block, const char *fmt_string)
428 for (i = n_bytes / sizeof (unsigned short); i > 0; i--)
430 unsigned int tmp = *(const unsigned short *) block;
431 printf (fmt_string, tmp);
432 block += sizeof (unsigned short);
437 print_int (size_t n_bytes, const char *block, const char *fmt_string)
440 for (i = n_bytes / sizeof (unsigned int); i > 0; i--)
442 unsigned int tmp = *(const unsigned int *) block;
443 printf (fmt_string, tmp);
444 block += sizeof (unsigned int);
449 print_long (size_t n_bytes, const char *block, const char *fmt_string)
452 for (i = n_bytes / sizeof (unsigned long); i > 0; i--)
454 unsigned long tmp = *(const unsigned long *) block;
455 printf (fmt_string, tmp);
456 block += sizeof (unsigned long);
461 print_long_long (size_t n_bytes, const char *block, const char *fmt_string)
464 for (i = n_bytes / sizeof (ulonglong_t); i > 0; i--)
466 ulonglong_t tmp = *(const ulonglong_t *) block;
467 printf (fmt_string, tmp);
468 block += sizeof (ulonglong_t);
473 print_float (size_t n_bytes, const char *block, const char *fmt_string)
476 for (i = n_bytes / sizeof (float); i > 0; i--)
478 float tmp = *(const float *) block;
479 printf (fmt_string, tmp);
480 block += sizeof (float);
485 print_double (size_t n_bytes, const char *block, const char *fmt_string)
488 for (i = n_bytes / sizeof (double); i > 0; i--)
490 double tmp = *(const double *) block;
491 printf (fmt_string, tmp);
492 block += sizeof (double);
496 #ifdef HAVE_LONG_DOUBLE
498 print_long_double (size_t n_bytes, const char *block, const char *fmt_string)
501 for (i = n_bytes / sizeof (LONG_DOUBLE); i > 0; i--)
503 LONG_DOUBLE tmp = *(const LONG_DOUBLE *) block;
504 printf (fmt_string, tmp);
505 block += sizeof (LONG_DOUBLE);
512 dump_hexl_mode_trailer (size_t n_bytes, const char *block)
515 fputs (" >", stdout);
516 for (i = n_bytes; i > 0; i--)
518 unsigned int c = *(const unsigned char *) block;
519 unsigned int c2 = (ISPRINT(c) ? c : '.');
521 block += sizeof (unsigned char);
527 print_named_ascii (size_t n_bytes, const char *block,
528 const char *unused_fmt_string ATTRIBUTE_UNUSED)
531 for (i = n_bytes; i > 0; i--)
533 unsigned int c = *(const unsigned char *) block;
534 unsigned int masked_c = (0x7f & c);
540 else if (masked_c <= 040)
541 s = charname[masked_c];
544 sprintf (buf, " %c", masked_c);
549 block += sizeof (unsigned char);
554 print_ascii (size_t n_bytes, const char *block,
555 const char *unused_fmt_string ATTRIBUTE_UNUSED)
558 for (i = n_bytes; i > 0; i--)
560 unsigned int c = *(const unsigned char *) block;
599 sprintf (buf, (ISPRINT (c) ? " %c" : "%03o"), c);
600 s = (const char *) buf;
604 block += sizeof (unsigned char);
608 /* Convert a null-terminated (possibly zero-length) string S to an
609 unsigned long integer value. If S points to a non-digit set *P to S,
610 *VAL to 0, and return 0. Otherwise, accumulate the integer value of
611 the string of digits. If the string of digits represents a value
612 larger than ULONG_MAX, don't modify *VAL or *P and return nonzero.
613 Otherwise, advance *P to the first non-digit after S, set *VAL to
614 the result of the conversion and return zero. */
617 simple_strtoul (const char *s, const char **p, long unsigned int *val)
619 unsigned long int sum;
624 unsigned int c = *s++ - '0';
625 if (sum > (ULONG_MAX - c) / 10)
634 /* If S points to a single valid POSIX-style od format string, put
635 a description of that format in *TSPEC, make *NEXT point at the
636 character following the just-decoded format (if *NEXT is non-NULL),
637 and return zero. If S is not valid, don't modify *NEXT or *TSPEC,
638 give a diagnostic, and return nonzero. For example, if S were
639 "d4afL" *NEXT would be set to "afL" and *TSPEC would be
641 fmt = SIGNED_DECIMAL;
642 size = INT or LONG; (whichever integral_type_size[4] resolves to)
643 print_function = print_int; (assuming size == INT)
644 fmt_string = "%011d%c";
646 S_ORIG is solely for reporting errors. It should be the full format
651 decode_one_format (const char *s_orig, const char *s, const char **next,
654 enum size_spec size_spec;
655 unsigned long int size;
656 enum output_format fmt;
657 const char *pre_fmt_string;
659 void (*print_function) PARAMS ((size_t, const char *, const char *));
662 unsigned int field_width = 0;
664 assert (tspec != NULL);
678 size = sizeof (char);
683 size = sizeof (short);
693 size = sizeof (long int);
697 if (simple_strtoul (s, &p, &size) != 0)
699 /* The integer at P in S would overflow an unsigned long.
700 A digit string that long is sufficiently odd looking
701 that the following diagnostic is sufficient. */
702 error (0, 0, _("invalid type string `%s'"), s_orig);
709 if (MAX_INTEGRAL_TYPE_SIZE < size
710 || integral_type_size[size] == NO_SIZE)
712 error (0, 0, _("invalid type string `%s';\n\
713 this system doesn't provide a %lu-byte integral type"), s_orig, size);
721 #define FMT_BYTES_ALLOCATED 9
722 fmt_string = xmalloc (FMT_BYTES_ALLOCATED);
724 size_spec = integral_type_size[size];
729 fmt = SIGNED_DECIMAL;
730 sprintf (fmt_string, " %%%u%sd",
731 (field_width = bytes_to_signed_dec_digits[size]),
732 (size_spec == LONG ? "l"
733 : (size_spec == LONG_LONG ? "ll"
739 sprintf (fmt_string, " %%0%u%so",
740 (field_width = bytes_to_oct_digits[size]),
741 (size_spec == LONG ? "l" : ""));
745 fmt = UNSIGNED_DECIMAL;
746 sprintf (fmt_string, " %%%u%su",
747 (field_width = bytes_to_unsigned_dec_digits[size]),
748 (size_spec == LONG ? "l" : ""));
753 sprintf (fmt_string, " %%0%u%sx",
754 (field_width = bytes_to_hex_digits[size]),
755 (size_spec == LONG ? "l" : ""));
762 assert (strlen (fmt_string) < FMT_BYTES_ALLOCATED);
767 print_function = (fmt == SIGNED_DECIMAL
773 print_function = (fmt == SIGNED_DECIMAL
779 print_function = print_int;
783 print_function = print_long;
787 print_function = print_long_long;
796 fmt = FLOATING_POINT;
802 size = sizeof (float);
807 size = sizeof (double);
812 size = sizeof (LONG_DOUBLE);
816 if (simple_strtoul (s, &p, &size) != 0)
818 /* The integer at P in S would overflow an unsigned long.
819 A digit string that long is sufficiently odd looking
820 that the following diagnostic is sufficient. */
821 error (0, 0, _("invalid type string `%s'"), s_orig);
825 size = sizeof (double);
828 if (size > MAX_FP_TYPE_SIZE
829 || fp_type_size[size] == NO_SIZE)
831 error (0, 0, _("invalid type string `%s';\n\
832 this system doesn't provide a %lu-byte floating point type"), s_orig, size);
839 size_spec = fp_type_size[size];
844 print_function = print_float;
845 /* Don't use %#e; not all systems support it. */
846 pre_fmt_string = " %%%d.%de";
847 fmt_string = xmalloc (strlen (pre_fmt_string));
848 sprintf (fmt_string, pre_fmt_string,
849 (field_width = FLT_DIG + 8), FLT_DIG);
853 print_function = print_double;
854 pre_fmt_string = " %%%d.%de";
855 fmt_string = xmalloc (strlen (pre_fmt_string));
856 sprintf (fmt_string, pre_fmt_string,
857 (field_width = DBL_DIG + 8), DBL_DIG);
860 #ifdef HAVE_LONG_DOUBLE
861 case FLOAT_LONG_DOUBLE:
862 print_function = print_long_double;
863 pre_fmt_string = " %%%d.%dLe";
864 fmt_string = xmalloc (strlen (pre_fmt_string));
865 sprintf (fmt_string, pre_fmt_string,
866 (field_width = LDBL_DIG + 8), LDBL_DIG);
877 fmt = NAMED_CHARACTER;
880 print_function = print_named_ascii;
889 print_function = print_ascii;
894 error (0, 0, _("invalid character `%c' in type string `%s'"),
899 tspec->size = size_spec;
901 tspec->print_function = print_function;
902 tspec->fmt_string = fmt_string;
904 tspec->field_width = field_width;
905 tspec->hexl_mode_trailer = (*s == 'z');
906 if (tspec->hexl_mode_trailer)
915 /* Given a list of one or more input filenames FILE_LIST, set the global
916 file pointer IN_STREAM and the global string INPUT_FILENAME to the
917 first one that can be successfully opened. Modify FILE_LIST to
918 reference the next filename in the list. A file name of "-" is
919 interpreted as standard input. If any file open fails, give an error
920 message and return nonzero. */
923 open_next_file (void)
929 input_filename = *file_list;
930 if (input_filename == NULL)
934 if (STREQ (input_filename, "-"))
936 input_filename = _("standard input");
942 in_stream = fopen (input_filename, "r");
943 if (in_stream == NULL)
945 error (0, errno, "%s", input_filename);
950 while (in_stream == NULL);
952 if (limit_bytes_to_format && !flag_dump_strings)
953 SETVBUF (in_stream, NULL, _IONBF, 0);
954 SET_BINARY (fileno (in_stream));
959 /* Test whether there have been errors on in_stream, and close it if
960 it is not standard input. Return nonzero if there has been an error
961 on in_stream or stdout; return zero otherwise. This function will
962 report more than one error only if both a read and a write error
966 check_and_close (void)
970 if (in_stream != NULL)
972 if (ferror (in_stream))
974 error (0, errno, "%s", input_filename);
975 if (in_stream != stdin)
979 else if (in_stream != stdin && fclose (in_stream) == EOF)
981 error (0, errno, "%s", input_filename);
990 error (0, errno, _("standard output"));
997 /* Decode the POSIX-style od format string S. Append the decoded
998 representation to the global array SPEC, reallocating SPEC if
999 necessary. Return zero if S is valid, nonzero otherwise. */
1002 decode_format_string (const char *s)
1004 const char *s_orig = s;
1012 if (decode_one_format (s_orig, s, &next, &tspec))
1018 if (n_specs >= n_specs_allocated)
1020 n_specs_allocated = 1 + (3 * n_specs_allocated) / 2;
1021 spec = (struct tspec *) xrealloc ((char *) spec,
1023 * sizeof (struct tspec)));
1026 memcpy ((char *) &spec[n_specs], (char *) &tspec,
1027 sizeof (struct tspec));
1034 /* Given a list of one or more input filenames FILE_LIST, set the global
1035 file pointer IN_STREAM to position N_SKIP in the concatenation of
1036 those files. If any file operation fails or if there are fewer than
1037 N_SKIP bytes in the combined input, give an error message and return
1038 nonzero. When possible, use seek rather than read operations to
1039 advance IN_STREAM. */
1042 skip (uintmax_t n_skip)
1049 while (in_stream != NULL) /* EOF. */
1051 struct stat file_stats;
1053 /* First try seeking. For large offsets, this extra work is
1054 worthwhile. If the offset is below some threshold it may be
1055 more efficient to move the pointer by reading. There are two
1056 issues when trying to seek:
1057 - the file must be seekable.
1058 - before seeking to the specified position, make sure
1059 that the new position is in the current file.
1060 Try to do that by getting file's size using fstat.
1061 But that will work only for regular files. */
1063 if (fstat (fileno (in_stream), &file_stats) == 0)
1065 /* The st_size field is valid only for regular files
1066 (and for symbolic links, which cannot occur here).
1067 If the number of bytes left to skip is at least
1068 as large as the size of the current file, we can
1069 decrement n_skip and go on to the next file. */
1071 if (S_ISREG (file_stats.st_mode) && 0 <= file_stats.st_size)
1073 if (file_stats.st_size <= n_skip)
1074 n_skip -= file_stats.st_size;
1077 if (lseek (fileno (in_stream), n_skip, SEEK_CUR) < 0)
1079 error (0, errno, "%s", input_filename);
1086 /* If it's not a regular file with nonnegative size,
1087 position the file pointer by reading. */
1092 size_t n_bytes_read, n_bytes_to_read = BUFSIZ;
1096 if (n_skip < n_bytes_to_read)
1097 n_bytes_to_read = n_skip;
1098 n_bytes_read = fread (buf, 1, n_bytes_to_read, in_stream);
1099 n_skip -= n_bytes_read;
1100 if (n_bytes_read != n_bytes_to_read)
1109 else /* cannot fstat() file */
1111 error (0, errno, "%s", input_filename);
1115 err |= check_and_close ();
1117 err |= open_next_file ();
1121 error (EXIT_FAILURE, 0, _("cannot skip past end of combined input"));
1127 format_address_none (uintmax_t address ATTRIBUTE_UNUSED, char c ATTRIBUTE_UNUSED)
1132 format_address_std (uintmax_t address, char c)
1134 char buf[MAX_ADDRESS_LENGTH + 2];
1135 char *p = buf + sizeof buf;
1140 pbound = p - address_pad_len;
1142 /* Use a special case of the code for each base. This is measurably
1143 faster than generic code. */
1144 switch (address_base)
1148 *--p = '0' + (address & 7);
1149 while ((address >>= 3) != 0);
1154 *--p = '0' + (address % 10);
1155 while ((address /= 10) != 0);
1160 *--p = "0123456789abcdef"[address & 15];
1161 while ((address >>= 4) != 0);
1172 format_address_paren (uintmax_t address, char c)
1175 format_address_std (address, ')');
1180 format_address_label (uintmax_t address, char c)
1182 format_address_std (address, ' ');
1183 format_address_paren (address + pseudo_offset, c);
1186 /* Write N_BYTES bytes from CURR_BLOCK to standard output once for each
1187 of the N_SPEC format specs. CURRENT_OFFSET is the byte address of
1188 CURR_BLOCK in the concatenation of input files, and it is printed
1189 (optionally) only before the output line associated with the first
1190 format spec. When duplicate blocks are being abbreviated, the output
1191 for a sequence of identical input blocks is the output for the first
1192 block followed by an asterisk alone on a line. It is valid to compare
1193 the blocks PREV_BLOCK and CURR_BLOCK only when N_BYTES == BYTES_PER_BLOCK.
1194 That condition may be false only for the last input block -- and then
1195 only when it has not been padded to length BYTES_PER_BLOCK. */
1198 write_block (uintmax_t current_offset, size_t n_bytes,
1199 const char *prev_block, const char *curr_block)
1201 static int first = 1;
1202 static int prev_pair_equal = 0;
1204 #define EQUAL_BLOCKS(b1, b2) (memcmp ((b1), (b2), bytes_per_block) == 0)
1206 if (abbreviate_duplicate_blocks
1207 && !first && n_bytes == bytes_per_block
1208 && EQUAL_BLOCKS (prev_block, curr_block))
1210 if (prev_pair_equal)
1212 /* The two preceding blocks were equal, and the current
1213 block is the same as the last one, so print nothing. */
1218 prev_pair_equal = 1;
1225 prev_pair_equal = 0;
1226 for (i = 0; i < n_specs; i++)
1229 format_address (current_offset, '\0');
1231 printf ("%*s", address_pad_len, "");
1232 (*spec[i].print_function) (n_bytes, curr_block, spec[i].fmt_string);
1233 if (spec[i].hexl_mode_trailer)
1235 /* space-pad out to full line width, then dump the trailer */
1236 int datum_width = width_bytes[spec[i].size];
1237 int blank_fields = (bytes_per_block - n_bytes) / datum_width;
1238 int field_width = spec[i].field_width + 1;
1239 printf ("%*s", blank_fields * field_width, "");
1240 dump_hexl_mode_trailer (n_bytes, curr_block);
1248 /* Read a single byte into *C from the concatenation of the input files
1249 named in the global array FILE_LIST. On the first call to this
1250 function, the global variable IN_STREAM is expected to be an open
1251 stream associated with the input file INPUT_FILENAME. If IN_STREAM
1252 is at end-of-file, close it and update the global variables IN_STREAM
1253 and INPUT_FILENAME so they correspond to the next file in the list.
1254 Then try to read a byte from the newly opened file. Repeat if
1255 necessary until EOF is reached for the last file in FILE_LIST, then
1256 set *C to EOF and return. Subsequent calls do likewise. The return
1257 value is nonzero if any errors occured, zero otherwise. */
1266 while (in_stream != NULL) /* EOF. */
1268 *c = fgetc (in_stream);
1273 err |= check_and_close ();
1275 err |= open_next_file ();
1281 /* Read N bytes into BLOCK from the concatenation of the input files
1282 named in the global array FILE_LIST. On the first call to this
1283 function, the global variable IN_STREAM is expected to be an open
1284 stream associated with the input file INPUT_FILENAME. If all N
1285 bytes cannot be read from IN_STREAM, close IN_STREAM and update
1286 the global variables IN_STREAM and INPUT_FILENAME. Then try to
1287 read the remaining bytes from the newly opened file. Repeat if
1288 necessary until EOF is reached for the last file in FILE_LIST.
1289 On subsequent calls, don't modify BLOCK and return zero. Set
1290 *N_BYTES_IN_BUFFER to the number of bytes read. If an error occurs,
1291 it will be detected through ferror when the stream is about to be
1292 closed. If there is an error, give a message but continue reading
1293 as usual and return nonzero. Otherwise return zero. */
1296 read_block (size_t n, char *block, size_t *n_bytes_in_buffer)
1300 assert (0 < n && n <= bytes_per_block);
1302 *n_bytes_in_buffer = 0;
1307 while (in_stream != NULL) /* EOF. */
1312 n_needed = n - *n_bytes_in_buffer;
1313 n_read = fread (block + *n_bytes_in_buffer, 1, n_needed, in_stream);
1315 *n_bytes_in_buffer += n_read;
1317 if (n_read == n_needed)
1320 err |= check_and_close ();
1322 err |= open_next_file ();
1328 /* Return the least common multiple of the sizes associated
1329 with the format specs. */
1337 for (i = 0; i < n_specs; i++)
1338 l_c_m = lcm (l_c_m, width_bytes[(int) spec[i].size]);
1342 /* If S is a valid pre-POSIX offset specification with an optional leading '+'
1343 return nonzero and set *OFFSET to the offset it denotes. */
1346 parse_old_offset (const char *s, uintmax_t *offset)
1349 enum strtol_error s_err;
1354 /* Skip over any leading '+'. */
1358 /* Determine the radix we'll use to interpret S. If there is a `.',
1359 it's decimal, otherwise, if the string begins with `0X'or `0x',
1360 it's hexadecimal, else octal. */
1361 if (strchr (s, '.') != NULL)
1365 if (s[0] == '0' && (s[1] == 'x' || s[1] == 'X'))
1371 s_err = xstrtoumax (s, NULL, radix, offset, "Bb");
1372 if (s_err != LONGINT_OK)
1374 STRTOL_FAIL_WARN (s, _("old-style offset"), s_err);
1380 /* Read a chunk of size BYTES_PER_BLOCK from the input files, write the
1381 formatted block to standard output, and repeat until the specified
1382 maximum number of bytes has been read or until all input has been
1383 processed. If the last block read is smaller than BYTES_PER_BLOCK
1384 and its size is not a multiple of the size associated with a format
1385 spec, extend the input block with zero bytes until its length is a
1386 multiple of all format spec sizes. Write the final block. Finally,
1387 write on a line by itself the offset of the byte after the last byte
1388 read. Accumulate return values from calls to read_block and
1389 check_and_close, and if any was nonzero, return nonzero.
1390 Otherwise, return zero. */
1396 uintmax_t current_offset;
1399 size_t n_bytes_read;
1401 block[0] = (char *) alloca (bytes_per_block);
1402 block[1] = (char *) alloca (bytes_per_block);
1404 current_offset = n_bytes_to_skip;
1408 if (limit_bytes_to_format)
1413 if (current_offset >= end_offset)
1418 n_needed = MIN (end_offset - current_offset,
1419 (uintmax_t) bytes_per_block);
1420 err |= read_block (n_needed, block[idx], &n_bytes_read);
1421 if (n_bytes_read < bytes_per_block)
1423 assert (n_bytes_read == bytes_per_block);
1424 write_block (current_offset, n_bytes_read,
1425 block[!idx], block[idx]);
1426 current_offset += n_bytes_read;
1434 err |= read_block (bytes_per_block, block[idx], &n_bytes_read);
1435 if (n_bytes_read < bytes_per_block)
1437 assert (n_bytes_read == bytes_per_block);
1438 write_block (current_offset, n_bytes_read,
1439 block[!idx], block[idx]);
1440 current_offset += n_bytes_read;
1445 if (n_bytes_read > 0)
1448 size_t bytes_to_write;
1452 /* Make bytes_to_write the smallest multiple of l_c_m that
1453 is at least as large as n_bytes_read. */
1454 bytes_to_write = l_c_m * ((n_bytes_read + l_c_m - 1) / l_c_m);
1456 memset (block[idx] + n_bytes_read, 0, bytes_to_write - n_bytes_read);
1457 write_block (current_offset, bytes_to_write,
1458 block[!idx], block[idx]);
1459 current_offset += n_bytes_read;
1462 format_address (current_offset, '\n');
1464 if (limit_bytes_to_format && current_offset >= end_offset)
1465 err |= check_and_close ();
1470 /* STRINGS mode. Find each "string constant" in the input.
1471 A string constant is a run of at least `string_min' ASCII
1472 graphic (or formatting) characters terminated by a null.
1473 Based on a function written by Richard Stallman for a
1474 pre-POSIX version of od. Return nonzero if an error
1475 occurs. Otherwise, return zero. */
1480 size_t bufsize = MAX (100, string_min);
1481 char *buf = xmalloc (bufsize);
1482 uintmax_t address = n_bytes_to_skip;
1491 /* See if the next `string_min' chars are all printing chars. */
1494 if (limit_bytes_to_format
1495 && (end_offset < string_min || end_offset - string_min <= address))
1498 for (i = 0; i < string_min; i++)
1500 err |= read_char (&c);
1508 /* Found a non-printing. Try again starting with next char. */
1513 /* We found a run of `string_min' printable characters.
1514 Now see if it is terminated with a null byte. */
1515 while (!limit_bytes_to_format || address < end_offset)
1519 bufsize = 1 + 3 * bufsize / 2;
1520 buf = xrealloc (buf, bufsize);
1522 err |= read_char (&c);
1530 break; /* It is; print this string. */
1532 goto tryline; /* It isn't; give up on this string. */
1533 buf[i++] = c; /* String continues; store it all. */
1536 /* If we get here, the string is all printable and null-terminated,
1537 so print it. It is all in `buf' and `i' is its length. */
1539 format_address (address - i - 1, ' ');
1541 for (i = 0; (c = buf[i]); i++)
1546 fputs ("\\a", stdout);
1550 fputs ("\\b", stdout);
1554 fputs ("\\f", stdout);
1558 fputs ("\\n", stdout);
1562 fputs ("\\r", stdout);
1566 fputs ("\\t", stdout);
1570 fputs ("\\v", stdout);
1580 /* We reach this point only if we search through
1581 (max_bytes_to_format - string_min) bytes before reaching EOF. */
1585 err |= check_and_close ();
1590 main (int argc, char **argv)
1596 size_t desired_width IF_LINT (= 0);
1597 int width_specified = 0;
1598 int n_failed_decodes = 0;
1601 /* The old-style `pseudo starting address' to be printed in parentheses
1602 after any true address. */
1603 uintmax_t pseudo_start IF_LINT (= 0);
1605 program_name = argv[0];
1606 setlocale (LC_ALL, "");
1607 bindtextdomain (PACKAGE, LOCALEDIR);
1608 textdomain (PACKAGE);
1610 atexit (close_stdout);
1614 for (i = 0; i <= MAX_INTEGRAL_TYPE_SIZE; i++)
1615 integral_type_size[i] = NO_SIZE;
1617 integral_type_size[sizeof (char)] = CHAR;
1618 integral_type_size[sizeof (short int)] = SHORT;
1619 integral_type_size[sizeof (int)] = INT;
1620 integral_type_size[sizeof (long int)] = LONG;
1621 #if HAVE_UNSIGNED_LONG_LONG
1622 integral_type_size[sizeof (ulonglong_t)] = LONG_LONG;
1625 for (i = 0; i <= MAX_FP_TYPE_SIZE; i++)
1626 fp_type_size[i] = NO_SIZE;
1628 fp_type_size[sizeof (float)] = FLOAT_SINGLE;
1629 /* The array entry for `double' is filled in after that for LONG_DOUBLE
1630 so that if `long double' is the same type or if long double isn't
1631 supported FLOAT_LONG_DOUBLE will never be used. */
1632 fp_type_size[sizeof (LONG_DOUBLE)] = FLOAT_LONG_DOUBLE;
1633 fp_type_size[sizeof (double)] = FLOAT_DOUBLE;
1636 n_specs_allocated = 5;
1637 spec = (struct tspec *) xmalloc (n_specs_allocated * sizeof (struct tspec));
1639 format_address = format_address_std;
1641 address_pad_len = 7;
1642 flag_dump_strings = 0;
1644 while ((c = getopt_long (argc, argv, "abcdfhilos::xw::A:j:N:t:v",
1645 long_options, NULL)) != -1)
1648 enum strtol_error s_err;
1659 format_address = format_address_std;
1661 address_pad_len = 7;
1664 format_address = format_address_std;
1666 address_pad_len = 7;
1669 format_address = format_address_std;
1671 address_pad_len = 6;
1674 format_address = format_address_none;
1675 address_pad_len = 0;
1678 error (EXIT_FAILURE, 0,
1679 _("invalid output address radix `%c'; \
1680 it must be one character from [doxn]"),
1687 s_err = xstrtoumax (optarg, NULL, 0, &n_bytes_to_skip, "bkm");
1688 if (s_err != LONGINT_OK)
1689 STRTOL_FATAL_ERROR (optarg, _("skip argument"), s_err);
1693 limit_bytes_to_format = 1;
1695 s_err = xstrtoumax (optarg, NULL, 0, &max_bytes_to_format, "bkm");
1696 if (s_err != LONGINT_OK)
1697 STRTOL_FATAL_ERROR (optarg, _("limit argument"), s_err);
1705 s_err = xstrtoumax (optarg, NULL, 0, &tmp, "bkm");
1706 if (s_err != LONGINT_OK)
1707 STRTOL_FATAL_ERROR (optarg, _("minimum string length"), s_err);
1709 /* The minimum string length may be no larger than SIZE_MAX,
1710 since we may allocate a buffer of this size. */
1712 error (EXIT_FAILURE, 0, _("%s is too large"), optarg);
1716 flag_dump_strings = 1;
1720 if (decode_format_string (optarg))
1725 abbreviate_duplicate_blocks = 0;
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) \
1740 if (decode_format_string (new_string)) \
1741 ++n_failed_decodes; \
1745 CASE_OLD_ARG ('a', "a");
1746 CASE_OLD_ARG ('b', "oC");
1747 CASE_OLD_ARG ('c', "c");
1748 CASE_OLD_ARG ('d', "u2");
1749 CASE_OLD_ARG ('f', "fF");
1750 CASE_OLD_ARG ('h', "x2");
1751 CASE_OLD_ARG ('i', "d2");
1752 CASE_OLD_ARG ('l', "d4");
1753 CASE_OLD_ARG ('o', "o2");
1754 CASE_OLD_ARG ('x', "x2");
1759 width_specified = 1;
1767 s_err = xstrtoumax (optarg, NULL, 10, &w_tmp, "");
1768 if (s_err != LONGINT_OK)
1769 STRTOL_FATAL_ERROR (optarg, _("width specification"), s_err);
1770 if (SIZE_MAX < w_tmp)
1771 error (EXIT_FAILURE, 0, _("%s is too large"), optarg);
1772 desired_width = w_tmp;
1776 case_GETOPT_HELP_CHAR;
1778 case_GETOPT_VERSION_CHAR (PROGRAM_NAME, AUTHORS);
1786 if (n_failed_decodes > 0)
1787 exit (EXIT_FAILURE);
1789 if (flag_dump_strings && n_specs > 0)
1790 error (EXIT_FAILURE, 0,
1791 _("no type may be specified when dumping strings"));
1793 n_files = argc - optind;
1795 /* If the --backward-compatible option is used, there may be from
1796 0 to 3 remaining command line arguments; handle each case
1798 od [file] [[+]offset[.][b] [[+]label[.][b]]]
1799 The offset and pseudo_start have the same syntax. */
1807 if (parse_old_offset (argv[optind], &offset))
1809 n_bytes_to_skip = offset;
1814 else if (n_files == 2)
1817 if (parse_old_offset (argv[optind], &o1)
1818 && parse_old_offset (argv[optind + 1], &o2))
1820 n_bytes_to_skip = o1;
1821 flag_pseudo_start = 1;
1826 else if (parse_old_offset (argv[optind + 1], &o2))
1828 n_bytes_to_skip = o2;
1830 argv[optind + 1] = argv[optind];
1836 _("invalid second operand in compatibility mode `%s'"),
1841 else if (n_files == 3)
1844 if (parse_old_offset (argv[optind + 1], &o1)
1845 && parse_old_offset (argv[optind + 2], &o2))
1847 n_bytes_to_skip = o1;
1848 flag_pseudo_start = 1;
1850 argv[optind + 2] = argv[optind];
1857 _("in compatibility mode, the last two arguments must be offsets"));
1861 else if (n_files > 3)
1864 _("compatibility mode supports at most three arguments"));
1868 if (flag_pseudo_start)
1870 if (format_address == format_address_none)
1873 address_pad_len = 7;
1874 format_address = format_address_paren;
1877 format_address = format_address_label;
1881 if (limit_bytes_to_format)
1883 end_offset = n_bytes_to_skip + max_bytes_to_format;
1884 if (end_offset < n_bytes_to_skip)
1885 error (EXIT_FAILURE, 0, "skip-bytes + read-bytes is too large");
1890 if (decode_one_format ("o2", "o2", NULL, &(spec[0])))
1892 /* This happens on Cray systems that don't have a 2-byte
1894 exit (EXIT_FAILURE);
1902 /* Set the global pointer FILE_LIST so that it
1903 references the first file-argument on the command-line. */
1905 file_list = (char const *const *) &argv[optind];
1909 /* No files were listed on the command line.
1910 Set the global pointer FILE_LIST so that it
1911 references the null-terminated list of one name: "-". */
1913 file_list = default_file_list;
1916 /* open the first input file */
1917 err |= open_next_file ();
1918 if (in_stream == NULL)
1921 /* skip over any unwanted header bytes */
1922 err |= skip (n_bytes_to_skip);
1923 if (in_stream == NULL)
1926 pseudo_offset = (flag_pseudo_start ? pseudo_start - n_bytes_to_skip : 0);
1928 /* Compute output block length. */
1931 if (width_specified)
1933 if (desired_width != 0 && desired_width % l_c_m == 0)
1934 bytes_per_block = desired_width;
1937 error (0, 0, _("warning: invalid width %lu; using %d instead"),
1938 (unsigned long) desired_width, l_c_m);
1939 bytes_per_block = l_c_m;
1944 if (l_c_m < DEFAULT_BYTES_PER_BLOCK)
1945 bytes_per_block = l_c_m * (DEFAULT_BYTES_PER_BLOCK / l_c_m);
1947 bytes_per_block = l_c_m;
1951 for (i = 0; i < n_specs; i++)
1953 printf (_("%d: fmt=\"%s\" width=%d\n"),
1954 i, spec[i].fmt_string, width_bytes[spec[i].size]);
1958 err |= (flag_dump_strings ? dump_strings () : dump ());
1962 if (have_read_stdin && fclose (stdin) == EOF)
1963 error (EXIT_FAILURE, errno, _("standard input"));
1965 exit (err == 0 ? EXIT_SUCCESS : EXIT_FAILURE);