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\
287 Mandatory arguments to long options are mandatory for short options too.\n\
290 -A, --address-radix=RADIX decide how file offsets are printed\n\
291 -j, --skip-bytes=BYTES skip BYTES input bytes first\n\
294 -N, --read-bytes=BYTES limit dump to BYTES input bytes\n\
295 -s, --strings[=BYTES] output strings of at least BYTES graphic chars\n\
296 -t, --format=TYPE select output format or formats\n\
297 -v, --output-duplicates do not use * to mark line suppression\n\
298 -w, --width[=BYTES] output BYTES bytes per output line\n\
299 --traditional accept arguments in pre-POSIX form\n\
301 fputs (HELP_OPTION_DESCRIPTION, stdout);
302 fputs (VERSION_OPTION_DESCRIPTION, stdout);
305 Pre-POSIX format specifications may be intermixed, they accumulate:\n\
306 -a same as -t a, select named characters\n\
307 -b same as -t oC, select octal bytes\n\
308 -c same as -t c, select ASCII characters or backslash escapes\n\
309 -d same as -t u2, select unsigned decimal shorts\n\
312 -f same as -t fF, select floats\n\
313 -h same as -t x2, select hexadecimal shorts\n\
314 -i same as -t d2, select decimal shorts\n\
315 -l same as -t d4, select decimal longs\n\
316 -o same as -t o2, select octal shorts\n\
317 -x same as -t x2, select hexadecimal shorts\n\
321 For older syntax (second call format), OFFSET means -j OFFSET. LABEL\n\
322 is the pseudo-address at first byte printed, incremented when dump is\n\
323 progressing. For OFFSET and LABEL, a 0x or 0X prefix indicates\n\
324 hexadecimal, suffixes maybe . for octal and b multiply by 512.\n\
326 TYPE is made up of one or more of these specifications:\n\
329 c ASCII character or backslash escape\n\
332 d[SIZE] signed decimal, SIZE bytes per integer\n\
333 f[SIZE] floating point, SIZE bytes per integer\n\
334 o[SIZE] octal, SIZE bytes per integer\n\
335 u[SIZE] unsigned decimal, SIZE bytes per integer\n\
336 x[SIZE] hexadecimal, SIZE bytes per integer\n\
340 SIZE is a number. For TYPE in doux, SIZE may also be C for\n\
341 sizeof(char), S for sizeof(short), I for sizeof(int) or L for\n\
342 sizeof(long). If TYPE is f, SIZE may also be F for sizeof(float), D\n\
343 for sizeof(double) or L for sizeof(long double).\n\
347 RADIX is d for decimal, o for octal, x for hexadecimal or n for none.\n\
348 BYTES is hexadecimal with 0x or 0X prefix, it is multiplied by 512\n\
349 with b suffix, by 1024 with k and by 1048576 with m. Adding a z suffix to\n\
350 any type adds a display of printable characters to the end of each line\n\
354 -s without a number implies 3. -w without a number implies 32.\n\
355 By default, od uses -A o -t d2 -w 16.\n\
357 puts (_("\nReport bugs to <bug-textutils@gnu.org>."));
359 exit (status == 0 ? EXIT_SUCCESS : EXIT_FAILURE);
362 /* Compute the greatest common denominator of U and V
363 using Euclid's algorithm. */
366 gcd (unsigned int u, unsigned int v)
378 /* Compute the least common multiple of U and V. */
381 lcm (unsigned int u, unsigned int v)
383 unsigned int t = gcd (u, v);
390 print_s_char (size_t n_bytes, const char *block, const char *fmt_string)
393 for (i = n_bytes; i > 0; i--)
395 int tmp = (unsigned) *(const unsigned char *) block;
397 tmp -= SCHAR_MAX - SCHAR_MIN + 1;
398 assert (tmp <= SCHAR_MAX);
399 printf (fmt_string, tmp);
400 block += sizeof (unsigned char);
405 print_char (size_t n_bytes, const char *block, const char *fmt_string)
408 for (i = n_bytes; i > 0; i--)
410 unsigned int tmp = *(const unsigned char *) block;
411 printf (fmt_string, tmp);
412 block += sizeof (unsigned char);
417 print_s_short (size_t n_bytes, const char *block, const char *fmt_string)
420 for (i = n_bytes / sizeof (unsigned short); i > 0; i--)
422 int tmp = (unsigned) *(const unsigned short *) block;
424 tmp -= SHRT_MAX - SHRT_MIN + 1;
425 assert (tmp <= SHRT_MAX);
426 printf (fmt_string, tmp);
427 block += sizeof (unsigned short);
432 print_short (size_t n_bytes, const char *block, const char *fmt_string)
435 for (i = n_bytes / sizeof (unsigned short); i > 0; i--)
437 unsigned int tmp = *(const unsigned short *) block;
438 printf (fmt_string, tmp);
439 block += sizeof (unsigned short);
444 print_int (size_t n_bytes, const char *block, const char *fmt_string)
447 for (i = n_bytes / sizeof (unsigned int); i > 0; i--)
449 unsigned int tmp = *(const unsigned int *) block;
450 printf (fmt_string, tmp);
451 block += sizeof (unsigned int);
456 print_long (size_t n_bytes, const char *block, const char *fmt_string)
459 for (i = n_bytes / sizeof (unsigned long); i > 0; i--)
461 unsigned long tmp = *(const unsigned long *) block;
462 printf (fmt_string, tmp);
463 block += sizeof (unsigned long);
468 print_long_long (size_t n_bytes, const char *block, const char *fmt_string)
471 for (i = n_bytes / sizeof (ulonglong_t); i > 0; i--)
473 ulonglong_t tmp = *(const ulonglong_t *) block;
474 printf (fmt_string, tmp);
475 block += sizeof (ulonglong_t);
480 print_float (size_t n_bytes, const char *block, const char *fmt_string)
483 for (i = n_bytes / sizeof (float); i > 0; i--)
485 float tmp = *(const float *) block;
486 printf (fmt_string, tmp);
487 block += sizeof (float);
492 print_double (size_t n_bytes, const char *block, const char *fmt_string)
495 for (i = n_bytes / sizeof (double); i > 0; i--)
497 double tmp = *(const double *) block;
498 printf (fmt_string, tmp);
499 block += sizeof (double);
503 #ifdef HAVE_LONG_DOUBLE
505 print_long_double (size_t n_bytes, const char *block, const char *fmt_string)
508 for (i = n_bytes / sizeof (LONG_DOUBLE); i > 0; i--)
510 LONG_DOUBLE tmp = *(const LONG_DOUBLE *) block;
511 printf (fmt_string, tmp);
512 block += sizeof (LONG_DOUBLE);
519 dump_hexl_mode_trailer (size_t n_bytes, const char *block)
522 fputs (" >", stdout);
523 for (i = n_bytes; i > 0; i--)
525 unsigned int c = *(const unsigned char *) block;
526 unsigned int c2 = (ISPRINT(c) ? c : '.');
528 block += sizeof (unsigned char);
534 print_named_ascii (size_t n_bytes, const char *block,
535 const char *unused_fmt_string ATTRIBUTE_UNUSED)
538 for (i = n_bytes; i > 0; i--)
540 unsigned int c = *(const unsigned char *) block;
541 unsigned int masked_c = (0x7f & c);
547 else if (masked_c <= 040)
548 s = charname[masked_c];
551 sprintf (buf, " %c", masked_c);
556 block += sizeof (unsigned char);
561 print_ascii (size_t n_bytes, const char *block,
562 const char *unused_fmt_string ATTRIBUTE_UNUSED)
565 for (i = n_bytes; i > 0; i--)
567 unsigned int c = *(const unsigned char *) block;
606 sprintf (buf, (ISPRINT (c) ? " %c" : "%03o"), c);
607 s = (const char *) buf;
611 block += sizeof (unsigned char);
615 /* Convert a null-terminated (possibly zero-length) string S to an
616 unsigned long integer value. If S points to a non-digit set *P to S,
617 *VAL to 0, and return 0. Otherwise, accumulate the integer value of
618 the string of digits. If the string of digits represents a value
619 larger than ULONG_MAX, don't modify *VAL or *P and return nonzero.
620 Otherwise, advance *P to the first non-digit after S, set *VAL to
621 the result of the conversion and return zero. */
624 simple_strtoul (const char *s, const char **p, long unsigned int *val)
626 unsigned long int sum;
631 unsigned int c = *s++ - '0';
632 if (sum > (ULONG_MAX - c) / 10)
641 /* If S points to a single valid POSIX-style od format string, put
642 a description of that format in *TSPEC, make *NEXT point at the
643 character following the just-decoded format (if *NEXT is non-NULL),
644 and return zero. If S is not valid, don't modify *NEXT or *TSPEC,
645 give a diagnostic, and return nonzero. For example, if S were
646 "d4afL" *NEXT would be set to "afL" and *TSPEC would be
648 fmt = SIGNED_DECIMAL;
649 size = INT or LONG; (whichever integral_type_size[4] resolves to)
650 print_function = print_int; (assuming size == INT)
651 fmt_string = "%011d%c";
653 S_ORIG is solely for reporting errors. It should be the full format
658 decode_one_format (const char *s_orig, const char *s, const char **next,
661 enum size_spec size_spec;
662 unsigned long int size;
663 enum output_format fmt;
664 const char *pre_fmt_string;
666 void (*print_function) PARAMS ((size_t, const char *, const char *));
669 unsigned int field_width = 0;
671 assert (tspec != NULL);
685 size = sizeof (char);
690 size = sizeof (short);
700 size = sizeof (long int);
704 if (simple_strtoul (s, &p, &size) != 0)
706 /* The integer at P in S would overflow an unsigned long.
707 A digit string that long is sufficiently odd looking
708 that the following diagnostic is sufficient. */
709 error (0, 0, _("invalid type string `%s'"), s_orig);
716 if (MAX_INTEGRAL_TYPE_SIZE < size
717 || integral_type_size[size] == NO_SIZE)
719 error (0, 0, _("invalid type string `%s';\n\
720 this system doesn't provide a %lu-byte integral type"), s_orig, size);
728 #define FMT_BYTES_ALLOCATED 9
729 fmt_string = xmalloc (FMT_BYTES_ALLOCATED);
731 size_spec = integral_type_size[size];
736 fmt = SIGNED_DECIMAL;
737 sprintf (fmt_string, " %%%u%sd",
738 (field_width = bytes_to_signed_dec_digits[size]),
739 (size_spec == LONG ? "l"
740 : (size_spec == LONG_LONG ? "ll"
746 sprintf (fmt_string, " %%0%u%so",
747 (field_width = bytes_to_oct_digits[size]),
748 (size_spec == LONG ? "l" : ""));
752 fmt = UNSIGNED_DECIMAL;
753 sprintf (fmt_string, " %%%u%su",
754 (field_width = bytes_to_unsigned_dec_digits[size]),
755 (size_spec == LONG ? "l" : ""));
760 sprintf (fmt_string, " %%0%u%sx",
761 (field_width = bytes_to_hex_digits[size]),
762 (size_spec == LONG ? "l" : ""));
769 assert (strlen (fmt_string) < FMT_BYTES_ALLOCATED);
774 print_function = (fmt == SIGNED_DECIMAL
780 print_function = (fmt == SIGNED_DECIMAL
786 print_function = print_int;
790 print_function = print_long;
794 print_function = print_long_long;
803 fmt = FLOATING_POINT;
809 size = sizeof (float);
814 size = sizeof (double);
819 size = sizeof (LONG_DOUBLE);
823 if (simple_strtoul (s, &p, &size) != 0)
825 /* The integer at P in S would overflow an unsigned long.
826 A digit string that long is sufficiently odd looking
827 that the following diagnostic is sufficient. */
828 error (0, 0, _("invalid type string `%s'"), s_orig);
832 size = sizeof (double);
835 if (size > MAX_FP_TYPE_SIZE
836 || fp_type_size[size] == NO_SIZE)
838 error (0, 0, _("invalid type string `%s';\n\
839 this system doesn't provide a %lu-byte floating point type"), s_orig, size);
846 size_spec = fp_type_size[size];
851 print_function = print_float;
852 /* Don't use %#e; not all systems support it. */
853 pre_fmt_string = " %%%d.%de";
854 fmt_string = xmalloc (strlen (pre_fmt_string));
855 sprintf (fmt_string, pre_fmt_string,
856 (field_width = FLT_DIG + 8), FLT_DIG);
860 print_function = print_double;
861 pre_fmt_string = " %%%d.%de";
862 fmt_string = xmalloc (strlen (pre_fmt_string));
863 sprintf (fmt_string, pre_fmt_string,
864 (field_width = DBL_DIG + 8), DBL_DIG);
867 #ifdef HAVE_LONG_DOUBLE
868 case FLOAT_LONG_DOUBLE:
869 print_function = print_long_double;
870 pre_fmt_string = " %%%d.%dLe";
871 fmt_string = xmalloc (strlen (pre_fmt_string));
872 sprintf (fmt_string, pre_fmt_string,
873 (field_width = LDBL_DIG + 8), LDBL_DIG);
884 fmt = NAMED_CHARACTER;
887 print_function = print_named_ascii;
896 print_function = print_ascii;
901 error (0, 0, _("invalid character `%c' in type string `%s'"),
906 tspec->size = size_spec;
908 tspec->print_function = print_function;
909 tspec->fmt_string = fmt_string;
911 tspec->field_width = field_width;
912 tspec->hexl_mode_trailer = (*s == 'z');
913 if (tspec->hexl_mode_trailer)
922 /* Given a list of one or more input filenames FILE_LIST, set the global
923 file pointer IN_STREAM and the global string INPUT_FILENAME to the
924 first one that can be successfully opened. Modify FILE_LIST to
925 reference the next filename in the list. A file name of "-" is
926 interpreted as standard input. If any file open fails, give an error
927 message and return nonzero. */
930 open_next_file (void)
936 input_filename = *file_list;
937 if (input_filename == NULL)
941 if (STREQ (input_filename, "-"))
943 input_filename = _("standard input");
949 in_stream = fopen (input_filename, "r");
950 if (in_stream == NULL)
952 error (0, errno, "%s", input_filename);
957 while (in_stream == NULL);
959 if (limit_bytes_to_format && !flag_dump_strings)
960 SETVBUF (in_stream, NULL, _IONBF, 0);
961 SET_BINARY (fileno (in_stream));
966 /* Test whether there have been errors on in_stream, and close it if
967 it is not standard input. Return nonzero if there has been an error
968 on in_stream or stdout; return zero otherwise. This function will
969 report more than one error only if both a read and a write error
973 check_and_close (void)
977 if (in_stream != NULL)
979 if (ferror (in_stream))
981 error (0, errno, "%s", input_filename);
982 if (in_stream != stdin)
986 else if (in_stream != stdin && fclose (in_stream) == EOF)
988 error (0, errno, "%s", input_filename);
997 error (0, errno, _("standard output"));
1004 /* Decode the POSIX-style od format string S. Append the decoded
1005 representation to the global array SPEC, reallocating SPEC if
1006 necessary. Return zero if S is valid, nonzero otherwise. */
1009 decode_format_string (const char *s)
1011 const char *s_orig = s;
1019 if (decode_one_format (s_orig, s, &next, &tspec))
1025 if (n_specs >= n_specs_allocated)
1027 n_specs_allocated = 1 + (3 * n_specs_allocated) / 2;
1028 spec = (struct tspec *) xrealloc ((char *) spec,
1030 * sizeof (struct tspec)));
1033 memcpy ((char *) &spec[n_specs], (char *) &tspec,
1034 sizeof (struct tspec));
1041 /* Given a list of one or more input filenames FILE_LIST, set the global
1042 file pointer IN_STREAM to position N_SKIP in the concatenation of
1043 those files. If any file operation fails or if there are fewer than
1044 N_SKIP bytes in the combined input, give an error message and return
1045 nonzero. When possible, use seek rather than read operations to
1046 advance IN_STREAM. */
1049 skip (uintmax_t n_skip)
1056 while (in_stream != NULL) /* EOF. */
1058 struct stat file_stats;
1060 /* First try seeking. For large offsets, this extra work is
1061 worthwhile. If the offset is below some threshold it may be
1062 more efficient to move the pointer by reading. There are two
1063 issues when trying to seek:
1064 - the file must be seekable.
1065 - before seeking to the specified position, make sure
1066 that the new position is in the current file.
1067 Try to do that by getting file's size using fstat.
1068 But that will work only for regular files. */
1070 if (fstat (fileno (in_stream), &file_stats) == 0)
1072 /* The st_size field is valid only for regular files
1073 (and for symbolic links, which cannot occur here).
1074 If the number of bytes left to skip is at least
1075 as large as the size of the current file, we can
1076 decrement n_skip and go on to the next file. */
1078 if (S_ISREG (file_stats.st_mode) && 0 <= file_stats.st_size)
1080 if (file_stats.st_size <= n_skip)
1081 n_skip -= file_stats.st_size;
1084 off_t offset = n_skip;
1085 if (offset == n_skip && 0 <= offset
1086 ? fseeko (in_stream, offset, SEEK_CUR) != 0
1087 : (errno = EOVERFLOW, 1))
1089 error (0, errno, "%s", input_filename);
1096 /* If it's not a regular file with nonnegative size,
1097 position the file pointer by reading. */
1102 size_t n_bytes_read, n_bytes_to_read = BUFSIZ;
1106 if (n_skip < n_bytes_to_read)
1107 n_bytes_to_read = n_skip;
1108 n_bytes_read = fread (buf, 1, n_bytes_to_read, in_stream);
1109 n_skip -= n_bytes_read;
1110 if (n_bytes_read != n_bytes_to_read)
1119 else /* cannot fstat() file */
1121 error (0, errno, "%s", input_filename);
1125 err |= check_and_close ();
1127 err |= open_next_file ();
1131 error (EXIT_FAILURE, 0, _("cannot skip past end of combined input"));
1137 format_address_none (uintmax_t address ATTRIBUTE_UNUSED, char c ATTRIBUTE_UNUSED)
1142 format_address_std (uintmax_t address, char c)
1144 char buf[MAX_ADDRESS_LENGTH + 2];
1145 char *p = buf + sizeof buf;
1150 pbound = p - address_pad_len;
1152 /* Use a special case of the code for each base. This is measurably
1153 faster than generic code. */
1154 switch (address_base)
1158 *--p = '0' + (address & 7);
1159 while ((address >>= 3) != 0);
1164 *--p = '0' + (address % 10);
1165 while ((address /= 10) != 0);
1170 *--p = "0123456789abcdef"[address & 15];
1171 while ((address >>= 4) != 0);
1182 format_address_paren (uintmax_t address, char c)
1185 format_address_std (address, ')');
1190 format_address_label (uintmax_t address, char c)
1192 format_address_std (address, ' ');
1193 format_address_paren (address + pseudo_offset, c);
1196 /* Write N_BYTES bytes from CURR_BLOCK to standard output once for each
1197 of the N_SPEC format specs. CURRENT_OFFSET is the byte address of
1198 CURR_BLOCK in the concatenation of input files, and it is printed
1199 (optionally) only before the output line associated with the first
1200 format spec. When duplicate blocks are being abbreviated, the output
1201 for a sequence of identical input blocks is the output for the first
1202 block followed by an asterisk alone on a line. It is valid to compare
1203 the blocks PREV_BLOCK and CURR_BLOCK only when N_BYTES == BYTES_PER_BLOCK.
1204 That condition may be false only for the last input block -- and then
1205 only when it has not been padded to length BYTES_PER_BLOCK. */
1208 write_block (uintmax_t current_offset, size_t n_bytes,
1209 const char *prev_block, const char *curr_block)
1211 static int first = 1;
1212 static int prev_pair_equal = 0;
1214 #define EQUAL_BLOCKS(b1, b2) (memcmp ((b1), (b2), bytes_per_block) == 0)
1216 if (abbreviate_duplicate_blocks
1217 && !first && n_bytes == bytes_per_block
1218 && EQUAL_BLOCKS (prev_block, curr_block))
1220 if (prev_pair_equal)
1222 /* The two preceding blocks were equal, and the current
1223 block is the same as the last one, so print nothing. */
1228 prev_pair_equal = 1;
1235 prev_pair_equal = 0;
1236 for (i = 0; i < n_specs; i++)
1239 format_address (current_offset, '\0');
1241 printf ("%*s", address_pad_len, "");
1242 (*spec[i].print_function) (n_bytes, curr_block, spec[i].fmt_string);
1243 if (spec[i].hexl_mode_trailer)
1245 /* space-pad out to full line width, then dump the trailer */
1246 int datum_width = width_bytes[spec[i].size];
1247 int blank_fields = (bytes_per_block - n_bytes) / datum_width;
1248 int field_width = spec[i].field_width + 1;
1249 printf ("%*s", blank_fields * field_width, "");
1250 dump_hexl_mode_trailer (n_bytes, curr_block);
1258 /* Read a single byte into *C from the concatenation of the input files
1259 named in the global array FILE_LIST. On the first call to this
1260 function, the global variable IN_STREAM is expected to be an open
1261 stream associated with the input file INPUT_FILENAME. If IN_STREAM
1262 is at end-of-file, close it and update the global variables IN_STREAM
1263 and INPUT_FILENAME so they correspond to the next file in the list.
1264 Then try to read a byte from the newly opened file. Repeat if
1265 necessary until EOF is reached for the last file in FILE_LIST, then
1266 set *C to EOF and return. Subsequent calls do likewise. The return
1267 value is nonzero if any errors occured, zero otherwise. */
1276 while (in_stream != NULL) /* EOF. */
1278 *c = fgetc (in_stream);
1283 err |= check_and_close ();
1285 err |= open_next_file ();
1291 /* Read N bytes into BLOCK from the concatenation of the input files
1292 named in the global array FILE_LIST. On the first call to this
1293 function, the global variable IN_STREAM is expected to be an open
1294 stream associated with the input file INPUT_FILENAME. If all N
1295 bytes cannot be read from IN_STREAM, close IN_STREAM and update
1296 the global variables IN_STREAM and INPUT_FILENAME. Then try to
1297 read the remaining bytes from the newly opened file. Repeat if
1298 necessary until EOF is reached for the last file in FILE_LIST.
1299 On subsequent calls, don't modify BLOCK and return zero. Set
1300 *N_BYTES_IN_BUFFER to the number of bytes read. If an error occurs,
1301 it will be detected through ferror when the stream is about to be
1302 closed. If there is an error, give a message but continue reading
1303 as usual and return nonzero. Otherwise return zero. */
1306 read_block (size_t n, char *block, size_t *n_bytes_in_buffer)
1310 assert (0 < n && n <= bytes_per_block);
1312 *n_bytes_in_buffer = 0;
1317 while (in_stream != NULL) /* EOF. */
1322 n_needed = n - *n_bytes_in_buffer;
1323 n_read = fread (block + *n_bytes_in_buffer, 1, n_needed, in_stream);
1325 *n_bytes_in_buffer += n_read;
1327 if (n_read == n_needed)
1330 err |= check_and_close ();
1332 err |= open_next_file ();
1338 /* Return the least common multiple of the sizes associated
1339 with the format specs. */
1347 for (i = 0; i < n_specs; i++)
1348 l_c_m = lcm (l_c_m, width_bytes[(int) spec[i].size]);
1352 /* If S is a valid pre-POSIX offset specification with an optional leading '+'
1353 return nonzero and set *OFFSET to the offset it denotes. */
1356 parse_old_offset (const char *s, uintmax_t *offset)
1359 enum strtol_error s_err;
1364 /* Skip over any leading '+'. */
1368 /* Determine the radix we'll use to interpret S. If there is a `.',
1369 it's decimal, otherwise, if the string begins with `0X'or `0x',
1370 it's hexadecimal, else octal. */
1371 if (strchr (s, '.') != NULL)
1375 if (s[0] == '0' && (s[1] == 'x' || s[1] == 'X'))
1381 s_err = xstrtoumax (s, NULL, radix, offset, "Bb");
1382 if (s_err != LONGINT_OK)
1384 STRTOL_FAIL_WARN (s, _("old-style offset"), s_err);
1390 /* Read a chunk of size BYTES_PER_BLOCK from the input files, write the
1391 formatted block to standard output, and repeat until the specified
1392 maximum number of bytes has been read or until all input has been
1393 processed. If the last block read is smaller than BYTES_PER_BLOCK
1394 and its size is not a multiple of the size associated with a format
1395 spec, extend the input block with zero bytes until its length is a
1396 multiple of all format spec sizes. Write the final block. Finally,
1397 write on a line by itself the offset of the byte after the last byte
1398 read. Accumulate return values from calls to read_block and
1399 check_and_close, and if any was nonzero, return nonzero.
1400 Otherwise, return zero. */
1406 uintmax_t current_offset;
1409 size_t n_bytes_read;
1411 block[0] = (char *) alloca (bytes_per_block);
1412 block[1] = (char *) alloca (bytes_per_block);
1414 current_offset = n_bytes_to_skip;
1418 if (limit_bytes_to_format)
1423 if (current_offset >= end_offset)
1428 n_needed = MIN (end_offset - current_offset,
1429 (uintmax_t) bytes_per_block);
1430 err |= read_block (n_needed, block[idx], &n_bytes_read);
1431 if (n_bytes_read < bytes_per_block)
1433 assert (n_bytes_read == bytes_per_block);
1434 write_block (current_offset, n_bytes_read,
1435 block[!idx], block[idx]);
1436 current_offset += n_bytes_read;
1444 err |= read_block (bytes_per_block, block[idx], &n_bytes_read);
1445 if (n_bytes_read < bytes_per_block)
1447 assert (n_bytes_read == bytes_per_block);
1448 write_block (current_offset, n_bytes_read,
1449 block[!idx], block[idx]);
1450 current_offset += n_bytes_read;
1455 if (n_bytes_read > 0)
1458 size_t bytes_to_write;
1462 /* Make bytes_to_write the smallest multiple of l_c_m that
1463 is at least as large as n_bytes_read. */
1464 bytes_to_write = l_c_m * ((n_bytes_read + l_c_m - 1) / l_c_m);
1466 memset (block[idx] + n_bytes_read, 0, bytes_to_write - n_bytes_read);
1467 write_block (current_offset, bytes_to_write,
1468 block[!idx], block[idx]);
1469 current_offset += n_bytes_read;
1472 format_address (current_offset, '\n');
1474 if (limit_bytes_to_format && current_offset >= end_offset)
1475 err |= check_and_close ();
1480 /* STRINGS mode. Find each "string constant" in the input.
1481 A string constant is a run of at least `string_min' ASCII
1482 graphic (or formatting) characters terminated by a null.
1483 Based on a function written by Richard Stallman for a
1484 pre-POSIX version of od. Return nonzero if an error
1485 occurs. Otherwise, return zero. */
1490 size_t bufsize = MAX (100, string_min);
1491 char *buf = xmalloc (bufsize);
1492 uintmax_t address = n_bytes_to_skip;
1501 /* See if the next `string_min' chars are all printing chars. */
1504 if (limit_bytes_to_format
1505 && (end_offset < string_min || end_offset - string_min <= address))
1508 for (i = 0; i < string_min; i++)
1510 err |= read_char (&c);
1518 /* Found a non-printing. Try again starting with next char. */
1523 /* We found a run of `string_min' printable characters.
1524 Now see if it is terminated with a null byte. */
1525 while (!limit_bytes_to_format || address < end_offset)
1529 bufsize = 1 + 3 * bufsize / 2;
1530 buf = xrealloc (buf, bufsize);
1532 err |= read_char (&c);
1540 break; /* It is; print this string. */
1542 goto tryline; /* It isn't; give up on this string. */
1543 buf[i++] = c; /* String continues; store it all. */
1546 /* If we get here, the string is all printable and null-terminated,
1547 so print it. It is all in `buf' and `i' is its length. */
1549 format_address (address - i - 1, ' ');
1551 for (i = 0; (c = buf[i]); i++)
1556 fputs ("\\a", stdout);
1560 fputs ("\\b", stdout);
1564 fputs ("\\f", stdout);
1568 fputs ("\\n", stdout);
1572 fputs ("\\r", stdout);
1576 fputs ("\\t", stdout);
1580 fputs ("\\v", stdout);
1590 /* We reach this point only if we search through
1591 (max_bytes_to_format - string_min) bytes before reaching EOF. */
1595 err |= check_and_close ();
1600 main (int argc, char **argv)
1606 size_t desired_width IF_LINT (= 0);
1607 int width_specified = 0;
1608 int n_failed_decodes = 0;
1611 /* The old-style `pseudo starting address' to be printed in parentheses
1612 after any true address. */
1613 uintmax_t pseudo_start IF_LINT (= 0);
1615 program_name = argv[0];
1616 setlocale (LC_ALL, "");
1617 bindtextdomain (PACKAGE, LOCALEDIR);
1618 textdomain (PACKAGE);
1620 atexit (close_stdout);
1624 for (i = 0; i <= MAX_INTEGRAL_TYPE_SIZE; i++)
1625 integral_type_size[i] = NO_SIZE;
1627 integral_type_size[sizeof (char)] = CHAR;
1628 integral_type_size[sizeof (short int)] = SHORT;
1629 integral_type_size[sizeof (int)] = INT;
1630 integral_type_size[sizeof (long int)] = LONG;
1631 #if HAVE_UNSIGNED_LONG_LONG
1632 integral_type_size[sizeof (ulonglong_t)] = LONG_LONG;
1635 for (i = 0; i <= MAX_FP_TYPE_SIZE; i++)
1636 fp_type_size[i] = NO_SIZE;
1638 fp_type_size[sizeof (float)] = FLOAT_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 FLOAT_LONG_DOUBLE will never be used. */
1642 fp_type_size[sizeof (LONG_DOUBLE)] = FLOAT_LONG_DOUBLE;
1643 fp_type_size[sizeof (double)] = FLOAT_DOUBLE;
1646 n_specs_allocated = 5;
1647 spec = (struct tspec *) xmalloc (n_specs_allocated * sizeof (struct tspec));
1649 format_address = format_address_std;
1651 address_pad_len = 7;
1652 flag_dump_strings = 0;
1654 while ((c = getopt_long (argc, argv, "abcdfhilos::xw::A:j:N:t:v",
1655 long_options, NULL)) != -1)
1658 enum strtol_error s_err;
1669 format_address = format_address_std;
1671 address_pad_len = 7;
1674 format_address = format_address_std;
1676 address_pad_len = 7;
1679 format_address = format_address_std;
1681 address_pad_len = 6;
1684 format_address = format_address_none;
1685 address_pad_len = 0;
1688 error (EXIT_FAILURE, 0,
1689 _("invalid output address radix `%c'; \
1690 it must be one character from [doxn]"),
1697 s_err = xstrtoumax (optarg, NULL, 0, &n_bytes_to_skip, "bkm");
1698 if (s_err != LONGINT_OK)
1699 STRTOL_FATAL_ERROR (optarg, _("skip argument"), s_err);
1703 limit_bytes_to_format = 1;
1705 s_err = xstrtoumax (optarg, NULL, 0, &max_bytes_to_format, "bkm");
1706 if (s_err != LONGINT_OK)
1707 STRTOL_FATAL_ERROR (optarg, _("limit argument"), s_err);
1715 s_err = xstrtoumax (optarg, NULL, 0, &tmp, "bkm");
1716 if (s_err != LONGINT_OK)
1717 STRTOL_FATAL_ERROR (optarg, _("minimum string length"), s_err);
1719 /* The minimum string length may be no larger than SIZE_MAX,
1720 since we may allocate a buffer of this size. */
1722 error (EXIT_FAILURE, 0, _("%s is too large"), optarg);
1726 flag_dump_strings = 1;
1730 if (decode_format_string (optarg))
1735 abbreviate_duplicate_blocks = 0;
1742 /* The next several cases map the old, pre-POSIX format
1743 specification options to the corresponding POSIX format
1744 specs. GNU od accepts any combination of old- and
1745 new-style options. Format specification options accumulate. */
1747 #define CASE_OLD_ARG(old_char,new_string) \
1750 if (decode_format_string (new_string)) \
1751 ++n_failed_decodes; \
1755 CASE_OLD_ARG ('a', "a");
1756 CASE_OLD_ARG ('b', "oC");
1757 CASE_OLD_ARG ('c', "c");
1758 CASE_OLD_ARG ('d', "u2");
1759 CASE_OLD_ARG ('f', "fF");
1760 CASE_OLD_ARG ('h', "x2");
1761 CASE_OLD_ARG ('i', "d2");
1762 CASE_OLD_ARG ('l', "d4");
1763 CASE_OLD_ARG ('o', "o2");
1764 CASE_OLD_ARG ('x', "x2");
1769 width_specified = 1;
1777 s_err = xstrtoumax (optarg, NULL, 10, &w_tmp, "");
1778 if (s_err != LONGINT_OK)
1779 STRTOL_FATAL_ERROR (optarg, _("width specification"), s_err);
1780 if (SIZE_MAX < w_tmp)
1781 error (EXIT_FAILURE, 0, _("%s is too large"), optarg);
1782 desired_width = w_tmp;
1786 case_GETOPT_HELP_CHAR;
1788 case_GETOPT_VERSION_CHAR (PROGRAM_NAME, AUTHORS);
1796 if (n_failed_decodes > 0)
1797 exit (EXIT_FAILURE);
1799 if (flag_dump_strings && n_specs > 0)
1800 error (EXIT_FAILURE, 0,
1801 _("no type may be specified when dumping strings"));
1803 n_files = argc - optind;
1805 /* If the --backward-compatible option is used, there may be from
1806 0 to 3 remaining command line arguments; handle each case
1808 od [file] [[+]offset[.][b] [[+]label[.][b]]]
1809 The offset and pseudo_start have the same syntax. */
1817 if (parse_old_offset (argv[optind], &offset))
1819 n_bytes_to_skip = offset;
1824 else if (n_files == 2)
1827 if (parse_old_offset (argv[optind], &o1)
1828 && parse_old_offset (argv[optind + 1], &o2))
1830 n_bytes_to_skip = o1;
1831 flag_pseudo_start = 1;
1836 else if (parse_old_offset (argv[optind + 1], &o2))
1838 n_bytes_to_skip = o2;
1840 argv[optind + 1] = argv[optind];
1846 _("invalid second operand in compatibility mode `%s'"),
1851 else if (n_files == 3)
1854 if (parse_old_offset (argv[optind + 1], &o1)
1855 && parse_old_offset (argv[optind + 2], &o2))
1857 n_bytes_to_skip = o1;
1858 flag_pseudo_start = 1;
1860 argv[optind + 2] = argv[optind];
1867 _("in compatibility mode, the last two arguments must be offsets"));
1871 else if (n_files > 3)
1874 _("compatibility mode supports at most three arguments"));
1878 if (flag_pseudo_start)
1880 if (format_address == format_address_none)
1883 address_pad_len = 7;
1884 format_address = format_address_paren;
1887 format_address = format_address_label;
1891 if (limit_bytes_to_format)
1893 end_offset = n_bytes_to_skip + max_bytes_to_format;
1894 if (end_offset < n_bytes_to_skip)
1895 error (EXIT_FAILURE, 0, "skip-bytes + read-bytes is too large");
1900 if (decode_one_format ("o2", "o2", NULL, &(spec[0])))
1902 /* This happens on Cray systems that don't have a 2-byte
1904 exit (EXIT_FAILURE);
1912 /* Set the global pointer FILE_LIST so that it
1913 references the first file-argument on the command-line. */
1915 file_list = (char const *const *) &argv[optind];
1919 /* No files were listed on the command line.
1920 Set the global pointer FILE_LIST so that it
1921 references the null-terminated list of one name: "-". */
1923 file_list = default_file_list;
1926 /* open the first input file */
1927 err |= open_next_file ();
1928 if (in_stream == NULL)
1931 /* skip over any unwanted header bytes */
1932 err |= skip (n_bytes_to_skip);
1933 if (in_stream == NULL)
1936 pseudo_offset = (flag_pseudo_start ? pseudo_start - n_bytes_to_skip : 0);
1938 /* Compute output block length. */
1941 if (width_specified)
1943 if (desired_width != 0 && desired_width % l_c_m == 0)
1944 bytes_per_block = desired_width;
1947 error (0, 0, _("warning: invalid width %lu; using %d instead"),
1948 (unsigned long) desired_width, l_c_m);
1949 bytes_per_block = l_c_m;
1954 if (l_c_m < DEFAULT_BYTES_PER_BLOCK)
1955 bytes_per_block = l_c_m * (DEFAULT_BYTES_PER_BLOCK / l_c_m);
1957 bytes_per_block = l_c_m;
1961 for (i = 0; i < n_specs; i++)
1963 printf (_("%d: fmt=\"%s\" width=%d\n"),
1964 i, spec[i].fmt_string, width_bytes[spec[i].size]);
1968 err |= (flag_dump_strings ? dump_strings () : dump ());
1972 if (have_read_stdin && fclose (stdin) == EOF)
1973 error (EXIT_FAILURE, errno, _("standard input"));
1975 exit (err == 0 ? EXIT_SUCCESS : EXIT_FAILURE);