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\
302 --help display this help and exit\n\
303 --version output version information and exit\n\
307 Pre-POSIX format specifications may be intermixed, they accumulate:\n\
308 -a same as -t a, select named characters\n\
309 -b same as -t oC, select octal bytes\n\
310 -c same as -t c, select ASCII characters or backslash escapes\n\
311 -d same as -t u2, select unsigned decimal shorts\n\
314 -f same as -t fF, select floats\n\
315 -h same as -t x2, select hexadecimal shorts\n\
316 -i same as -t d2, select decimal shorts\n\
317 -l same as -t d4, select decimal longs\n\
318 -o same as -t o2, select octal shorts\n\
319 -x same as -t x2, select hexadecimal shorts\n\
323 For older syntax (second call format), OFFSET means -j OFFSET. LABEL\n\
324 is the pseudo-address at first byte printed, incremented when dump is\n\
325 progressing. For OFFSET and LABEL, a 0x or 0X prefix indicates\n\
326 hexadecimal, suffixes maybe . for octal and b multiply by 512.\n\
328 TYPE is made up of one or more of these specifications:\n\
331 c ASCII character or backslash escape\n\
334 d[SIZE] signed decimal, SIZE bytes per integer\n\
335 f[SIZE] floating point, SIZE bytes per integer\n\
336 o[SIZE] octal, SIZE bytes per integer\n\
337 u[SIZE] unsigned decimal, SIZE bytes per integer\n\
338 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\
344 sizeof(long). If TYPE is f, SIZE may also be F for sizeof(float), D\n\
345 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\
351 with b suffix, by 1024 with k and by 1048576 with m. Adding a z suffix to\n\
352 any type adds a display of printable characters to the end of each line\n\
353 of output. -s without a number implies 3. -w without a number implies 32.\n\
354 By default, od uses -A o -t d2 -w 16.\n\
356 puts (_("\nReport bugs to <bug-textutils@gnu.org>."));
358 exit (status == 0 ? EXIT_SUCCESS : EXIT_FAILURE);
361 /* Compute the greatest common denominator of U and V
362 using Euclid's algorithm. */
365 gcd (unsigned int u, unsigned int v)
377 /* Compute the least common multiple of U and V. */
380 lcm (unsigned int u, unsigned int v)
382 unsigned int t = gcd (u, v);
389 print_s_char (size_t n_bytes, const char *block, const char *fmt_string)
392 for (i = n_bytes; i > 0; i--)
394 int tmp = (unsigned) *(const unsigned char *) block;
396 tmp -= SCHAR_MAX - SCHAR_MIN + 1;
397 assert (tmp <= SCHAR_MAX);
398 printf (fmt_string, tmp);
399 block += sizeof (unsigned char);
404 print_char (size_t n_bytes, const char *block, const char *fmt_string)
407 for (i = n_bytes; i > 0; i--)
409 unsigned int tmp = *(const unsigned char *) block;
410 printf (fmt_string, tmp);
411 block += sizeof (unsigned char);
416 print_s_short (size_t n_bytes, const char *block, const char *fmt_string)
419 for (i = n_bytes / sizeof (unsigned short); i > 0; i--)
421 int tmp = (unsigned) *(const unsigned short *) block;
423 tmp -= SHRT_MAX - SHRT_MIN + 1;
424 assert (tmp <= SHRT_MAX);
425 printf (fmt_string, tmp);
426 block += sizeof (unsigned short);
431 print_short (size_t n_bytes, const char *block, const char *fmt_string)
434 for (i = n_bytes / sizeof (unsigned short); i > 0; i--)
436 unsigned int tmp = *(const unsigned short *) block;
437 printf (fmt_string, tmp);
438 block += sizeof (unsigned short);
443 print_int (size_t n_bytes, const char *block, const char *fmt_string)
446 for (i = n_bytes / sizeof (unsigned int); i > 0; i--)
448 unsigned int tmp = *(const unsigned int *) block;
449 printf (fmt_string, tmp);
450 block += sizeof (unsigned int);
455 print_long (size_t n_bytes, const char *block, const char *fmt_string)
458 for (i = n_bytes / sizeof (unsigned long); i > 0; i--)
460 unsigned long tmp = *(const unsigned long *) block;
461 printf (fmt_string, tmp);
462 block += sizeof (unsigned long);
467 print_long_long (size_t n_bytes, const char *block, const char *fmt_string)
470 for (i = n_bytes / sizeof (ulonglong_t); i > 0; i--)
472 ulonglong_t tmp = *(const ulonglong_t *) block;
473 printf (fmt_string, tmp);
474 block += sizeof (ulonglong_t);
479 print_float (size_t n_bytes, const char *block, const char *fmt_string)
482 for (i = n_bytes / sizeof (float); i > 0; i--)
484 float tmp = *(const float *) block;
485 printf (fmt_string, tmp);
486 block += sizeof (float);
491 print_double (size_t n_bytes, const char *block, const char *fmt_string)
494 for (i = n_bytes / sizeof (double); i > 0; i--)
496 double tmp = *(const double *) block;
497 printf (fmt_string, tmp);
498 block += sizeof (double);
502 #ifdef HAVE_LONG_DOUBLE
504 print_long_double (size_t n_bytes, const char *block, const char *fmt_string)
507 for (i = n_bytes / sizeof (LONG_DOUBLE); i > 0; i--)
509 LONG_DOUBLE tmp = *(const LONG_DOUBLE *) block;
510 printf (fmt_string, tmp);
511 block += sizeof (LONG_DOUBLE);
518 dump_hexl_mode_trailer (size_t n_bytes, const char *block)
521 fputs (" >", stdout);
522 for (i = n_bytes; i > 0; i--)
524 unsigned int c = *(const unsigned char *) block;
525 unsigned int c2 = (ISPRINT(c) ? c : '.');
527 block += sizeof (unsigned char);
533 print_named_ascii (size_t n_bytes, const char *block,
534 const char *unused_fmt_string ATTRIBUTE_UNUSED)
537 for (i = n_bytes; i > 0; i--)
539 unsigned int c = *(const unsigned char *) block;
540 unsigned int masked_c = (0x7f & c);
546 else if (masked_c <= 040)
547 s = charname[masked_c];
550 sprintf (buf, " %c", masked_c);
555 block += sizeof (unsigned char);
560 print_ascii (size_t n_bytes, const char *block,
561 const char *unused_fmt_string ATTRIBUTE_UNUSED)
564 for (i = n_bytes; i > 0; i--)
566 unsigned int c = *(const unsigned char *) block;
605 sprintf (buf, (ISPRINT (c) ? " %c" : "%03o"), c);
606 s = (const char *) buf;
610 block += sizeof (unsigned char);
614 /* Convert a null-terminated (possibly zero-length) string S to an
615 unsigned long integer value. If S points to a non-digit set *P to S,
616 *VAL to 0, and return 0. Otherwise, accumulate the integer value of
617 the string of digits. If the string of digits represents a value
618 larger than ULONG_MAX, don't modify *VAL or *P and return nonzero.
619 Otherwise, advance *P to the first non-digit after S, set *VAL to
620 the result of the conversion and return zero. */
623 simple_strtoul (const char *s, const char **p, long unsigned int *val)
625 unsigned long int sum;
630 unsigned int c = *s++ - '0';
631 if (sum > (ULONG_MAX - c) / 10)
640 /* If S points to a single valid POSIX-style od format string, put
641 a description of that format in *TSPEC, make *NEXT point at the
642 character following the just-decoded format (if *NEXT is non-NULL),
643 and return zero. If S is not valid, don't modify *NEXT or *TSPEC,
644 give a diagnostic, and return nonzero. For example, if S were
645 "d4afL" *NEXT would be set to "afL" and *TSPEC would be
647 fmt = SIGNED_DECIMAL;
648 size = INT or LONG; (whichever integral_type_size[4] resolves to)
649 print_function = print_int; (assuming size == INT)
650 fmt_string = "%011d%c";
652 S_ORIG is solely for reporting errors. It should be the full format
657 decode_one_format (const char *s_orig, const char *s, const char **next,
660 enum size_spec size_spec;
661 unsigned long int size;
662 enum output_format fmt;
663 const char *pre_fmt_string;
665 void (*print_function) PARAMS ((size_t, const char *, const char *));
668 unsigned int field_width = 0;
670 assert (tspec != NULL);
684 size = sizeof (char);
689 size = sizeof (short);
699 size = sizeof (long int);
703 if (simple_strtoul (s, &p, &size) != 0)
705 /* The integer at P in S would overflow an unsigned long.
706 A digit string that long is sufficiently odd looking
707 that the following diagnostic is sufficient. */
708 error (0, 0, _("invalid type string `%s'"), s_orig);
715 if (MAX_INTEGRAL_TYPE_SIZE < size
716 || integral_type_size[size] == NO_SIZE)
718 error (0, 0, _("invalid type string `%s';\n\
719 this system doesn't provide a %lu-byte integral type"), s_orig, size);
727 #define FMT_BYTES_ALLOCATED 9
728 fmt_string = xmalloc (FMT_BYTES_ALLOCATED);
730 size_spec = integral_type_size[size];
735 fmt = SIGNED_DECIMAL;
736 sprintf (fmt_string, " %%%u%sd",
737 (field_width = bytes_to_signed_dec_digits[size]),
738 (size_spec == LONG ? "l"
739 : (size_spec == LONG_LONG ? "ll"
745 sprintf (fmt_string, " %%0%u%so",
746 (field_width = bytes_to_oct_digits[size]),
747 (size_spec == LONG ? "l" : ""));
751 fmt = UNSIGNED_DECIMAL;
752 sprintf (fmt_string, " %%%u%su",
753 (field_width = bytes_to_unsigned_dec_digits[size]),
754 (size_spec == LONG ? "l" : ""));
759 sprintf (fmt_string, " %%0%u%sx",
760 (field_width = bytes_to_hex_digits[size]),
761 (size_spec == LONG ? "l" : ""));
768 assert (strlen (fmt_string) < FMT_BYTES_ALLOCATED);
773 print_function = (fmt == SIGNED_DECIMAL
779 print_function = (fmt == SIGNED_DECIMAL
785 print_function = print_int;
789 print_function = print_long;
793 print_function = print_long_long;
802 fmt = FLOATING_POINT;
808 size = sizeof (float);
813 size = sizeof (double);
818 size = sizeof (LONG_DOUBLE);
822 if (simple_strtoul (s, &p, &size) != 0)
824 /* The integer at P in S would overflow an unsigned long.
825 A digit string that long is sufficiently odd looking
826 that the following diagnostic is sufficient. */
827 error (0, 0, _("invalid type string `%s'"), s_orig);
831 size = sizeof (double);
834 if (size > MAX_FP_TYPE_SIZE
835 || fp_type_size[size] == NO_SIZE)
837 error (0, 0, _("invalid type string `%s';\n\
838 this system doesn't provide a %lu-byte floating point type"), s_orig, size);
845 size_spec = fp_type_size[size];
850 print_function = print_float;
851 /* Don't use %#e; not all systems support it. */
852 pre_fmt_string = " %%%d.%de";
853 fmt_string = xmalloc (strlen (pre_fmt_string));
854 sprintf (fmt_string, pre_fmt_string,
855 (field_width = FLT_DIG + 8), FLT_DIG);
859 print_function = print_double;
860 pre_fmt_string = " %%%d.%de";
861 fmt_string = xmalloc (strlen (pre_fmt_string));
862 sprintf (fmt_string, pre_fmt_string,
863 (field_width = DBL_DIG + 8), DBL_DIG);
866 #ifdef HAVE_LONG_DOUBLE
867 case FLOAT_LONG_DOUBLE:
868 print_function = print_long_double;
869 pre_fmt_string = " %%%d.%dLe";
870 fmt_string = xmalloc (strlen (pre_fmt_string));
871 sprintf (fmt_string, pre_fmt_string,
872 (field_width = LDBL_DIG + 8), LDBL_DIG);
883 fmt = NAMED_CHARACTER;
886 print_function = print_named_ascii;
895 print_function = print_ascii;
900 error (0, 0, _("invalid character `%c' in type string `%s'"),
905 tspec->size = size_spec;
907 tspec->print_function = print_function;
908 tspec->fmt_string = fmt_string;
910 tspec->field_width = field_width;
911 tspec->hexl_mode_trailer = (*s == 'z');
912 if (tspec->hexl_mode_trailer)
921 /* Given a list of one or more input filenames FILE_LIST, set the global
922 file pointer IN_STREAM and the global string INPUT_FILENAME to the
923 first one that can be successfully opened. Modify FILE_LIST to
924 reference the next filename in the list. A file name of "-" is
925 interpreted as standard input. If any file open fails, give an error
926 message and return nonzero. */
929 open_next_file (void)
935 input_filename = *file_list;
936 if (input_filename == NULL)
940 if (STREQ (input_filename, "-"))
942 input_filename = _("standard input");
948 in_stream = fopen (input_filename, "r");
949 if (in_stream == NULL)
951 error (0, errno, "%s", input_filename);
956 while (in_stream == NULL);
958 if (limit_bytes_to_format && !flag_dump_strings)
959 SETVBUF (in_stream, NULL, _IONBF, 0);
960 SET_BINARY (fileno (in_stream));
965 /* Test whether there have been errors on in_stream, and close it if
966 it is not standard input. Return nonzero if there has been an error
967 on in_stream or stdout; return zero otherwise. This function will
968 report more than one error only if both a read and a write error
972 check_and_close (void)
976 if (in_stream != NULL)
978 if (ferror (in_stream))
980 error (0, errno, "%s", input_filename);
981 if (in_stream != stdin)
985 else if (in_stream != stdin && fclose (in_stream) == EOF)
987 error (0, errno, "%s", input_filename);
996 error (0, errno, _("standard output"));
1003 /* Decode the POSIX-style od format string S. Append the decoded
1004 representation to the global array SPEC, reallocating SPEC if
1005 necessary. Return zero if S is valid, nonzero otherwise. */
1008 decode_format_string (const char *s)
1010 const char *s_orig = s;
1018 if (decode_one_format (s_orig, s, &next, &tspec))
1024 if (n_specs >= n_specs_allocated)
1026 n_specs_allocated = 1 + (3 * n_specs_allocated) / 2;
1027 spec = (struct tspec *) xrealloc ((char *) spec,
1029 * sizeof (struct tspec)));
1032 memcpy ((char *) &spec[n_specs], (char *) &tspec,
1033 sizeof (struct tspec));
1040 /* Given a list of one or more input filenames FILE_LIST, set the global
1041 file pointer IN_STREAM to position N_SKIP in the concatenation of
1042 those files. If any file operation fails or if there are fewer than
1043 N_SKIP bytes in the combined input, give an error message and return
1044 nonzero. When possible, use seek rather than read operations to
1045 advance IN_STREAM. */
1048 skip (uintmax_t n_skip)
1055 while (in_stream != NULL) /* EOF. */
1057 struct stat file_stats;
1059 /* First try seeking. For large offsets, this extra work is
1060 worthwhile. If the offset is below some threshold it may be
1061 more efficient to move the pointer by reading. There are two
1062 issues when trying to seek:
1063 - the file must be seekable.
1064 - before seeking to the specified position, make sure
1065 that the new position is in the current file.
1066 Try to do that by getting file's size using fstat.
1067 But that will work only for regular files. */
1069 if (fstat (fileno (in_stream), &file_stats) == 0)
1071 /* The st_size field is valid only for regular files
1072 (and for symbolic links, which cannot occur here).
1073 If the number of bytes left to skip is at least
1074 as large as the size of the current file, we can
1075 decrement n_skip and go on to the next file. */
1077 if (S_ISREG (file_stats.st_mode) && 0 <= file_stats.st_size)
1079 if (file_stats.st_size <= n_skip)
1080 n_skip -= file_stats.st_size;
1083 if (lseek (fileno (in_stream), n_skip, SEEK_CUR) < 0)
1085 error (0, errno, "%s", input_filename);
1092 /* If it's not a regular file with nonnegative size,
1093 position the file pointer by reading. */
1098 size_t n_bytes_read, n_bytes_to_read = BUFSIZ;
1102 if (n_skip < n_bytes_to_read)
1103 n_bytes_to_read = n_skip;
1104 n_bytes_read = fread (buf, 1, n_bytes_to_read, in_stream);
1105 n_skip -= n_bytes_read;
1106 if (n_bytes_read != n_bytes_to_read)
1115 else /* cannot fstat() file */
1117 error (0, errno, "%s", input_filename);
1121 err |= check_and_close ();
1123 err |= open_next_file ();
1127 error (EXIT_FAILURE, 0, _("cannot skip past end of combined input"));
1133 format_address_none (uintmax_t address ATTRIBUTE_UNUSED, char c ATTRIBUTE_UNUSED)
1138 format_address_std (uintmax_t address, char c)
1140 char buf[MAX_ADDRESS_LENGTH + 2];
1141 char *p = buf + sizeof buf;
1146 pbound = p - address_pad_len;
1148 /* Use a special case of the code for each base. This is measurably
1149 faster than generic code. */
1150 switch (address_base)
1154 *--p = '0' + (address & 7);
1155 while ((address >>= 3) != 0);
1160 *--p = '0' + (address % 10);
1161 while ((address /= 10) != 0);
1166 *--p = "0123456789abcdef"[address & 15];
1167 while ((address >>= 4) != 0);
1178 format_address_paren (uintmax_t address, char c)
1181 format_address_std (address, ')');
1186 format_address_label (uintmax_t address, char c)
1188 format_address_std (address, ' ');
1189 format_address_paren (address + pseudo_offset, c);
1192 /* Write N_BYTES bytes from CURR_BLOCK to standard output once for each
1193 of the N_SPEC format specs. CURRENT_OFFSET is the byte address of
1194 CURR_BLOCK in the concatenation of input files, and it is printed
1195 (optionally) only before the output line associated with the first
1196 format spec. When duplicate blocks are being abbreviated, the output
1197 for a sequence of identical input blocks is the output for the first
1198 block followed by an asterisk alone on a line. It is valid to compare
1199 the blocks PREV_BLOCK and CURR_BLOCK only when N_BYTES == BYTES_PER_BLOCK.
1200 That condition may be false only for the last input block -- and then
1201 only when it has not been padded to length BYTES_PER_BLOCK. */
1204 write_block (uintmax_t current_offset, size_t n_bytes,
1205 const char *prev_block, const char *curr_block)
1207 static int first = 1;
1208 static int prev_pair_equal = 0;
1210 #define EQUAL_BLOCKS(b1, b2) (memcmp ((b1), (b2), bytes_per_block) == 0)
1212 if (abbreviate_duplicate_blocks
1213 && !first && n_bytes == bytes_per_block
1214 && EQUAL_BLOCKS (prev_block, curr_block))
1216 if (prev_pair_equal)
1218 /* The two preceding blocks were equal, and the current
1219 block is the same as the last one, so print nothing. */
1224 prev_pair_equal = 1;
1231 prev_pair_equal = 0;
1232 for (i = 0; i < n_specs; i++)
1235 format_address (current_offset, '\0');
1237 printf ("%*s", address_pad_len, "");
1238 (*spec[i].print_function) (n_bytes, curr_block, spec[i].fmt_string);
1239 if (spec[i].hexl_mode_trailer)
1241 /* space-pad out to full line width, then dump the trailer */
1242 int datum_width = width_bytes[spec[i].size];
1243 int blank_fields = (bytes_per_block - n_bytes) / datum_width;
1244 int field_width = spec[i].field_width + 1;
1245 printf ("%*s", blank_fields * field_width, "");
1246 dump_hexl_mode_trailer (n_bytes, curr_block);
1254 /* Read a single byte into *C from the concatenation of the input files
1255 named in the global array FILE_LIST. On the first call to this
1256 function, the global variable IN_STREAM is expected to be an open
1257 stream associated with the input file INPUT_FILENAME. If IN_STREAM
1258 is at end-of-file, close it and update the global variables IN_STREAM
1259 and INPUT_FILENAME so they correspond to the next file in the list.
1260 Then try to read a byte from the newly opened file. Repeat if
1261 necessary until EOF is reached for the last file in FILE_LIST, then
1262 set *C to EOF and return. Subsequent calls do likewise. The return
1263 value is nonzero if any errors occured, zero otherwise. */
1272 while (in_stream != NULL) /* EOF. */
1274 *c = fgetc (in_stream);
1279 err |= check_and_close ();
1281 err |= open_next_file ();
1287 /* Read N bytes into BLOCK from the concatenation of the input files
1288 named in the global array FILE_LIST. On the first call to this
1289 function, the global variable IN_STREAM is expected to be an open
1290 stream associated with the input file INPUT_FILENAME. If all N
1291 bytes cannot be read from IN_STREAM, close IN_STREAM and update
1292 the global variables IN_STREAM and INPUT_FILENAME. Then try to
1293 read the remaining bytes from the newly opened file. Repeat if
1294 necessary until EOF is reached for the last file in FILE_LIST.
1295 On subsequent calls, don't modify BLOCK and return zero. Set
1296 *N_BYTES_IN_BUFFER to the number of bytes read. If an error occurs,
1297 it will be detected through ferror when the stream is about to be
1298 closed. If there is an error, give a message but continue reading
1299 as usual and return nonzero. Otherwise return zero. */
1302 read_block (size_t n, char *block, size_t *n_bytes_in_buffer)
1306 assert (0 < n && n <= bytes_per_block);
1308 *n_bytes_in_buffer = 0;
1313 while (in_stream != NULL) /* EOF. */
1318 n_needed = n - *n_bytes_in_buffer;
1319 n_read = fread (block + *n_bytes_in_buffer, 1, n_needed, in_stream);
1321 *n_bytes_in_buffer += n_read;
1323 if (n_read == n_needed)
1326 err |= check_and_close ();
1328 err |= open_next_file ();
1334 /* Return the least common multiple of the sizes associated
1335 with the format specs. */
1343 for (i = 0; i < n_specs; i++)
1344 l_c_m = lcm (l_c_m, width_bytes[(int) spec[i].size]);
1348 /* If S is a valid pre-POSIX offset specification with an optional leading '+'
1349 return nonzero and set *OFFSET to the offset it denotes. */
1352 parse_old_offset (const char *s, uintmax_t *offset)
1355 enum strtol_error s_err;
1360 /* Skip over any leading '+'. */
1364 /* Determine the radix we'll use to interpret S. If there is a `.',
1365 it's decimal, otherwise, if the string begins with `0X'or `0x',
1366 it's hexadecimal, else octal. */
1367 if (strchr (s, '.') != NULL)
1371 if (s[0] == '0' && (s[1] == 'x' || s[1] == 'X'))
1377 s_err = xstrtoumax (s, NULL, radix, offset, "Bb");
1378 if (s_err != LONGINT_OK)
1380 STRTOL_FAIL_WARN (s, _("old-style offset"), s_err);
1386 /* Read a chunk of size BYTES_PER_BLOCK from the input files, write the
1387 formatted block to standard output, and repeat until the specified
1388 maximum number of bytes has been read or until all input has been
1389 processed. If the last block read is smaller than BYTES_PER_BLOCK
1390 and its size is not a multiple of the size associated with a format
1391 spec, extend the input block with zero bytes until its length is a
1392 multiple of all format spec sizes. Write the final block. Finally,
1393 write on a line by itself the offset of the byte after the last byte
1394 read. Accumulate return values from calls to read_block and
1395 check_and_close, and if any was nonzero, return nonzero.
1396 Otherwise, return zero. */
1402 uintmax_t current_offset;
1405 size_t n_bytes_read;
1407 block[0] = (char *) alloca (bytes_per_block);
1408 block[1] = (char *) alloca (bytes_per_block);
1410 current_offset = n_bytes_to_skip;
1414 if (limit_bytes_to_format)
1419 if (current_offset >= end_offset)
1424 n_needed = MIN (end_offset - current_offset,
1425 (uintmax_t) bytes_per_block);
1426 err |= read_block (n_needed, block[idx], &n_bytes_read);
1427 if (n_bytes_read < bytes_per_block)
1429 assert (n_bytes_read == bytes_per_block);
1430 write_block (current_offset, n_bytes_read,
1431 block[!idx], block[idx]);
1432 current_offset += n_bytes_read;
1440 err |= read_block (bytes_per_block, block[idx], &n_bytes_read);
1441 if (n_bytes_read < bytes_per_block)
1443 assert (n_bytes_read == bytes_per_block);
1444 write_block (current_offset, n_bytes_read,
1445 block[!idx], block[idx]);
1446 current_offset += n_bytes_read;
1451 if (n_bytes_read > 0)
1454 size_t bytes_to_write;
1458 /* Make bytes_to_write the smallest multiple of l_c_m that
1459 is at least as large as n_bytes_read. */
1460 bytes_to_write = l_c_m * ((n_bytes_read + l_c_m - 1) / l_c_m);
1462 memset (block[idx] + n_bytes_read, 0, bytes_to_write - n_bytes_read);
1463 write_block (current_offset, bytes_to_write,
1464 block[!idx], block[idx]);
1465 current_offset += n_bytes_read;
1468 format_address (current_offset, '\n');
1470 if (limit_bytes_to_format && current_offset >= end_offset)
1471 err |= check_and_close ();
1476 /* STRINGS mode. Find each "string constant" in the input.
1477 A string constant is a run of at least `string_min' ASCII
1478 graphic (or formatting) characters terminated by a null.
1479 Based on a function written by Richard Stallman for a
1480 pre-POSIX version of od. Return nonzero if an error
1481 occurs. Otherwise, return zero. */
1486 size_t bufsize = MAX (100, string_min);
1487 char *buf = xmalloc (bufsize);
1488 uintmax_t address = n_bytes_to_skip;
1497 /* See if the next `string_min' chars are all printing chars. */
1500 if (limit_bytes_to_format
1501 && (end_offset < string_min || end_offset - string_min <= address))
1504 for (i = 0; i < string_min; i++)
1506 err |= read_char (&c);
1514 /* Found a non-printing. Try again starting with next char. */
1519 /* We found a run of `string_min' printable characters.
1520 Now see if it is terminated with a null byte. */
1521 while (!limit_bytes_to_format || address < end_offset)
1525 bufsize = 1 + 3 * bufsize / 2;
1526 buf = xrealloc (buf, bufsize);
1528 err |= read_char (&c);
1536 break; /* It is; print this string. */
1538 goto tryline; /* It isn't; give up on this string. */
1539 buf[i++] = c; /* String continues; store it all. */
1542 /* If we get here, the string is all printable and null-terminated,
1543 so print it. It is all in `buf' and `i' is its length. */
1545 format_address (address - i - 1, ' ');
1547 for (i = 0; (c = buf[i]); i++)
1552 fputs ("\\a", stdout);
1556 fputs ("\\b", stdout);
1560 fputs ("\\f", stdout);
1564 fputs ("\\n", stdout);
1568 fputs ("\\r", stdout);
1572 fputs ("\\t", stdout);
1576 fputs ("\\v", stdout);
1586 /* We reach this point only if we search through
1587 (max_bytes_to_format - string_min) bytes before reaching EOF. */
1591 err |= check_and_close ();
1596 main (int argc, char **argv)
1602 size_t desired_width IF_LINT (= 0);
1603 int width_specified = 0;
1604 int n_failed_decodes = 0;
1607 /* The old-style `pseudo starting address' to be printed in parentheses
1608 after any true address. */
1609 uintmax_t pseudo_start IF_LINT (= 0);
1611 program_name = argv[0];
1612 setlocale (LC_ALL, "");
1613 bindtextdomain (PACKAGE, LOCALEDIR);
1614 textdomain (PACKAGE);
1616 atexit (close_stdout);
1620 for (i = 0; i <= MAX_INTEGRAL_TYPE_SIZE; i++)
1621 integral_type_size[i] = NO_SIZE;
1623 integral_type_size[sizeof (char)] = CHAR;
1624 integral_type_size[sizeof (short int)] = SHORT;
1625 integral_type_size[sizeof (int)] = INT;
1626 integral_type_size[sizeof (long int)] = LONG;
1627 #if HAVE_UNSIGNED_LONG_LONG
1628 integral_type_size[sizeof (ulonglong_t)] = LONG_LONG;
1631 for (i = 0; i <= MAX_FP_TYPE_SIZE; i++)
1632 fp_type_size[i] = NO_SIZE;
1634 fp_type_size[sizeof (float)] = FLOAT_SINGLE;
1635 /* The array entry for `double' is filled in after that for LONG_DOUBLE
1636 so that if `long double' is the same type or if long double isn't
1637 supported FLOAT_LONG_DOUBLE will never be used. */
1638 fp_type_size[sizeof (LONG_DOUBLE)] = FLOAT_LONG_DOUBLE;
1639 fp_type_size[sizeof (double)] = FLOAT_DOUBLE;
1642 n_specs_allocated = 5;
1643 spec = (struct tspec *) xmalloc (n_specs_allocated * sizeof (struct tspec));
1645 format_address = format_address_std;
1647 address_pad_len = 7;
1648 flag_dump_strings = 0;
1650 while ((c = getopt_long (argc, argv, "abcdfhilos::xw::A:j:N:t:v",
1651 long_options, NULL)) != -1)
1654 enum strtol_error s_err;
1665 format_address = format_address_std;
1667 address_pad_len = 7;
1670 format_address = format_address_std;
1672 address_pad_len = 7;
1675 format_address = format_address_std;
1677 address_pad_len = 6;
1680 format_address = format_address_none;
1681 address_pad_len = 0;
1684 error (EXIT_FAILURE, 0,
1685 _("invalid output address radix `%c'; \
1686 it must be one character from [doxn]"),
1693 s_err = xstrtoumax (optarg, NULL, 0, &n_bytes_to_skip, "bkm");
1694 if (s_err != LONGINT_OK)
1695 STRTOL_FATAL_ERROR (optarg, _("skip argument"), s_err);
1699 limit_bytes_to_format = 1;
1701 s_err = xstrtoumax (optarg, NULL, 0, &max_bytes_to_format, "bkm");
1702 if (s_err != LONGINT_OK)
1703 STRTOL_FATAL_ERROR (optarg, _("limit argument"), s_err);
1711 s_err = xstrtoumax (optarg, NULL, 0, &tmp, "bkm");
1712 if (s_err != LONGINT_OK)
1713 STRTOL_FATAL_ERROR (optarg, _("minimum string length"), s_err);
1715 /* The minimum string length may be no larger than SIZE_MAX,
1716 since we may allocate a buffer of this size. */
1718 error (EXIT_FAILURE, 0, _("%s is too large"), optarg);
1722 flag_dump_strings = 1;
1726 if (decode_format_string (optarg))
1731 abbreviate_duplicate_blocks = 0;
1738 /* The next several cases map the old, pre-POSIX format
1739 specification options to the corresponding POSIX format
1740 specs. GNU od accepts any combination of old- and
1741 new-style options. Format specification options accumulate. */
1743 #define CASE_OLD_ARG(old_char,new_string) \
1746 if (decode_format_string (new_string)) \
1747 ++n_failed_decodes; \
1751 CASE_OLD_ARG ('a', "a");
1752 CASE_OLD_ARG ('b', "oC");
1753 CASE_OLD_ARG ('c', "c");
1754 CASE_OLD_ARG ('d', "u2");
1755 CASE_OLD_ARG ('f', "fF");
1756 CASE_OLD_ARG ('h', "x2");
1757 CASE_OLD_ARG ('i', "d2");
1758 CASE_OLD_ARG ('l', "d4");
1759 CASE_OLD_ARG ('o', "o2");
1760 CASE_OLD_ARG ('x', "x2");
1765 width_specified = 1;
1773 s_err = xstrtoumax (optarg, NULL, 10, &w_tmp, "");
1774 if (s_err != LONGINT_OK)
1775 STRTOL_FATAL_ERROR (optarg, _("width specification"), s_err);
1776 if (SIZE_MAX < w_tmp)
1777 error (EXIT_FAILURE, 0, _("%s is too large"), optarg);
1778 desired_width = w_tmp;
1782 case_GETOPT_HELP_CHAR;
1784 case_GETOPT_VERSION_CHAR (PROGRAM_NAME, AUTHORS);
1792 if (n_failed_decodes > 0)
1793 exit (EXIT_FAILURE);
1795 if (flag_dump_strings && n_specs > 0)
1796 error (EXIT_FAILURE, 0,
1797 _("no type may be specified when dumping strings"));
1799 n_files = argc - optind;
1801 /* If the --backward-compatible option is used, there may be from
1802 0 to 3 remaining command line arguments; handle each case
1804 od [file] [[+]offset[.][b] [[+]label[.][b]]]
1805 The offset and pseudo_start have the same syntax. */
1813 if (parse_old_offset (argv[optind], &offset))
1815 n_bytes_to_skip = offset;
1820 else if (n_files == 2)
1823 if (parse_old_offset (argv[optind], &o1)
1824 && parse_old_offset (argv[optind + 1], &o2))
1826 n_bytes_to_skip = o1;
1827 flag_pseudo_start = 1;
1832 else if (parse_old_offset (argv[optind + 1], &o2))
1834 n_bytes_to_skip = o2;
1836 argv[optind + 1] = argv[optind];
1842 _("invalid second operand in compatibility mode `%s'"),
1847 else if (n_files == 3)
1850 if (parse_old_offset (argv[optind + 1], &o1)
1851 && parse_old_offset (argv[optind + 2], &o2))
1853 n_bytes_to_skip = o1;
1854 flag_pseudo_start = 1;
1856 argv[optind + 2] = argv[optind];
1863 _("in compatibility mode, the last two arguments must be offsets"));
1867 else if (n_files > 3)
1870 _("compatibility mode supports at most three arguments"));
1874 if (flag_pseudo_start)
1876 if (format_address == format_address_none)
1879 address_pad_len = 7;
1880 format_address = format_address_paren;
1883 format_address = format_address_label;
1887 if (limit_bytes_to_format)
1889 end_offset = n_bytes_to_skip + max_bytes_to_format;
1890 if (end_offset < n_bytes_to_skip)
1891 error (EXIT_FAILURE, 0, "skip-bytes + read-bytes is too large");
1896 if (decode_one_format ("o2", "o2", NULL, &(spec[0])))
1898 /* This happens on Cray systems that don't have a 2-byte
1900 exit (EXIT_FAILURE);
1908 /* Set the global pointer FILE_LIST so that it
1909 references the first file-argument on the command-line. */
1911 file_list = (char const *const *) &argv[optind];
1915 /* No files were listed on the command line.
1916 Set the global pointer FILE_LIST so that it
1917 references the null-terminated list of one name: "-". */
1919 file_list = default_file_list;
1922 /* open the first input file */
1923 err |= open_next_file ();
1924 if (in_stream == NULL)
1927 /* skip over any unwanted header bytes */
1928 err |= skip (n_bytes_to_skip);
1929 if (in_stream == NULL)
1932 pseudo_offset = (flag_pseudo_start ? pseudo_start - n_bytes_to_skip : 0);
1934 /* Compute output block length. */
1937 if (width_specified)
1939 if (desired_width != 0 && desired_width % l_c_m == 0)
1940 bytes_per_block = desired_width;
1943 error (0, 0, _("warning: invalid width %lu; using %d instead"),
1944 (unsigned long) desired_width, l_c_m);
1945 bytes_per_block = l_c_m;
1950 if (l_c_m < DEFAULT_BYTES_PER_BLOCK)
1951 bytes_per_block = l_c_m * (DEFAULT_BYTES_PER_BLOCK / l_c_m);
1953 bytes_per_block = l_c_m;
1957 for (i = 0; i < n_specs; i++)
1959 printf (_("%d: fmt=\"%s\" width=%d\n"),
1960 i, spec[i].fmt_string, width_bytes[spec[i].size]);
1964 err |= (flag_dump_strings ? dump_strings () : dump ());
1968 if (have_read_stdin && fclose (stdin) == EOF)
1969 error (EXIT_FAILURE, errno, _("standard input"));
1971 exit (err == 0 ? EXIT_SUCCESS : EXIT_FAILURE);