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 EMIT_HELP_DESCRIPTION (stdout);
302 EMIT_VERSION_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\
338 SIZE is a number. For TYPE in doux, SIZE may also be C for\n\
339 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\
345 RADIX is d for decimal, o for octal, x for hexadecimal or n for none.\n\
346 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\
351 of output. -s without a number implies 3. -w without a number implies 32.\n\
352 By default, od uses -A o -t d2 -w 16.\n\
354 puts (_("\nReport bugs to <bug-textutils@gnu.org>."));
356 exit (status == 0 ? EXIT_SUCCESS : EXIT_FAILURE);
359 /* Compute the greatest common denominator of U and V
360 using Euclid's algorithm. */
363 gcd (unsigned int u, unsigned int v)
375 /* Compute the least common multiple of U and V. */
378 lcm (unsigned int u, unsigned int v)
380 unsigned int t = gcd (u, v);
387 print_s_char (size_t n_bytes, const char *block, const char *fmt_string)
390 for (i = n_bytes; i > 0; i--)
392 int tmp = (unsigned) *(const unsigned char *) block;
394 tmp -= SCHAR_MAX - SCHAR_MIN + 1;
395 assert (tmp <= SCHAR_MAX);
396 printf (fmt_string, tmp);
397 block += sizeof (unsigned char);
402 print_char (size_t n_bytes, const char *block, const char *fmt_string)
405 for (i = n_bytes; i > 0; i--)
407 unsigned int tmp = *(const unsigned char *) block;
408 printf (fmt_string, tmp);
409 block += sizeof (unsigned char);
414 print_s_short (size_t n_bytes, const char *block, const char *fmt_string)
417 for (i = n_bytes / sizeof (unsigned short); i > 0; i--)
419 int tmp = (unsigned) *(const unsigned short *) block;
421 tmp -= SHRT_MAX - SHRT_MIN + 1;
422 assert (tmp <= SHRT_MAX);
423 printf (fmt_string, tmp);
424 block += sizeof (unsigned short);
429 print_short (size_t n_bytes, const char *block, const char *fmt_string)
432 for (i = n_bytes / sizeof (unsigned short); i > 0; i--)
434 unsigned int tmp = *(const unsigned short *) block;
435 printf (fmt_string, tmp);
436 block += sizeof (unsigned short);
441 print_int (size_t n_bytes, const char *block, const char *fmt_string)
444 for (i = n_bytes / sizeof (unsigned int); i > 0; i--)
446 unsigned int tmp = *(const unsigned int *) block;
447 printf (fmt_string, tmp);
448 block += sizeof (unsigned int);
453 print_long (size_t n_bytes, const char *block, const char *fmt_string)
456 for (i = n_bytes / sizeof (unsigned long); i > 0; i--)
458 unsigned long tmp = *(const unsigned long *) block;
459 printf (fmt_string, tmp);
460 block += sizeof (unsigned long);
465 print_long_long (size_t n_bytes, const char *block, const char *fmt_string)
468 for (i = n_bytes / sizeof (ulonglong_t); i > 0; i--)
470 ulonglong_t tmp = *(const ulonglong_t *) block;
471 printf (fmt_string, tmp);
472 block += sizeof (ulonglong_t);
477 print_float (size_t n_bytes, const char *block, const char *fmt_string)
480 for (i = n_bytes / sizeof (float); i > 0; i--)
482 float tmp = *(const float *) block;
483 printf (fmt_string, tmp);
484 block += sizeof (float);
489 print_double (size_t n_bytes, const char *block, const char *fmt_string)
492 for (i = n_bytes / sizeof (double); i > 0; i--)
494 double tmp = *(const double *) block;
495 printf (fmt_string, tmp);
496 block += sizeof (double);
500 #ifdef HAVE_LONG_DOUBLE
502 print_long_double (size_t n_bytes, const char *block, const char *fmt_string)
505 for (i = n_bytes / sizeof (LONG_DOUBLE); i > 0; i--)
507 LONG_DOUBLE tmp = *(const LONG_DOUBLE *) block;
508 printf (fmt_string, tmp);
509 block += sizeof (LONG_DOUBLE);
516 dump_hexl_mode_trailer (size_t n_bytes, const char *block)
519 fputs (" >", stdout);
520 for (i = n_bytes; i > 0; i--)
522 unsigned int c = *(const unsigned char *) block;
523 unsigned int c2 = (ISPRINT(c) ? c : '.');
525 block += sizeof (unsigned char);
531 print_named_ascii (size_t n_bytes, const char *block,
532 const char *unused_fmt_string ATTRIBUTE_UNUSED)
535 for (i = n_bytes; i > 0; i--)
537 unsigned int c = *(const unsigned char *) block;
538 unsigned int masked_c = (0x7f & c);
544 else if (masked_c <= 040)
545 s = charname[masked_c];
548 sprintf (buf, " %c", masked_c);
553 block += sizeof (unsigned char);
558 print_ascii (size_t n_bytes, const char *block,
559 const char *unused_fmt_string ATTRIBUTE_UNUSED)
562 for (i = n_bytes; i > 0; i--)
564 unsigned int c = *(const unsigned char *) block;
603 sprintf (buf, (ISPRINT (c) ? " %c" : "%03o"), c);
604 s = (const char *) buf;
608 block += sizeof (unsigned char);
612 /* Convert a null-terminated (possibly zero-length) string S to an
613 unsigned long integer value. If S points to a non-digit set *P to S,
614 *VAL to 0, and return 0. Otherwise, accumulate the integer value of
615 the string of digits. If the string of digits represents a value
616 larger than ULONG_MAX, don't modify *VAL or *P and return nonzero.
617 Otherwise, advance *P to the first non-digit after S, set *VAL to
618 the result of the conversion and return zero. */
621 simple_strtoul (const char *s, const char **p, long unsigned int *val)
623 unsigned long int sum;
628 unsigned int c = *s++ - '0';
629 if (sum > (ULONG_MAX - c) / 10)
638 /* If S points to a single valid POSIX-style od format string, put
639 a description of that format in *TSPEC, make *NEXT point at the
640 character following the just-decoded format (if *NEXT is non-NULL),
641 and return zero. If S is not valid, don't modify *NEXT or *TSPEC,
642 give a diagnostic, and return nonzero. For example, if S were
643 "d4afL" *NEXT would be set to "afL" and *TSPEC would be
645 fmt = SIGNED_DECIMAL;
646 size = INT or LONG; (whichever integral_type_size[4] resolves to)
647 print_function = print_int; (assuming size == INT)
648 fmt_string = "%011d%c";
650 S_ORIG is solely for reporting errors. It should be the full format
655 decode_one_format (const char *s_orig, const char *s, const char **next,
658 enum size_spec size_spec;
659 unsigned long int size;
660 enum output_format fmt;
661 const char *pre_fmt_string;
663 void (*print_function) PARAMS ((size_t, const char *, const char *));
666 unsigned int field_width = 0;
668 assert (tspec != NULL);
682 size = sizeof (char);
687 size = sizeof (short);
697 size = sizeof (long int);
701 if (simple_strtoul (s, &p, &size) != 0)
703 /* The integer at P in S would overflow an unsigned long.
704 A digit string that long is sufficiently odd looking
705 that the following diagnostic is sufficient. */
706 error (0, 0, _("invalid type string `%s'"), s_orig);
713 if (MAX_INTEGRAL_TYPE_SIZE < size
714 || integral_type_size[size] == NO_SIZE)
716 error (0, 0, _("invalid type string `%s';\n\
717 this system doesn't provide a %lu-byte integral type"), s_orig, size);
725 #define FMT_BYTES_ALLOCATED 9
726 fmt_string = xmalloc (FMT_BYTES_ALLOCATED);
728 size_spec = integral_type_size[size];
733 fmt = SIGNED_DECIMAL;
734 sprintf (fmt_string, " %%%u%sd",
735 (field_width = bytes_to_signed_dec_digits[size]),
736 (size_spec == LONG ? "l"
737 : (size_spec == LONG_LONG ? "ll"
743 sprintf (fmt_string, " %%0%u%so",
744 (field_width = bytes_to_oct_digits[size]),
745 (size_spec == LONG ? "l" : ""));
749 fmt = UNSIGNED_DECIMAL;
750 sprintf (fmt_string, " %%%u%su",
751 (field_width = bytes_to_unsigned_dec_digits[size]),
752 (size_spec == LONG ? "l" : ""));
757 sprintf (fmt_string, " %%0%u%sx",
758 (field_width = bytes_to_hex_digits[size]),
759 (size_spec == LONG ? "l" : ""));
766 assert (strlen (fmt_string) < FMT_BYTES_ALLOCATED);
771 print_function = (fmt == SIGNED_DECIMAL
777 print_function = (fmt == SIGNED_DECIMAL
783 print_function = print_int;
787 print_function = print_long;
791 print_function = print_long_long;
800 fmt = FLOATING_POINT;
806 size = sizeof (float);
811 size = sizeof (double);
816 size = sizeof (LONG_DOUBLE);
820 if (simple_strtoul (s, &p, &size) != 0)
822 /* The integer at P in S would overflow an unsigned long.
823 A digit string that long is sufficiently odd looking
824 that the following diagnostic is sufficient. */
825 error (0, 0, _("invalid type string `%s'"), s_orig);
829 size = sizeof (double);
832 if (size > MAX_FP_TYPE_SIZE
833 || fp_type_size[size] == NO_SIZE)
835 error (0, 0, _("invalid type string `%s';\n\
836 this system doesn't provide a %lu-byte floating point type"), s_orig, size);
843 size_spec = fp_type_size[size];
848 print_function = print_float;
849 /* Don't use %#e; not all systems support it. */
850 pre_fmt_string = " %%%d.%de";
851 fmt_string = xmalloc (strlen (pre_fmt_string));
852 sprintf (fmt_string, pre_fmt_string,
853 (field_width = FLT_DIG + 8), FLT_DIG);
857 print_function = print_double;
858 pre_fmt_string = " %%%d.%de";
859 fmt_string = xmalloc (strlen (pre_fmt_string));
860 sprintf (fmt_string, pre_fmt_string,
861 (field_width = DBL_DIG + 8), DBL_DIG);
864 #ifdef HAVE_LONG_DOUBLE
865 case FLOAT_LONG_DOUBLE:
866 print_function = print_long_double;
867 pre_fmt_string = " %%%d.%dLe";
868 fmt_string = xmalloc (strlen (pre_fmt_string));
869 sprintf (fmt_string, pre_fmt_string,
870 (field_width = LDBL_DIG + 8), LDBL_DIG);
881 fmt = NAMED_CHARACTER;
884 print_function = print_named_ascii;
893 print_function = print_ascii;
898 error (0, 0, _("invalid character `%c' in type string `%s'"),
903 tspec->size = size_spec;
905 tspec->print_function = print_function;
906 tspec->fmt_string = fmt_string;
908 tspec->field_width = field_width;
909 tspec->hexl_mode_trailer = (*s == 'z');
910 if (tspec->hexl_mode_trailer)
919 /* Given a list of one or more input filenames FILE_LIST, set the global
920 file pointer IN_STREAM and the global string INPUT_FILENAME to the
921 first one that can be successfully opened. Modify FILE_LIST to
922 reference the next filename in the list. A file name of "-" is
923 interpreted as standard input. If any file open fails, give an error
924 message and return nonzero. */
927 open_next_file (void)
933 input_filename = *file_list;
934 if (input_filename == NULL)
938 if (STREQ (input_filename, "-"))
940 input_filename = _("standard input");
946 in_stream = fopen (input_filename, "r");
947 if (in_stream == NULL)
949 error (0, errno, "%s", input_filename);
954 while (in_stream == NULL);
956 if (limit_bytes_to_format && !flag_dump_strings)
957 SETVBUF (in_stream, NULL, _IONBF, 0);
958 SET_BINARY (fileno (in_stream));
963 /* Test whether there have been errors on in_stream, and close it if
964 it is not standard input. Return nonzero if there has been an error
965 on in_stream or stdout; return zero otherwise. This function will
966 report more than one error only if both a read and a write error
970 check_and_close (void)
974 if (in_stream != NULL)
976 if (ferror (in_stream))
978 error (0, errno, "%s", input_filename);
979 if (in_stream != stdin)
983 else if (in_stream != stdin && fclose (in_stream) == EOF)
985 error (0, errno, "%s", input_filename);
994 error (0, errno, _("standard output"));
1001 /* Decode the POSIX-style od format string S. Append the decoded
1002 representation to the global array SPEC, reallocating SPEC if
1003 necessary. Return zero if S is valid, nonzero otherwise. */
1006 decode_format_string (const char *s)
1008 const char *s_orig = s;
1016 if (decode_one_format (s_orig, s, &next, &tspec))
1022 if (n_specs >= n_specs_allocated)
1024 n_specs_allocated = 1 + (3 * n_specs_allocated) / 2;
1025 spec = (struct tspec *) xrealloc ((char *) spec,
1027 * sizeof (struct tspec)));
1030 memcpy ((char *) &spec[n_specs], (char *) &tspec,
1031 sizeof (struct tspec));
1038 /* Given a list of one or more input filenames FILE_LIST, set the global
1039 file pointer IN_STREAM to position N_SKIP in the concatenation of
1040 those files. If any file operation fails or if there are fewer than
1041 N_SKIP bytes in the combined input, give an error message and return
1042 nonzero. When possible, use seek rather than read operations to
1043 advance IN_STREAM. */
1046 skip (uintmax_t n_skip)
1053 while (in_stream != NULL) /* EOF. */
1055 struct stat file_stats;
1057 /* First try seeking. For large offsets, this extra work is
1058 worthwhile. If the offset is below some threshold it may be
1059 more efficient to move the pointer by reading. There are two
1060 issues when trying to seek:
1061 - the file must be seekable.
1062 - before seeking to the specified position, make sure
1063 that the new position is in the current file.
1064 Try to do that by getting file's size using fstat.
1065 But that will work only for regular files. */
1067 if (fstat (fileno (in_stream), &file_stats) == 0)
1069 /* The st_size field is valid only for regular files
1070 (and for symbolic links, which cannot occur here).
1071 If the number of bytes left to skip is at least
1072 as large as the size of the current file, we can
1073 decrement n_skip and go on to the next file. */
1075 if (S_ISREG (file_stats.st_mode) && 0 <= file_stats.st_size)
1077 if (file_stats.st_size <= n_skip)
1078 n_skip -= file_stats.st_size;
1081 if (lseek (fileno (in_stream), n_skip, SEEK_CUR) < 0)
1083 error (0, errno, "%s", input_filename);
1090 /* If it's not a regular file with nonnegative size,
1091 position the file pointer by reading. */
1096 size_t n_bytes_read, n_bytes_to_read = BUFSIZ;
1100 if (n_skip < n_bytes_to_read)
1101 n_bytes_to_read = n_skip;
1102 n_bytes_read = fread (buf, 1, n_bytes_to_read, in_stream);
1103 n_skip -= n_bytes_read;
1104 if (n_bytes_read != n_bytes_to_read)
1113 else /* cannot fstat() file */
1115 error (0, errno, "%s", input_filename);
1119 err |= check_and_close ();
1121 err |= open_next_file ();
1125 error (EXIT_FAILURE, 0, _("cannot skip past end of combined input"));
1131 format_address_none (uintmax_t address ATTRIBUTE_UNUSED, char c ATTRIBUTE_UNUSED)
1136 format_address_std (uintmax_t address, char c)
1138 char buf[MAX_ADDRESS_LENGTH + 2];
1139 char *p = buf + sizeof buf;
1144 pbound = p - address_pad_len;
1146 /* Use a special case of the code for each base. This is measurably
1147 faster than generic code. */
1148 switch (address_base)
1152 *--p = '0' + (address & 7);
1153 while ((address >>= 3) != 0);
1158 *--p = '0' + (address % 10);
1159 while ((address /= 10) != 0);
1164 *--p = "0123456789abcdef"[address & 15];
1165 while ((address >>= 4) != 0);
1176 format_address_paren (uintmax_t address, char c)
1179 format_address_std (address, ')');
1184 format_address_label (uintmax_t address, char c)
1186 format_address_std (address, ' ');
1187 format_address_paren (address + pseudo_offset, c);
1190 /* Write N_BYTES bytes from CURR_BLOCK to standard output once for each
1191 of the N_SPEC format specs. CURRENT_OFFSET is the byte address of
1192 CURR_BLOCK in the concatenation of input files, and it is printed
1193 (optionally) only before the output line associated with the first
1194 format spec. When duplicate blocks are being abbreviated, the output
1195 for a sequence of identical input blocks is the output for the first
1196 block followed by an asterisk alone on a line. It is valid to compare
1197 the blocks PREV_BLOCK and CURR_BLOCK only when N_BYTES == BYTES_PER_BLOCK.
1198 That condition may be false only for the last input block -- and then
1199 only when it has not been padded to length BYTES_PER_BLOCK. */
1202 write_block (uintmax_t current_offset, size_t n_bytes,
1203 const char *prev_block, const char *curr_block)
1205 static int first = 1;
1206 static int prev_pair_equal = 0;
1208 #define EQUAL_BLOCKS(b1, b2) (memcmp ((b1), (b2), bytes_per_block) == 0)
1210 if (abbreviate_duplicate_blocks
1211 && !first && n_bytes == bytes_per_block
1212 && EQUAL_BLOCKS (prev_block, curr_block))
1214 if (prev_pair_equal)
1216 /* The two preceding blocks were equal, and the current
1217 block is the same as the last one, so print nothing. */
1222 prev_pair_equal = 1;
1229 prev_pair_equal = 0;
1230 for (i = 0; i < n_specs; i++)
1233 format_address (current_offset, '\0');
1235 printf ("%*s", address_pad_len, "");
1236 (*spec[i].print_function) (n_bytes, curr_block, spec[i].fmt_string);
1237 if (spec[i].hexl_mode_trailer)
1239 /* space-pad out to full line width, then dump the trailer */
1240 int datum_width = width_bytes[spec[i].size];
1241 int blank_fields = (bytes_per_block - n_bytes) / datum_width;
1242 int field_width = spec[i].field_width + 1;
1243 printf ("%*s", blank_fields * field_width, "");
1244 dump_hexl_mode_trailer (n_bytes, curr_block);
1252 /* Read a single byte into *C from the concatenation of the input files
1253 named in the global array FILE_LIST. On the first call to this
1254 function, the global variable IN_STREAM is expected to be an open
1255 stream associated with the input file INPUT_FILENAME. If IN_STREAM
1256 is at end-of-file, close it and update the global variables IN_STREAM
1257 and INPUT_FILENAME so they correspond to the next file in the list.
1258 Then try to read a byte from the newly opened file. Repeat if
1259 necessary until EOF is reached for the last file in FILE_LIST, then
1260 set *C to EOF and return. Subsequent calls do likewise. The return
1261 value is nonzero if any errors occured, zero otherwise. */
1270 while (in_stream != NULL) /* EOF. */
1272 *c = fgetc (in_stream);
1277 err |= check_and_close ();
1279 err |= open_next_file ();
1285 /* Read N bytes into BLOCK from the concatenation of the input files
1286 named in the global array FILE_LIST. On the first call to this
1287 function, the global variable IN_STREAM is expected to be an open
1288 stream associated with the input file INPUT_FILENAME. If all N
1289 bytes cannot be read from IN_STREAM, close IN_STREAM and update
1290 the global variables IN_STREAM and INPUT_FILENAME. Then try to
1291 read the remaining bytes from the newly opened file. Repeat if
1292 necessary until EOF is reached for the last file in FILE_LIST.
1293 On subsequent calls, don't modify BLOCK and return zero. Set
1294 *N_BYTES_IN_BUFFER to the number of bytes read. If an error occurs,
1295 it will be detected through ferror when the stream is about to be
1296 closed. If there is an error, give a message but continue reading
1297 as usual and return nonzero. Otherwise return zero. */
1300 read_block (size_t n, char *block, size_t *n_bytes_in_buffer)
1304 assert (0 < n && n <= bytes_per_block);
1306 *n_bytes_in_buffer = 0;
1311 while (in_stream != NULL) /* EOF. */
1316 n_needed = n - *n_bytes_in_buffer;
1317 n_read = fread (block + *n_bytes_in_buffer, 1, n_needed, in_stream);
1319 *n_bytes_in_buffer += n_read;
1321 if (n_read == n_needed)
1324 err |= check_and_close ();
1326 err |= open_next_file ();
1332 /* Return the least common multiple of the sizes associated
1333 with the format specs. */
1341 for (i = 0; i < n_specs; i++)
1342 l_c_m = lcm (l_c_m, width_bytes[(int) spec[i].size]);
1346 /* If S is a valid pre-POSIX offset specification with an optional leading '+'
1347 return nonzero and set *OFFSET to the offset it denotes. */
1350 parse_old_offset (const char *s, uintmax_t *offset)
1353 enum strtol_error s_err;
1358 /* Skip over any leading '+'. */
1362 /* Determine the radix we'll use to interpret S. If there is a `.',
1363 it's decimal, otherwise, if the string begins with `0X'or `0x',
1364 it's hexadecimal, else octal. */
1365 if (strchr (s, '.') != NULL)
1369 if (s[0] == '0' && (s[1] == 'x' || s[1] == 'X'))
1375 s_err = xstrtoumax (s, NULL, radix, offset, "Bb");
1376 if (s_err != LONGINT_OK)
1378 STRTOL_FAIL_WARN (s, _("old-style offset"), s_err);
1384 /* Read a chunk of size BYTES_PER_BLOCK from the input files, write the
1385 formatted block to standard output, and repeat until the specified
1386 maximum number of bytes has been read or until all input has been
1387 processed. If the last block read is smaller than BYTES_PER_BLOCK
1388 and its size is not a multiple of the size associated with a format
1389 spec, extend the input block with zero bytes until its length is a
1390 multiple of all format spec sizes. Write the final block. Finally,
1391 write on a line by itself the offset of the byte after the last byte
1392 read. Accumulate return values from calls to read_block and
1393 check_and_close, and if any was nonzero, return nonzero.
1394 Otherwise, return zero. */
1400 uintmax_t current_offset;
1403 size_t n_bytes_read;
1405 block[0] = (char *) alloca (bytes_per_block);
1406 block[1] = (char *) alloca (bytes_per_block);
1408 current_offset = n_bytes_to_skip;
1412 if (limit_bytes_to_format)
1417 if (current_offset >= end_offset)
1422 n_needed = MIN (end_offset - current_offset,
1423 (uintmax_t) bytes_per_block);
1424 err |= read_block (n_needed, block[idx], &n_bytes_read);
1425 if (n_bytes_read < bytes_per_block)
1427 assert (n_bytes_read == bytes_per_block);
1428 write_block (current_offset, n_bytes_read,
1429 block[!idx], block[idx]);
1430 current_offset += n_bytes_read;
1438 err |= read_block (bytes_per_block, block[idx], &n_bytes_read);
1439 if (n_bytes_read < bytes_per_block)
1441 assert (n_bytes_read == bytes_per_block);
1442 write_block (current_offset, n_bytes_read,
1443 block[!idx], block[idx]);
1444 current_offset += n_bytes_read;
1449 if (n_bytes_read > 0)
1452 size_t bytes_to_write;
1456 /* Make bytes_to_write the smallest multiple of l_c_m that
1457 is at least as large as n_bytes_read. */
1458 bytes_to_write = l_c_m * ((n_bytes_read + l_c_m - 1) / l_c_m);
1460 memset (block[idx] + n_bytes_read, 0, bytes_to_write - n_bytes_read);
1461 write_block (current_offset, bytes_to_write,
1462 block[!idx], block[idx]);
1463 current_offset += n_bytes_read;
1466 format_address (current_offset, '\n');
1468 if (limit_bytes_to_format && current_offset >= end_offset)
1469 err |= check_and_close ();
1474 /* STRINGS mode. Find each "string constant" in the input.
1475 A string constant is a run of at least `string_min' ASCII
1476 graphic (or formatting) characters terminated by a null.
1477 Based on a function written by Richard Stallman for a
1478 pre-POSIX version of od. Return nonzero if an error
1479 occurs. Otherwise, return zero. */
1484 size_t bufsize = MAX (100, string_min);
1485 char *buf = xmalloc (bufsize);
1486 uintmax_t address = n_bytes_to_skip;
1495 /* See if the next `string_min' chars are all printing chars. */
1498 if (limit_bytes_to_format
1499 && (end_offset < string_min || end_offset - string_min <= address))
1502 for (i = 0; i < string_min; i++)
1504 err |= read_char (&c);
1512 /* Found a non-printing. Try again starting with next char. */
1517 /* We found a run of `string_min' printable characters.
1518 Now see if it is terminated with a null byte. */
1519 while (!limit_bytes_to_format || address < end_offset)
1523 bufsize = 1 + 3 * bufsize / 2;
1524 buf = xrealloc (buf, bufsize);
1526 err |= read_char (&c);
1534 break; /* It is; print this string. */
1536 goto tryline; /* It isn't; give up on this string. */
1537 buf[i++] = c; /* String continues; store it all. */
1540 /* If we get here, the string is all printable and null-terminated,
1541 so print it. It is all in `buf' and `i' is its length. */
1543 format_address (address - i - 1, ' ');
1545 for (i = 0; (c = buf[i]); i++)
1550 fputs ("\\a", stdout);
1554 fputs ("\\b", stdout);
1558 fputs ("\\f", stdout);
1562 fputs ("\\n", stdout);
1566 fputs ("\\r", stdout);
1570 fputs ("\\t", stdout);
1574 fputs ("\\v", stdout);
1584 /* We reach this point only if we search through
1585 (max_bytes_to_format - string_min) bytes before reaching EOF. */
1589 err |= check_and_close ();
1594 main (int argc, char **argv)
1600 size_t desired_width IF_LINT (= 0);
1601 int width_specified = 0;
1602 int n_failed_decodes = 0;
1605 /* The old-style `pseudo starting address' to be printed in parentheses
1606 after any true address. */
1607 uintmax_t pseudo_start IF_LINT (= 0);
1609 program_name = argv[0];
1610 setlocale (LC_ALL, "");
1611 bindtextdomain (PACKAGE, LOCALEDIR);
1612 textdomain (PACKAGE);
1614 atexit (close_stdout);
1618 for (i = 0; i <= MAX_INTEGRAL_TYPE_SIZE; i++)
1619 integral_type_size[i] = NO_SIZE;
1621 integral_type_size[sizeof (char)] = CHAR;
1622 integral_type_size[sizeof (short int)] = SHORT;
1623 integral_type_size[sizeof (int)] = INT;
1624 integral_type_size[sizeof (long int)] = LONG;
1625 #if HAVE_UNSIGNED_LONG_LONG
1626 integral_type_size[sizeof (ulonglong_t)] = LONG_LONG;
1629 for (i = 0; i <= MAX_FP_TYPE_SIZE; i++)
1630 fp_type_size[i] = NO_SIZE;
1632 fp_type_size[sizeof (float)] = FLOAT_SINGLE;
1633 /* The array entry for `double' is filled in after that for LONG_DOUBLE
1634 so that if `long double' is the same type or if long double isn't
1635 supported FLOAT_LONG_DOUBLE will never be used. */
1636 fp_type_size[sizeof (LONG_DOUBLE)] = FLOAT_LONG_DOUBLE;
1637 fp_type_size[sizeof (double)] = FLOAT_DOUBLE;
1640 n_specs_allocated = 5;
1641 spec = (struct tspec *) xmalloc (n_specs_allocated * sizeof (struct tspec));
1643 format_address = format_address_std;
1645 address_pad_len = 7;
1646 flag_dump_strings = 0;
1648 while ((c = getopt_long (argc, argv, "abcdfhilos::xw::A:j:N:t:v",
1649 long_options, NULL)) != -1)
1652 enum strtol_error s_err;
1663 format_address = format_address_std;
1665 address_pad_len = 7;
1668 format_address = format_address_std;
1670 address_pad_len = 7;
1673 format_address = format_address_std;
1675 address_pad_len = 6;
1678 format_address = format_address_none;
1679 address_pad_len = 0;
1682 error (EXIT_FAILURE, 0,
1683 _("invalid output address radix `%c'; \
1684 it must be one character from [doxn]"),
1691 s_err = xstrtoumax (optarg, NULL, 0, &n_bytes_to_skip, "bkm");
1692 if (s_err != LONGINT_OK)
1693 STRTOL_FATAL_ERROR (optarg, _("skip argument"), s_err);
1697 limit_bytes_to_format = 1;
1699 s_err = xstrtoumax (optarg, NULL, 0, &max_bytes_to_format, "bkm");
1700 if (s_err != LONGINT_OK)
1701 STRTOL_FATAL_ERROR (optarg, _("limit argument"), s_err);
1709 s_err = xstrtoumax (optarg, NULL, 0, &tmp, "bkm");
1710 if (s_err != LONGINT_OK)
1711 STRTOL_FATAL_ERROR (optarg, _("minimum string length"), s_err);
1713 /* The minimum string length may be no larger than SIZE_MAX,
1714 since we may allocate a buffer of this size. */
1716 error (EXIT_FAILURE, 0, _("%s is too large"), optarg);
1720 flag_dump_strings = 1;
1724 if (decode_format_string (optarg))
1729 abbreviate_duplicate_blocks = 0;
1736 /* The next several cases map the old, pre-POSIX format
1737 specification options to the corresponding POSIX format
1738 specs. GNU od accepts any combination of old- and
1739 new-style options. Format specification options accumulate. */
1741 #define CASE_OLD_ARG(old_char,new_string) \
1744 if (decode_format_string (new_string)) \
1745 ++n_failed_decodes; \
1749 CASE_OLD_ARG ('a', "a");
1750 CASE_OLD_ARG ('b', "oC");
1751 CASE_OLD_ARG ('c', "c");
1752 CASE_OLD_ARG ('d', "u2");
1753 CASE_OLD_ARG ('f', "fF");
1754 CASE_OLD_ARG ('h', "x2");
1755 CASE_OLD_ARG ('i', "d2");
1756 CASE_OLD_ARG ('l', "d4");
1757 CASE_OLD_ARG ('o', "o2");
1758 CASE_OLD_ARG ('x', "x2");
1763 width_specified = 1;
1771 s_err = xstrtoumax (optarg, NULL, 10, &w_tmp, "");
1772 if (s_err != LONGINT_OK)
1773 STRTOL_FATAL_ERROR (optarg, _("width specification"), s_err);
1774 if (SIZE_MAX < w_tmp)
1775 error (EXIT_FAILURE, 0, _("%s is too large"), optarg);
1776 desired_width = w_tmp;
1780 case_GETOPT_HELP_CHAR;
1782 case_GETOPT_VERSION_CHAR (PROGRAM_NAME, AUTHORS);
1790 if (n_failed_decodes > 0)
1791 exit (EXIT_FAILURE);
1793 if (flag_dump_strings && n_specs > 0)
1794 error (EXIT_FAILURE, 0,
1795 _("no type may be specified when dumping strings"));
1797 n_files = argc - optind;
1799 /* If the --backward-compatible option is used, there may be from
1800 0 to 3 remaining command line arguments; handle each case
1802 od [file] [[+]offset[.][b] [[+]label[.][b]]]
1803 The offset and pseudo_start have the same syntax. */
1811 if (parse_old_offset (argv[optind], &offset))
1813 n_bytes_to_skip = offset;
1818 else if (n_files == 2)
1821 if (parse_old_offset (argv[optind], &o1)
1822 && parse_old_offset (argv[optind + 1], &o2))
1824 n_bytes_to_skip = o1;
1825 flag_pseudo_start = 1;
1830 else if (parse_old_offset (argv[optind + 1], &o2))
1832 n_bytes_to_skip = o2;
1834 argv[optind + 1] = argv[optind];
1840 _("invalid second operand in compatibility mode `%s'"),
1845 else if (n_files == 3)
1848 if (parse_old_offset (argv[optind + 1], &o1)
1849 && parse_old_offset (argv[optind + 2], &o2))
1851 n_bytes_to_skip = o1;
1852 flag_pseudo_start = 1;
1854 argv[optind + 2] = argv[optind];
1861 _("in compatibility mode, the last two arguments must be offsets"));
1865 else if (n_files > 3)
1868 _("compatibility mode supports at most three arguments"));
1872 if (flag_pseudo_start)
1874 if (format_address == format_address_none)
1877 address_pad_len = 7;
1878 format_address = format_address_paren;
1881 format_address = format_address_label;
1885 if (limit_bytes_to_format)
1887 end_offset = n_bytes_to_skip + max_bytes_to_format;
1888 if (end_offset < n_bytes_to_skip)
1889 error (EXIT_FAILURE, 0, "skip-bytes + read-bytes is too large");
1894 if (decode_one_format ("o2", "o2", NULL, &(spec[0])))
1896 /* This happens on Cray systems that don't have a 2-byte
1898 exit (EXIT_FAILURE);
1906 /* Set the global pointer FILE_LIST so that it
1907 references the first file-argument on the command-line. */
1909 file_list = (char const *const *) &argv[optind];
1913 /* No files were listed on the command line.
1914 Set the global pointer FILE_LIST so that it
1915 references the null-terminated list of one name: "-". */
1917 file_list = default_file_list;
1920 /* open the first input file */
1921 err |= open_next_file ();
1922 if (in_stream == NULL)
1925 /* skip over any unwanted header bytes */
1926 err |= skip (n_bytes_to_skip);
1927 if (in_stream == NULL)
1930 pseudo_offset = (flag_pseudo_start ? pseudo_start - n_bytes_to_skip : 0);
1932 /* Compute output block length. */
1935 if (width_specified)
1937 if (desired_width != 0 && desired_width % l_c_m == 0)
1938 bytes_per_block = desired_width;
1941 error (0, 0, _("warning: invalid width %lu; using %d instead"),
1942 (unsigned long) desired_width, l_c_m);
1943 bytes_per_block = l_c_m;
1948 if (l_c_m < DEFAULT_BYTES_PER_BLOCK)
1949 bytes_per_block = l_c_m * (DEFAULT_BYTES_PER_BLOCK / l_c_m);
1951 bytes_per_block = l_c_m;
1955 for (i = 0; i < n_specs; i++)
1957 printf (_("%d: fmt=\"%s\" width=%d\n"),
1958 i, spec[i].fmt_string, width_bytes[spec[i].size]);
1962 err |= (flag_dump_strings ? dump_strings () : dump ());
1966 if (have_read_stdin && fclose (stdin) == EOF)
1967 error (EXIT_FAILURE, errno, _("standard input"));
1969 exit (err == 0 ? EXIT_SUCCESS : EXIT_FAILURE);