1 /* od -- dump files in octal and other formats
2 Copyright (C) 92, 1995-2001 Free Software Foundation, Inc.
4 This program is free software; you can redistribute it and/or modify
5 it under the terms of the GNU General Public License as published by
6 the Free Software Foundation; either version 2, or (at your option)
9 This program is distributed in the hope that it will be useful,
10 but WITHOUT ANY WARRANTY; without even the implied warranty of
11 MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
12 GNU General Public License for more details.
14 You should have received a copy of the GNU General Public License
15 along with this program; if not, write to the Free Software Foundation,
16 Inc., 59 Temple Place - Suite 330, Boston, MA 02111-1307, USA. */
18 /* Written by Jim Meyering. */
25 #include <sys/types.h>
31 /* The official name of this program (e.g., no `g' prefix). */
32 #define PROGRAM_NAME "od"
34 #define AUTHORS "Jim Meyering"
36 #if defined(__GNUC__) || defined(STDC_HEADERS)
40 #ifdef HAVE_LONG_DOUBLE
41 typedef long double LONG_DOUBLE;
43 typedef double LONG_DOUBLE;
50 /* The default number of input bytes per output line. */
51 #define DEFAULT_BYTES_PER_BLOCK 16
53 /* The number of decimal digits of precision in a float. */
58 /* The number of decimal digits of precision in a double. */
63 /* The number of decimal digits of precision in a long double. */
65 # define LDBL_DIG DBL_DIG
76 /* FIXME: add INTMAX support, too */
93 /* Each output format specification (from POSIX `-t spec' or from
94 old-style options) is represented by one of these structures. */
97 enum output_format fmt;
99 void (*print_function) ();
101 int hexl_mode_trailer;
105 /* The name this program was run with. */
108 /* Convert the number of 8-bit bytes of a binary representation to
109 the number of characters (digits + sign if the type is signed)
110 required to represent the same quantity in the specified base/type.
111 For example, a 32-bit (4-byte) quantity may require a field width
112 as wide as the following for these types:
116 8 unsigned hexadecimal */
118 static const unsigned int bytes_to_oct_digits[] =
119 {0, 3, 6, 8, 11, 14, 16, 19, 22, 25, 27, 30, 32, 35, 38, 41, 43};
121 static const unsigned int bytes_to_signed_dec_digits[] =
122 {1, 4, 6, 8, 11, 13, 16, 18, 20, 23, 25, 28, 30, 33, 35, 37, 40};
124 static const unsigned int bytes_to_unsigned_dec_digits[] =
125 {0, 3, 5, 8, 10, 13, 15, 17, 20, 22, 25, 27, 29, 32, 34, 37, 39};
127 static const unsigned int bytes_to_hex_digits[] =
128 {0, 2, 4, 6, 8, 10, 12, 14, 16, 18, 20, 22, 24, 26, 28, 30, 32};
130 /* Convert enum size_spec to the size of the named type. */
131 static const int width_bytes[] =
143 /* Names for some non-printing characters. */
144 static const char *const charname[33] =
146 "nul", "soh", "stx", "etx", "eot", "enq", "ack", "bel",
147 "bs", "ht", "nl", "vt", "ff", "cr", "so", "si",
148 "dle", "dc1", "dc2", "dc3", "dc4", "nak", "syn", "etb",
149 "can", "em", "sub", "esc", "fs", "gs", "rs", "us",
153 /* Address base (8, 10 or 16). */
154 static int address_base;
156 /* The number of octal digits required to represent the largest
158 #define MAX_ADDRESS_LENGTH \
159 ((sizeof (uintmax_t) * CHAR_BIT + CHAR_BIT - 1) / 3)
161 /* Width of a normal address. */
162 static int address_pad_len;
164 static size_t string_min;
165 static int flag_dump_strings;
167 /* Non-zero if we should recognize the pre-POSIX non-option arguments
168 that specified at most one file and optional arguments specifying
169 offset and pseudo-start address. */
170 static int traditional;
172 /* Non-zero if an old-style `pseudo-address' was specified. */
173 static int flag_pseudo_start;
175 /* The difference between the old-style pseudo starting address and
176 the number of bytes to skip. */
177 static uintmax_t pseudo_offset;
179 /* Function that accepts an address and an optional following char,
180 and prints the address and char to stdout. */
181 static void (*format_address) PARAMS ((uintmax_t, char));
183 /* The number of input bytes to skip before formatting and writing. */
184 static uintmax_t n_bytes_to_skip = 0;
186 /* When zero, MAX_BYTES_TO_FORMAT and END_OFFSET are ignored, and all
187 input is formatted. */
188 static int limit_bytes_to_format = 0;
190 /* The maximum number of bytes that will be formatted. */
191 static uintmax_t max_bytes_to_format;
193 /* The offset of the first byte after the last byte to be formatted. */
194 static uintmax_t end_offset;
196 /* When nonzero and two or more consecutive blocks are equal, format
197 only the first block and output an asterisk alone on the following
198 line to indicate that identical blocks have been elided. */
199 static int abbreviate_duplicate_blocks = 1;
201 /* An array of specs describing how to format each input block. */
202 static struct tspec *spec;
204 /* The number of format specs. */
205 static size_t n_specs;
207 /* The allocated length of SPEC. */
208 static size_t n_specs_allocated;
210 /* The number of input bytes formatted per output line. It must be
211 a multiple of the least common multiple of the sizes associated with
212 the specified output types. It should be as large as possible, but
213 no larger than 16 -- unless specified with the -w option. */
214 static size_t bytes_per_block;
216 /* Human-readable representation of *file_list (for error messages).
217 It differs from *file_list only when *file_list is "-". */
218 static char const *input_filename;
220 /* A NULL-terminated list of the file-arguments from the command line. */
221 static char const *const *file_list;
223 /* Initializer for file_list if no file-arguments
224 were specified on the command line. */
225 static char const *const default_file_list[] = {"-", NULL};
227 /* The input stream associated with the current file. */
228 static FILE *in_stream;
230 /* If nonzero, at least one of the files we read was standard input. */
231 static int have_read_stdin;
233 #if HAVE_UNSIGNED_LONG_LONG
234 typedef unsigned long long ulonglong_t;
236 /* This is just a place-holder to avoid a few `#if' directives.
237 In this case, the type isn't actually used. */
238 typedef unsigned long int ulonglong_t;
241 #define MAX_INTEGRAL_TYPE_SIZE sizeof (ulonglong_t)
242 static enum size_spec integral_type_size[MAX_INTEGRAL_TYPE_SIZE + 1];
244 #define MAX_FP_TYPE_SIZE sizeof(LONG_DOUBLE)
245 static enum size_spec fp_type_size[MAX_FP_TYPE_SIZE + 1];
247 static struct option const long_options[] =
250 {"skip-bytes", required_argument, NULL, 'j'},
251 {"address-radix", required_argument, NULL, 'A'},
252 {"read-bytes", required_argument, NULL, 'N'},
253 {"format", required_argument, NULL, 't'},
254 {"output-duplicates", no_argument, NULL, 'v'},
256 /* non-POSIX options. */
257 {"strings", optional_argument, NULL, 's'},
258 {"traditional", no_argument, NULL, 'B'},
259 {"width", optional_argument, NULL, 'w'},
261 {GETOPT_HELP_OPTION_DECL},
262 {GETOPT_VERSION_OPTION_DECL},
270 fprintf (stderr, _("Try `%s --help' for more information.\n"),
275 Usage: %s [OPTION]... [FILE]...\n\
276 or: %s --traditional [FILE] [[+]OFFSET [[+]LABEL]]\n\
278 program_name, program_name);
280 Write an unambiguous representation, octal bytes by default,\n\
281 of FILE to standard output. With more than one FILE argument,\n\
282 concatenate them in the listed order to form the input.\n\
283 With no FILE, or when FILE is -, read standard input.\n\
285 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\
288 -N, --read-bytes=BYTES limit dump to BYTES input bytes\n\
289 -s, --strings[=BYTES] output strings of at least BYTES graphic chars\n\
290 -t, --format=TYPE select output format or formats\n\
291 -v, --output-duplicates do not use * to mark line suppression\n\
292 -w, --width[=BYTES] output BYTES bytes per output line\n\
293 --traditional accept arguments in pre-POSIX form\n\
294 --help display this help and exit\n\
295 --version output version information and exit\n\
297 Pre-POSIX format specifications may be intermixed, they accumulate:\n\
298 -a same as -t a, select named characters\n\
299 -b same as -t oC, select octal bytes\n\
300 -c same as -t c, select ASCII characters or backslash escapes\n\
301 -d same as -t u2, select unsigned decimal shorts\n\
302 -f same as -t fF, select floats\n\
303 -h same as -t x2, select hexadecimal shorts\n\
304 -i same as -t d2, select decimal shorts\n\
305 -l same as -t d4, select decimal longs\n\
306 -o same as -t o2, select octal shorts\n\
307 -x same as -t x2, select hexadecimal shorts\n\
311 For older syntax (second call format), OFFSET means -j OFFSET. LABEL\n\
312 is the pseudo-address at first byte printed, incremented when dump is\n\
313 progressing. For OFFSET and LABEL, a 0x or 0X prefix indicates\n\
314 hexadecimal, suffixes maybe . for octal and b multiply by 512.\n\
316 TYPE is made up of one or more of these specifications:\n\
319 c ASCII character or backslash escape\n\
320 d[SIZE] signed decimal, SIZE bytes per integer\n\
321 f[SIZE] floating point, SIZE bytes per integer\n\
322 o[SIZE] octal, SIZE bytes per integer\n\
323 u[SIZE] unsigned decimal, SIZE bytes per integer\n\
324 x[SIZE] hexadecimal, SIZE bytes per integer\n\
326 SIZE is a number. For TYPE in doux, SIZE may also be C for\n\
327 sizeof(char), S for sizeof(short), I for sizeof(int) or L for\n\
328 sizeof(long). If TYPE is f, SIZE may also be F for sizeof(float), D\n\
329 for sizeof(double) or L for sizeof(long double).\n\
331 RADIX is d for decimal, o for octal, x for hexadecimal or n for none.\n\
332 BYTES is hexadecimal with 0x or 0X prefix, it is multiplied by 512\n\
333 with b suffix, by 1024 with k and by 1048576 with m. Adding a z suffix to\n\
334 any type adds a display of printable characters to the end of each line\n\
335 of output. -s without a number implies 3. -w without a number implies 32.\n\
336 By default, od uses -A o -t d2 -w 16.\n\
338 puts (_("\nReport bugs to <bug-textutils@gnu.org>."));
340 exit (status == 0 ? EXIT_SUCCESS : EXIT_FAILURE);
343 /* Compute the greatest common denominator of U and V
344 using Euclid's algorithm. */
347 gcd (unsigned int u, unsigned int v)
359 /* Compute the least common multiple of U and V. */
362 lcm (unsigned int u, unsigned int v)
364 unsigned int t = gcd (u, v);
371 print_s_char (size_t n_bytes, const char *block, const char *fmt_string)
374 for (i = n_bytes; i > 0; i--)
376 int tmp = (unsigned) *(const unsigned char *) block;
378 tmp -= SCHAR_MAX - SCHAR_MIN + 1;
379 assert (tmp <= SCHAR_MAX);
380 printf (fmt_string, tmp);
381 block += sizeof (unsigned char);
386 print_char (size_t n_bytes, const char *block, const char *fmt_string)
389 for (i = n_bytes; i > 0; i--)
391 unsigned int tmp = *(const unsigned char *) block;
392 printf (fmt_string, tmp);
393 block += sizeof (unsigned char);
398 print_s_short (size_t n_bytes, const char *block, const char *fmt_string)
401 for (i = n_bytes / sizeof (unsigned short); i > 0; i--)
403 int tmp = (unsigned) *(const unsigned short *) block;
405 tmp -= SHRT_MAX - SHRT_MIN + 1;
406 assert (tmp <= SHRT_MAX);
407 printf (fmt_string, tmp);
408 block += sizeof (unsigned short);
413 print_short (size_t n_bytes, const char *block, const char *fmt_string)
416 for (i = n_bytes / sizeof (unsigned short); i > 0; i--)
418 unsigned int tmp = *(const unsigned short *) block;
419 printf (fmt_string, tmp);
420 block += sizeof (unsigned short);
425 print_int (size_t n_bytes, const char *block, const char *fmt_string)
428 for (i = n_bytes / sizeof (unsigned int); i > 0; i--)
430 unsigned int tmp = *(const unsigned int *) block;
431 printf (fmt_string, tmp);
432 block += sizeof (unsigned int);
437 print_long (size_t n_bytes, const char *block, const char *fmt_string)
440 for (i = n_bytes / sizeof (unsigned long); i > 0; i--)
442 unsigned long tmp = *(const unsigned long *) block;
443 printf (fmt_string, tmp);
444 block += sizeof (unsigned long);
449 print_long_long (size_t n_bytes, const char *block, const char *fmt_string)
452 for (i = n_bytes / sizeof (ulonglong_t); i > 0; i--)
454 ulonglong_t tmp = *(const ulonglong_t *) block;
455 printf (fmt_string, tmp);
456 block += sizeof (ulonglong_t);
461 print_float (size_t n_bytes, const char *block, const char *fmt_string)
464 for (i = n_bytes / sizeof (float); i > 0; i--)
466 float tmp = *(const float *) block;
467 printf (fmt_string, tmp);
468 block += sizeof (float);
473 print_double (size_t n_bytes, const char *block, const char *fmt_string)
476 for (i = n_bytes / sizeof (double); i > 0; i--)
478 double tmp = *(const double *) block;
479 printf (fmt_string, tmp);
480 block += sizeof (double);
484 #ifdef HAVE_LONG_DOUBLE
486 print_long_double (size_t n_bytes, const char *block, const char *fmt_string)
489 for (i = n_bytes / sizeof (LONG_DOUBLE); i > 0; i--)
491 LONG_DOUBLE tmp = *(const LONG_DOUBLE *) block;
492 printf (fmt_string, tmp);
493 block += sizeof (LONG_DOUBLE);
500 dump_hexl_mode_trailer (size_t n_bytes, const char *block)
503 fputs (" >", stdout);
504 for (i = n_bytes; i > 0; i--)
506 unsigned int c = *(const unsigned char *) block;
507 unsigned int c2 = (ISPRINT(c) ? c : '.');
509 block += sizeof (unsigned char);
515 print_named_ascii (size_t n_bytes, const char *block,
516 const char *unused_fmt_string ATTRIBUTE_UNUSED)
519 for (i = n_bytes; i > 0; i--)
521 unsigned int c = *(const unsigned char *) block;
522 unsigned int masked_c = (0x7f & c);
528 else if (masked_c <= 040)
529 s = charname[masked_c];
532 sprintf (buf, " %c", masked_c);
537 block += sizeof (unsigned char);
542 print_ascii (size_t n_bytes, const char *block,
543 const char *unused_fmt_string ATTRIBUTE_UNUSED)
546 for (i = n_bytes; i > 0; i--)
548 unsigned int c = *(const unsigned char *) block;
587 sprintf (buf, (ISPRINT (c) ? " %c" : "%03o"), c);
588 s = (const char *) buf;
592 block += sizeof (unsigned char);
596 /* Convert a null-terminated (possibly zero-length) string S to an
597 unsigned long integer value. If S points to a non-digit set *P to S,
598 *VAL to 0, and return 0. Otherwise, accumulate the integer value of
599 the string of digits. If the string of digits represents a value
600 larger than ULONG_MAX, don't modify *VAL or *P and return nonzero.
601 Otherwise, advance *P to the first non-digit after S, set *VAL to
602 the result of the conversion and return zero. */
605 simple_strtoul (const char *s, const char **p, long unsigned int *val)
607 unsigned long int sum;
612 unsigned int c = *s++ - '0';
613 if (sum > (ULONG_MAX - c) / 10)
622 /* If S points to a single valid POSIX-style od format string, put
623 a description of that format in *TSPEC, make *NEXT point at the
624 character following the just-decoded format (if *NEXT is non-NULL),
625 and return zero. If S is not valid, don't modify *NEXT or *TSPEC,
626 give a diagnostic, and return nonzero. For example, if S were
627 "d4afL" *NEXT would be set to "afL" and *TSPEC would be
629 fmt = SIGNED_DECIMAL;
630 size = INT or LONG; (whichever integral_type_size[4] resolves to)
631 print_function = print_int; (assuming size == INT)
632 fmt_string = "%011d%c";
634 S_ORIG is solely for reporting errors. It should be the full format
639 decode_one_format (const char *s_orig, const char *s, const char **next,
642 enum size_spec size_spec;
643 unsigned long int size;
644 enum output_format fmt;
645 const char *pre_fmt_string;
647 void (*print_function) PARAMS ((size_t, const char *, const char *));
650 unsigned int field_width = 0;
652 assert (tspec != NULL);
666 size = sizeof (char);
671 size = sizeof (short);
681 size = sizeof (long int);
685 if (simple_strtoul (s, &p, &size) != 0)
687 /* The integer at P in S would overflow an unsigned long.
688 A digit string that long is sufficiently odd looking
689 that the following diagnostic is sufficient. */
690 error (0, 0, _("invalid type string `%s'"), s_orig);
697 if (MAX_INTEGRAL_TYPE_SIZE < size
698 || integral_type_size[size] == NO_SIZE)
700 error (0, 0, _("invalid type string `%s';\n\
701 this system doesn't provide a %lu-byte integral type"), s_orig, size);
709 #define FMT_BYTES_ALLOCATED 9
710 fmt_string = xmalloc (FMT_BYTES_ALLOCATED);
712 size_spec = integral_type_size[size];
717 fmt = SIGNED_DECIMAL;
718 sprintf (fmt_string, " %%%u%sd",
719 (field_width = bytes_to_signed_dec_digits[size]),
720 (size_spec == LONG ? "l"
721 : (size_spec == LONG_LONG ? "ll"
727 sprintf (fmt_string, " %%0%u%so",
728 (field_width = bytes_to_oct_digits[size]),
729 (size_spec == LONG ? "l" : ""));
733 fmt = UNSIGNED_DECIMAL;
734 sprintf (fmt_string, " %%%u%su",
735 (field_width = bytes_to_unsigned_dec_digits[size]),
736 (size_spec == LONG ? "l" : ""));
741 sprintf (fmt_string, " %%0%u%sx",
742 (field_width = bytes_to_hex_digits[size]),
743 (size_spec == LONG ? "l" : ""));
750 assert (strlen (fmt_string) < FMT_BYTES_ALLOCATED);
755 print_function = (fmt == SIGNED_DECIMAL
761 print_function = (fmt == SIGNED_DECIMAL
767 print_function = print_int;
771 print_function = print_long;
775 print_function = print_long_long;
784 fmt = FLOATING_POINT;
790 size = sizeof (float);
795 size = sizeof (double);
800 size = sizeof (LONG_DOUBLE);
804 if (simple_strtoul (s, &p, &size) != 0)
806 /* The integer at P in S would overflow an unsigned long.
807 A digit string that long is sufficiently odd looking
808 that the following diagnostic is sufficient. */
809 error (0, 0, _("invalid type string `%s'"), s_orig);
813 size = sizeof (double);
816 if (size > MAX_FP_TYPE_SIZE
817 || fp_type_size[size] == NO_SIZE)
819 error (0, 0, _("invalid type string `%s';\n\
820 this system doesn't provide a %lu-byte floating point type"), s_orig, size);
827 size_spec = fp_type_size[size];
832 print_function = print_float;
833 /* Don't use %#e; not all systems support it. */
834 pre_fmt_string = " %%%d.%de";
835 fmt_string = xmalloc (strlen (pre_fmt_string));
836 sprintf (fmt_string, pre_fmt_string,
837 (field_width = FLT_DIG + 8), FLT_DIG);
841 print_function = print_double;
842 pre_fmt_string = " %%%d.%de";
843 fmt_string = xmalloc (strlen (pre_fmt_string));
844 sprintf (fmt_string, pre_fmt_string,
845 (field_width = DBL_DIG + 8), DBL_DIG);
848 #ifdef HAVE_LONG_DOUBLE
849 case FLOAT_LONG_DOUBLE:
850 print_function = print_long_double;
851 pre_fmt_string = " %%%d.%dLe";
852 fmt_string = xmalloc (strlen (pre_fmt_string));
853 sprintf (fmt_string, pre_fmt_string,
854 (field_width = LDBL_DIG + 8), LDBL_DIG);
865 fmt = NAMED_CHARACTER;
868 print_function = print_named_ascii;
877 print_function = print_ascii;
882 error (0, 0, _("invalid character `%c' in type string `%s'"),
887 tspec->size = size_spec;
889 tspec->print_function = print_function;
890 tspec->fmt_string = fmt_string;
892 tspec->field_width = field_width;
893 tspec->hexl_mode_trailer = (*s == 'z');
894 if (tspec->hexl_mode_trailer)
903 /* Given a list of one or more input filenames FILE_LIST, set the global
904 file pointer IN_STREAM and the global string INPUT_FILENAME to the
905 first one that can be successfully opened. Modify FILE_LIST to
906 reference the next filename in the list. A file name of "-" is
907 interpreted as standard input. If any file open fails, give an error
908 message and return nonzero. */
911 open_next_file (void)
917 input_filename = *file_list;
918 if (input_filename == NULL)
922 if (STREQ (input_filename, "-"))
924 input_filename = _("standard input");
930 in_stream = fopen (input_filename, "r");
931 if (in_stream == NULL)
933 error (0, errno, "%s", input_filename);
938 while (in_stream == NULL);
940 if (limit_bytes_to_format && !flag_dump_strings)
941 SETVBUF (in_stream, NULL, _IONBF, 0);
942 SET_BINARY (fileno (in_stream));
947 /* Test whether there have been errors on in_stream, and close it if
948 it is not standard input. Return nonzero if there has been an error
949 on in_stream or stdout; return zero otherwise. This function will
950 report more than one error only if both a read and a write error
954 check_and_close (void)
958 if (in_stream != NULL)
960 if (ferror (in_stream))
962 error (0, errno, "%s", input_filename);
963 if (in_stream != stdin)
967 else if (in_stream != stdin && fclose (in_stream) == EOF)
969 error (0, errno, "%s", input_filename);
978 error (0, errno, _("standard output"));
985 /* Decode the POSIX-style od format string S. Append the decoded
986 representation to the global array SPEC, reallocating SPEC if
987 necessary. Return zero if S is valid, nonzero otherwise. */
990 decode_format_string (const char *s)
992 const char *s_orig = s;
1000 if (decode_one_format (s_orig, s, &next, &tspec))
1006 if (n_specs >= n_specs_allocated)
1008 n_specs_allocated = 1 + (3 * n_specs_allocated) / 2;
1009 spec = (struct tspec *) xrealloc ((char *) spec,
1011 * sizeof (struct tspec)));
1014 memcpy ((char *) &spec[n_specs], (char *) &tspec,
1015 sizeof (struct tspec));
1022 /* Given a list of one or more input filenames FILE_LIST, set the global
1023 file pointer IN_STREAM to position N_SKIP in the concatenation of
1024 those files. If any file operation fails or if there are fewer than
1025 N_SKIP bytes in the combined input, give an error message and return
1026 nonzero. When possible, use seek rather than read operations to
1027 advance IN_STREAM. */
1030 skip (uintmax_t n_skip)
1037 while (in_stream != NULL) /* EOF. */
1039 struct stat file_stats;
1041 /* First try seeking. For large offsets, this extra work is
1042 worthwhile. If the offset is below some threshold it may be
1043 more efficient to move the pointer by reading. There are two
1044 issues when trying to seek:
1045 - the file must be seekable.
1046 - before seeking to the specified position, make sure
1047 that the new position is in the current file.
1048 Try to do that by getting file's size using fstat.
1049 But that will work only for regular files. */
1051 if (fstat (fileno (in_stream), &file_stats) == 0)
1053 /* The st_size field is valid only for regular files
1054 (and for symbolic links, which cannot occur here).
1055 If the number of bytes left to skip is at least
1056 as large as the size of the current file, we can
1057 decrement n_skip and go on to the next file. */
1059 if (S_ISREG (file_stats.st_mode) && 0 <= file_stats.st_size)
1061 if (file_stats.st_size <= n_skip)
1062 n_skip -= file_stats.st_size;
1065 if (lseek (fileno (in_stream), n_skip, SEEK_CUR) < 0)
1067 error (0, errno, "%s", input_filename);
1074 /* If it's not a regular file with nonnegative size,
1075 position the file pointer by reading. */
1080 size_t n_bytes_read, n_bytes_to_read = BUFSIZ;
1084 if (n_skip < n_bytes_to_read)
1085 n_bytes_to_read = n_skip;
1086 n_bytes_read = fread (buf, 1, n_bytes_to_read, in_stream);
1087 n_skip -= n_bytes_read;
1088 if (n_bytes_read != n_bytes_to_read)
1097 else /* cannot fstat() file */
1099 error (0, errno, "%s", input_filename);
1103 err |= check_and_close ();
1105 err |= open_next_file ();
1109 error (EXIT_FAILURE, 0, _("cannot skip past end of combined input"));
1115 format_address_none (uintmax_t address ATTRIBUTE_UNUSED, char c ATTRIBUTE_UNUSED)
1120 format_address_std (uintmax_t address, char c)
1122 char buf[MAX_ADDRESS_LENGTH + 2];
1123 char *p = buf + sizeof buf;
1128 pbound = p - address_pad_len;
1130 /* Use a special case of the code for each base. This is measurably
1131 faster than generic code. */
1132 switch (address_base)
1136 *--p = '0' + (address & 7);
1137 while ((address >>= 3) != 0);
1142 *--p = '0' + (address % 10);
1143 while ((address /= 10) != 0);
1148 *--p = "0123456789abcdef"[address & 15];
1149 while ((address >>= 4) != 0);
1160 format_address_paren (uintmax_t address, char c)
1163 format_address_std (address, ')');
1168 format_address_label (uintmax_t address, char c)
1170 format_address_std (address, ' ');
1171 format_address_paren (address + pseudo_offset, c);
1174 /* Write N_BYTES bytes from CURR_BLOCK to standard output once for each
1175 of the N_SPEC format specs. CURRENT_OFFSET is the byte address of
1176 CURR_BLOCK in the concatenation of input files, and it is printed
1177 (optionally) only before the output line associated with the first
1178 format spec. When duplicate blocks are being abbreviated, the output
1179 for a sequence of identical input blocks is the output for the first
1180 block followed by an asterisk alone on a line. It is valid to compare
1181 the blocks PREV_BLOCK and CURR_BLOCK only when N_BYTES == BYTES_PER_BLOCK.
1182 That condition may be false only for the last input block -- and then
1183 only when it has not been padded to length BYTES_PER_BLOCK. */
1186 write_block (uintmax_t current_offset, size_t n_bytes,
1187 const char *prev_block, const char *curr_block)
1189 static int first = 1;
1190 static int prev_pair_equal = 0;
1192 #define EQUAL_BLOCKS(b1, b2) (memcmp ((b1), (b2), bytes_per_block) == 0)
1194 if (abbreviate_duplicate_blocks
1195 && !first && n_bytes == bytes_per_block
1196 && EQUAL_BLOCKS (prev_block, curr_block))
1198 if (prev_pair_equal)
1200 /* The two preceding blocks were equal, and the current
1201 block is the same as the last one, so print nothing. */
1206 prev_pair_equal = 1;
1213 prev_pair_equal = 0;
1214 for (i = 0; i < n_specs; i++)
1217 format_address (current_offset, '\0');
1219 printf ("%*s", address_pad_len, "");
1220 (*spec[i].print_function) (n_bytes, curr_block, spec[i].fmt_string);
1221 if (spec[i].hexl_mode_trailer)
1223 /* space-pad out to full line width, then dump the trailer */
1224 int datum_width = width_bytes[spec[i].size];
1225 int blank_fields = (bytes_per_block - n_bytes) / datum_width;
1226 int field_width = spec[i].field_width + 1;
1227 printf ("%*s", blank_fields * field_width, "");
1228 dump_hexl_mode_trailer (n_bytes, curr_block);
1236 /* Read a single byte into *C from the concatenation of the input files
1237 named in the global array FILE_LIST. On the first call to this
1238 function, the global variable IN_STREAM is expected to be an open
1239 stream associated with the input file INPUT_FILENAME. If IN_STREAM
1240 is at end-of-file, close it and update the global variables IN_STREAM
1241 and INPUT_FILENAME so they correspond to the next file in the list.
1242 Then try to read a byte from the newly opened file. Repeat if
1243 necessary until EOF is reached for the last file in FILE_LIST, then
1244 set *C to EOF and return. Subsequent calls do likewise. The return
1245 value is nonzero if any errors occured, zero otherwise. */
1254 while (in_stream != NULL) /* EOF. */
1256 *c = fgetc (in_stream);
1261 err |= check_and_close ();
1263 err |= open_next_file ();
1269 /* Read N bytes into BLOCK from the concatenation of the input files
1270 named in the global array FILE_LIST. On the first call to this
1271 function, the global variable IN_STREAM is expected to be an open
1272 stream associated with the input file INPUT_FILENAME. If all N
1273 bytes cannot be read from IN_STREAM, close IN_STREAM and update
1274 the global variables IN_STREAM and INPUT_FILENAME. Then try to
1275 read the remaining bytes from the newly opened file. Repeat if
1276 necessary until EOF is reached for the last file in FILE_LIST.
1277 On subsequent calls, don't modify BLOCK and return zero. Set
1278 *N_BYTES_IN_BUFFER to the number of bytes read. If an error occurs,
1279 it will be detected through ferror when the stream is about to be
1280 closed. If there is an error, give a message but continue reading
1281 as usual and return nonzero. Otherwise return zero. */
1284 read_block (size_t n, char *block, size_t *n_bytes_in_buffer)
1288 assert (0 < n && n <= bytes_per_block);
1290 *n_bytes_in_buffer = 0;
1295 while (in_stream != NULL) /* EOF. */
1300 n_needed = n - *n_bytes_in_buffer;
1301 n_read = fread (block + *n_bytes_in_buffer, 1, n_needed, in_stream);
1303 *n_bytes_in_buffer += n_read;
1305 if (n_read == n_needed)
1308 err |= check_and_close ();
1310 err |= open_next_file ();
1316 /* Return the least common multiple of the sizes associated
1317 with the format specs. */
1325 for (i = 0; i < n_specs; i++)
1326 l_c_m = lcm (l_c_m, width_bytes[(int) spec[i].size]);
1330 /* If S is a valid pre-POSIX offset specification with an optional leading '+'
1331 return nonzero and set *OFFSET to the offset it denotes. */
1334 parse_old_offset (const char *s, uintmax_t *offset)
1337 enum strtol_error s_err;
1342 /* Skip over any leading '+'. */
1346 /* Determine the radix we'll use to interpret S. If there is a `.',
1347 it's decimal, otherwise, if the string begins with `0X'or `0x',
1348 it's hexadecimal, else octal. */
1349 if (strchr (s, '.') != NULL)
1353 if (s[0] == '0' && (s[1] == 'x' || s[1] == 'X'))
1359 s_err = xstrtoumax (s, NULL, radix, offset, "Bb");
1360 if (s_err != LONGINT_OK)
1362 STRTOL_FAIL_WARN (s, _("old-style offset"), s_err);
1368 /* Read a chunk of size BYTES_PER_BLOCK from the input files, write the
1369 formatted block to standard output, and repeat until the specified
1370 maximum number of bytes has been read or until all input has been
1371 processed. If the last block read is smaller than BYTES_PER_BLOCK
1372 and its size is not a multiple of the size associated with a format
1373 spec, extend the input block with zero bytes until its length is a
1374 multiple of all format spec sizes. Write the final block. Finally,
1375 write on a line by itself the offset of the byte after the last byte
1376 read. Accumulate return values from calls to read_block and
1377 check_and_close, and if any was nonzero, return nonzero.
1378 Otherwise, return zero. */
1384 uintmax_t current_offset;
1387 size_t n_bytes_read;
1389 block[0] = (char *) alloca (bytes_per_block);
1390 block[1] = (char *) alloca (bytes_per_block);
1392 current_offset = n_bytes_to_skip;
1396 if (limit_bytes_to_format)
1401 if (current_offset >= end_offset)
1406 n_needed = MIN (end_offset - current_offset,
1407 (uintmax_t) bytes_per_block);
1408 err |= read_block (n_needed, block[idx], &n_bytes_read);
1409 if (n_bytes_read < bytes_per_block)
1411 assert (n_bytes_read == bytes_per_block);
1412 write_block (current_offset, n_bytes_read,
1413 block[!idx], block[idx]);
1414 current_offset += n_bytes_read;
1422 err |= read_block (bytes_per_block, block[idx], &n_bytes_read);
1423 if (n_bytes_read < bytes_per_block)
1425 assert (n_bytes_read == bytes_per_block);
1426 write_block (current_offset, n_bytes_read,
1427 block[!idx], block[idx]);
1428 current_offset += n_bytes_read;
1433 if (n_bytes_read > 0)
1436 size_t bytes_to_write;
1440 /* Make bytes_to_write the smallest multiple of l_c_m that
1441 is at least as large as n_bytes_read. */
1442 bytes_to_write = l_c_m * ((n_bytes_read + l_c_m - 1) / l_c_m);
1444 memset (block[idx] + n_bytes_read, 0, bytes_to_write - n_bytes_read);
1445 write_block (current_offset, bytes_to_write,
1446 block[!idx], block[idx]);
1447 current_offset += n_bytes_read;
1450 format_address (current_offset, '\n');
1452 if (limit_bytes_to_format && current_offset >= end_offset)
1453 err |= check_and_close ();
1458 /* STRINGS mode. Find each "string constant" in the input.
1459 A string constant is a run of at least `string_min' ASCII
1460 graphic (or formatting) characters terminated by a null.
1461 Based on a function written by Richard Stallman for a
1462 pre-POSIX version of od. Return nonzero if an error
1463 occurs. Otherwise, return zero. */
1468 size_t bufsize = MAX (100, string_min);
1469 char *buf = xmalloc (bufsize);
1470 uintmax_t address = n_bytes_to_skip;
1479 /* See if the next `string_min' chars are all printing chars. */
1482 if (limit_bytes_to_format
1483 && (end_offset < string_min || end_offset - string_min <= address))
1486 for (i = 0; i < string_min; i++)
1488 err |= read_char (&c);
1496 /* Found a non-printing. Try again starting with next char. */
1501 /* We found a run of `string_min' printable characters.
1502 Now see if it is terminated with a null byte. */
1503 while (!limit_bytes_to_format || address < end_offset)
1507 bufsize = 1 + 3 * bufsize / 2;
1508 buf = xrealloc (buf, bufsize);
1510 err |= read_char (&c);
1518 break; /* It is; print this string. */
1520 goto tryline; /* It isn't; give up on this string. */
1521 buf[i++] = c; /* String continues; store it all. */
1524 /* If we get here, the string is all printable and null-terminated,
1525 so print it. It is all in `buf' and `i' is its length. */
1527 format_address (address - i - 1, ' ');
1529 for (i = 0; (c = buf[i]); i++)
1534 fputs ("\\a", stdout);
1538 fputs ("\\b", stdout);
1542 fputs ("\\f", stdout);
1546 fputs ("\\n", stdout);
1550 fputs ("\\r", stdout);
1554 fputs ("\\t", stdout);
1558 fputs ("\\v", stdout);
1568 /* We reach this point only if we search through
1569 (max_bytes_to_format - string_min) bytes before reaching EOF. */
1573 err |= check_and_close ();
1578 main (int argc, char **argv)
1584 size_t desired_width IF_LINT (= 0);
1585 int width_specified = 0;
1586 int n_failed_decodes = 0;
1589 /* The old-style `pseudo starting address' to be printed in parentheses
1590 after any true address. */
1591 uintmax_t pseudo_start IF_LINT (= 0);
1593 program_name = argv[0];
1594 setlocale (LC_ALL, "");
1595 bindtextdomain (PACKAGE, LOCALEDIR);
1596 textdomain (PACKAGE);
1598 atexit (close_stdout);
1602 for (i = 0; i <= MAX_INTEGRAL_TYPE_SIZE; i++)
1603 integral_type_size[i] = NO_SIZE;
1605 integral_type_size[sizeof (char)] = CHAR;
1606 integral_type_size[sizeof (short int)] = SHORT;
1607 integral_type_size[sizeof (int)] = INT;
1608 integral_type_size[sizeof (long int)] = LONG;
1609 #if HAVE_UNSIGNED_LONG_LONG
1610 integral_type_size[sizeof (ulonglong_t)] = LONG_LONG;
1613 for (i = 0; i <= MAX_FP_TYPE_SIZE; i++)
1614 fp_type_size[i] = NO_SIZE;
1616 fp_type_size[sizeof (float)] = FLOAT_SINGLE;
1617 /* The array entry for `double' is filled in after that for LONG_DOUBLE
1618 so that if `long double' is the same type or if long double isn't
1619 supported FLOAT_LONG_DOUBLE will never be used. */
1620 fp_type_size[sizeof (LONG_DOUBLE)] = FLOAT_LONG_DOUBLE;
1621 fp_type_size[sizeof (double)] = FLOAT_DOUBLE;
1624 n_specs_allocated = 5;
1625 spec = (struct tspec *) xmalloc (n_specs_allocated * sizeof (struct tspec));
1627 format_address = format_address_std;
1629 address_pad_len = 7;
1630 flag_dump_strings = 0;
1632 while ((c = getopt_long (argc, argv, "abcdfhilos::xw::A:j:N:t:v",
1633 long_options, NULL)) != -1)
1636 enum strtol_error s_err;
1647 format_address = format_address_std;
1649 address_pad_len = 7;
1652 format_address = format_address_std;
1654 address_pad_len = 7;
1657 format_address = format_address_std;
1659 address_pad_len = 6;
1662 format_address = format_address_none;
1663 address_pad_len = 0;
1666 error (EXIT_FAILURE, 0,
1667 _("invalid output address radix `%c'; \
1668 it must be one character from [doxn]"),
1675 s_err = xstrtoumax (optarg, NULL, 0, &n_bytes_to_skip, "bkm");
1676 if (s_err != LONGINT_OK)
1677 STRTOL_FATAL_ERROR (optarg, _("skip argument"), s_err);
1681 limit_bytes_to_format = 1;
1683 s_err = xstrtoumax (optarg, NULL, 0, &max_bytes_to_format, "bkm");
1684 if (s_err != LONGINT_OK)
1685 STRTOL_FATAL_ERROR (optarg, _("limit argument"), s_err);
1693 s_err = xstrtoumax (optarg, NULL, 0, &tmp, "bkm");
1694 if (s_err != LONGINT_OK)
1695 STRTOL_FATAL_ERROR (optarg, _("minimum string length"), s_err);
1697 /* The minimum string length may be no larger than SIZE_MAX,
1698 since we may allocate a buffer of this size. */
1700 error (EXIT_FAILURE, 0, _("%s is too large"), optarg);
1704 flag_dump_strings = 1;
1708 if (decode_format_string (optarg))
1713 abbreviate_duplicate_blocks = 0;
1720 /* The next several cases map the old, pre-POSIX format
1721 specification options to the corresponding POSIX format
1722 specs. GNU od accepts any combination of old- and
1723 new-style options. Format specification options accumulate. */
1725 #define CASE_OLD_ARG(old_char,new_string) \
1728 if (decode_format_string (new_string)) \
1729 ++n_failed_decodes; \
1733 CASE_OLD_ARG ('a', "a");
1734 CASE_OLD_ARG ('b', "oC");
1735 CASE_OLD_ARG ('c', "c");
1736 CASE_OLD_ARG ('d', "u2");
1737 CASE_OLD_ARG ('f', "fF");
1738 CASE_OLD_ARG ('h', "x2");
1739 CASE_OLD_ARG ('i', "d2");
1740 CASE_OLD_ARG ('l', "d4");
1741 CASE_OLD_ARG ('o', "o2");
1742 CASE_OLD_ARG ('x', "x2");
1747 width_specified = 1;
1755 s_err = xstrtoumax (optarg, NULL, 10, &w_tmp, "");
1756 if (s_err != LONGINT_OK)
1757 STRTOL_FATAL_ERROR (optarg, _("width specification"), s_err);
1758 if (SIZE_MAX < w_tmp)
1759 error (EXIT_FAILURE, 0, _("%s is too large"), optarg);
1760 desired_width = w_tmp;
1764 case_GETOPT_HELP_CHAR;
1766 case_GETOPT_VERSION_CHAR (PROGRAM_NAME, AUTHORS);
1774 if (n_failed_decodes > 0)
1775 exit (EXIT_FAILURE);
1777 if (flag_dump_strings && n_specs > 0)
1778 error (EXIT_FAILURE, 0,
1779 _("no type may be specified when dumping strings"));
1781 n_files = argc - optind;
1783 /* If the --backward-compatible option is used, there may be from
1784 0 to 3 remaining command line arguments; handle each case
1786 od [file] [[+]offset[.][b] [[+]label[.][b]]]
1787 The offset and pseudo_start have the same syntax. */
1795 if (parse_old_offset (argv[optind], &offset))
1797 n_bytes_to_skip = offset;
1802 else if (n_files == 2)
1805 if (parse_old_offset (argv[optind], &o1)
1806 && parse_old_offset (argv[optind + 1], &o2))
1808 n_bytes_to_skip = o1;
1809 flag_pseudo_start = 1;
1814 else if (parse_old_offset (argv[optind + 1], &o2))
1816 n_bytes_to_skip = o2;
1818 argv[optind + 1] = argv[optind];
1824 _("invalid second operand in compatibility mode `%s'"),
1829 else if (n_files == 3)
1832 if (parse_old_offset (argv[optind + 1], &o1)
1833 && parse_old_offset (argv[optind + 2], &o2))
1835 n_bytes_to_skip = o1;
1836 flag_pseudo_start = 1;
1838 argv[optind + 2] = argv[optind];
1845 _("in compatibility mode, the last two arguments must be offsets"));
1849 else if (n_files > 3)
1852 _("compatibility mode supports at most three arguments"));
1856 if (flag_pseudo_start)
1858 if (format_address == format_address_none)
1861 address_pad_len = 7;
1862 format_address = format_address_paren;
1865 format_address = format_address_label;
1869 if (limit_bytes_to_format)
1871 end_offset = n_bytes_to_skip + max_bytes_to_format;
1872 if (end_offset < n_bytes_to_skip)
1873 error (EXIT_FAILURE, 0, "skip-bytes + read-bytes is too large");
1878 if (decode_one_format ("o2", "o2", NULL, &(spec[0])))
1880 /* This happens on Cray systems that don't have a 2-byte
1882 exit (EXIT_FAILURE);
1890 /* Set the global pointer FILE_LIST so that it
1891 references the first file-argument on the command-line. */
1893 file_list = (char const *const *) &argv[optind];
1897 /* No files were listed on the command line.
1898 Set the global pointer FILE_LIST so that it
1899 references the null-terminated list of one name: "-". */
1901 file_list = default_file_list;
1904 /* open the first input file */
1905 err |= open_next_file ();
1906 if (in_stream == NULL)
1909 /* skip over any unwanted header bytes */
1910 err |= skip (n_bytes_to_skip);
1911 if (in_stream == NULL)
1914 pseudo_offset = (flag_pseudo_start ? pseudo_start - n_bytes_to_skip : 0);
1916 /* Compute output block length. */
1919 if (width_specified)
1921 if (desired_width != 0 && desired_width % l_c_m == 0)
1922 bytes_per_block = desired_width;
1925 error (0, 0, _("warning: invalid width %lu; using %d instead"),
1926 (unsigned long) desired_width, l_c_m);
1927 bytes_per_block = l_c_m;
1932 if (l_c_m < DEFAULT_BYTES_PER_BLOCK)
1933 bytes_per_block = l_c_m * (DEFAULT_BYTES_PER_BLOCK / l_c_m);
1935 bytes_per_block = l_c_m;
1939 for (i = 0; i < n_specs; i++)
1941 printf (_("%d: fmt=\"%s\" width=%d\n"),
1942 i, spec[i].fmt_string, width_bytes[spec[i].size]);
1946 err |= (flag_dump_strings ? dump_strings () : dump ());
1950 if (have_read_stdin && fclose (stdin) == EOF)
1951 error (EXIT_FAILURE, errno, _("standard input"));
1953 exit (err == 0 ? EXIT_SUCCESS : EXIT_FAILURE);