1 /* od -- dump files in octal and other formats
2 Copyright (C) 92, 1995-2002 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>
32 /* The official name of this program (e.g., no `g' prefix). */
33 #define PROGRAM_NAME "od"
35 #define AUTHORS "Jim Meyering"
37 #if defined(__GNUC__) || defined(STDC_HEADERS)
41 #ifdef HAVE_LONG_DOUBLE
42 typedef long double LONG_DOUBLE;
44 typedef double LONG_DOUBLE;
51 /* The default number of input bytes per output line. */
52 #define DEFAULT_BYTES_PER_BLOCK 16
54 /* The number of decimal digits of precision in a float. */
59 /* The number of decimal digits of precision in a double. */
64 /* The number of decimal digits of precision in a long double. */
66 # define LDBL_DIG DBL_DIG
69 #if HAVE_UNSIGNED_LONG_LONG
70 typedef unsigned long long ulonglong_t;
72 /* This is just a place-holder to avoid a few `#if' directives.
73 In this case, the type isn't actually used. */
74 typedef unsigned long int ulonglong_t;
85 /* FIXME: add INTMAX support, too */
103 /* Each output format specification (from `-t spec' or from
104 old-style options) is represented by one of these structures. */
107 enum output_format fmt;
109 void (*print_function) PARAMS ((size_t, const char *, const char *));
111 int hexl_mode_trailer;
115 /* The name this program was run with. */
118 /* Convert the number of 8-bit bytes of a binary representation to
119 the number of characters (digits + sign if the type is signed)
120 required to represent the same quantity in the specified base/type.
121 For example, a 32-bit (4-byte) quantity may require a field width
122 as wide as the following for these types:
126 8 unsigned hexadecimal */
128 static const unsigned int bytes_to_oct_digits[] =
129 {0, 3, 6, 8, 11, 14, 16, 19, 22, 25, 27, 30, 32, 35, 38, 41, 43};
131 static const unsigned int bytes_to_signed_dec_digits[] =
132 {1, 4, 6, 8, 11, 13, 16, 18, 20, 23, 25, 28, 30, 33, 35, 37, 40};
134 static const unsigned int bytes_to_unsigned_dec_digits[] =
135 {0, 3, 5, 8, 10, 13, 15, 17, 20, 22, 25, 27, 29, 32, 34, 37, 39};
137 static const unsigned int bytes_to_hex_digits[] =
138 {0, 2, 4, 6, 8, 10, 12, 14, 16, 18, 20, 22, 24, 26, 28, 30, 32};
140 /* Convert enum size_spec to the size of the named type. */
141 static const int width_bytes[] =
148 sizeof (ulonglong_t),
154 /* Ensure that for each member of `enum size_spec' there is an
155 initializer in the width_bytes array. */
158 int assert_width_bytes_matches_size_spec_decl
159 [sizeof width_bytes / sizeof width_bytes[0] == N_SIZE_SPECS ? 1 : -1];
162 /* Names for some non-printing characters. */
163 static const char *const charname[33] =
165 "nul", "soh", "stx", "etx", "eot", "enq", "ack", "bel",
166 "bs", "ht", "nl", "vt", "ff", "cr", "so", "si",
167 "dle", "dc1", "dc2", "dc3", "dc4", "nak", "syn", "etb",
168 "can", "em", "sub", "esc", "fs", "gs", "rs", "us",
172 /* Address base (8, 10 or 16). */
173 static int address_base;
175 /* The number of octal digits required to represent the largest
177 #define MAX_ADDRESS_LENGTH \
178 ((sizeof (uintmax_t) * CHAR_BIT + CHAR_BIT - 1) / 3)
180 /* Width of a normal address. */
181 static int address_pad_len;
183 static size_t string_min;
184 static int flag_dump_strings;
186 /* Non-zero if we should recognize the older non-option arguments
187 that specified at most one file and optional arguments specifying
188 offset and pseudo-start address. */
189 static int traditional;
191 /* Non-zero if an old-style `pseudo-address' was specified. */
192 static int flag_pseudo_start;
194 /* The difference between the old-style pseudo starting address and
195 the number of bytes to skip. */
196 static uintmax_t pseudo_offset;
198 /* Function that accepts an address and an optional following char,
199 and prints the address and char to stdout. */
200 static void (*format_address) PARAMS ((uintmax_t, char));
202 /* The number of input bytes to skip before formatting and writing. */
203 static uintmax_t n_bytes_to_skip = 0;
205 /* When zero, MAX_BYTES_TO_FORMAT and END_OFFSET are ignored, and all
206 input is formatted. */
207 static int limit_bytes_to_format = 0;
209 /* The maximum number of bytes that will be formatted. */
210 static uintmax_t max_bytes_to_format;
212 /* The offset of the first byte after the last byte to be formatted. */
213 static uintmax_t end_offset;
215 /* When nonzero and two or more consecutive blocks are equal, format
216 only the first block and output an asterisk alone on the following
217 line to indicate that identical blocks have been elided. */
218 static int abbreviate_duplicate_blocks = 1;
220 /* An array of specs describing how to format each input block. */
221 static struct tspec *spec;
223 /* The number of format specs. */
224 static size_t n_specs;
226 /* The allocated length of SPEC. */
227 static size_t n_specs_allocated;
229 /* The number of input bytes formatted per output line. It must be
230 a multiple of the least common multiple of the sizes associated with
231 the specified output types. It should be as large as possible, but
232 no larger than 16 -- unless specified with the -w option. */
233 static size_t bytes_per_block;
235 /* Human-readable representation of *file_list (for error messages).
236 It differs from *file_list only when *file_list is "-". */
237 static char const *input_filename;
239 /* A NULL-terminated list of the file-arguments from the command line. */
240 static char const *const *file_list;
242 /* Initializer for file_list if no file-arguments
243 were specified on the command line. */
244 static char const *const default_file_list[] = {"-", NULL};
246 /* The input stream associated with the current file. */
247 static FILE *in_stream;
249 /* If nonzero, at least one of the files we read was standard input. */
250 static int have_read_stdin;
252 #define MAX_INTEGRAL_TYPE_SIZE sizeof (ulonglong_t)
253 static enum size_spec integral_type_size[MAX_INTEGRAL_TYPE_SIZE + 1];
255 #define MAX_FP_TYPE_SIZE sizeof(LONG_DOUBLE)
256 static enum size_spec fp_type_size[MAX_FP_TYPE_SIZE + 1];
258 #define COMMON_SHORT_OPTIONS "A:N:abcdfhij:lot:vx"
260 /* For long options that have no equivalent short option, use a
261 non-character as a pseudo short option, starting with CHAR_MAX + 1. */
264 TRADITIONAL_OPTION = CHAR_MAX + 1
267 static struct option const long_options[] =
269 {"skip-bytes", required_argument, NULL, 'j'},
270 {"address-radix", required_argument, NULL, 'A'},
271 {"read-bytes", required_argument, NULL, 'N'},
272 {"format", required_argument, NULL, 't'},
273 {"output-duplicates", no_argument, NULL, 'v'},
274 {"strings", optional_argument, NULL, 's'},
275 {"traditional", no_argument, NULL, TRADITIONAL_OPTION},
276 {"width", optional_argument, NULL, 'w'},
278 {GETOPT_HELP_OPTION_DECL},
279 {GETOPT_VERSION_OPTION_DECL},
287 fprintf (stderr, _("Try `%s --help' for more information.\n"),
292 Usage: %s [OPTION]... [FILE]...\n\
293 or: %s --traditional [FILE] [[+]OFFSET [[+]LABEL]]\n\
295 program_name, program_name);
297 Write an unambiguous representation, octal bytes by default,\n\
298 of FILE to standard output. With more than one FILE argument,\n\
299 concatenate them in the listed order to form the input.\n\
300 With no FILE, or when FILE is -, read standard input.\n\
304 All arguments to long options are mandatory for short options.\n\
307 -A, --address-radix=RADIX decide how file offsets are printed\n\
308 -j, --skip-bytes=BYTES skip BYTES input bytes first\n\
311 -N, --read-bytes=BYTES limit dump to BYTES input bytes\n\
312 -s, --strings[=BYTES] output strings of at least BYTES graphic chars\n\
313 -t, --format=TYPE select output format or formats\n\
314 -v, --output-duplicates do not use * to mark line suppression\n\
315 -w, --width[=BYTES] output BYTES bytes per output line\n\
316 --traditional accept arguments in traditional form\n\
318 fputs (HELP_OPTION_DESCRIPTION, stdout);
319 fputs (VERSION_OPTION_DESCRIPTION, stdout);
322 Traditional format specifications may be intermixed; they accumulate:\n\
323 -a same as -t a, select named characters\n\
324 -b same as -t oC, select octal bytes\n\
325 -c same as -t c, select ASCII characters or backslash escapes\n\
326 -d same as -t u2, select unsigned decimal shorts\n\
329 -f same as -t fF, select floats\n\
330 -h same as -t x2, select hexadecimal shorts\n\
331 -i same as -t d2, select decimal shorts\n\
332 -l same as -t d4, select decimal longs\n\
333 -o same as -t o2, select octal shorts\n\
334 -x same as -t x2, select hexadecimal shorts\n\
338 For older syntax (second call format), OFFSET means -j OFFSET. LABEL\n\
339 is the pseudo-address at first byte printed, incremented when dump is\n\
340 progressing. For OFFSET and LABEL, a 0x or 0X prefix indicates\n\
341 hexadecimal, suffixes may be . for octal and b for multiply by 512.\n\
343 TYPE is made up of one or more of these specifications:\n\
346 c ASCII character or backslash escape\n\
349 d[SIZE] signed decimal, SIZE bytes per integer\n\
350 f[SIZE] floating point, SIZE bytes per integer\n\
351 o[SIZE] octal, SIZE bytes per integer\n\
352 u[SIZE] unsigned decimal, SIZE bytes per integer\n\
353 x[SIZE] hexadecimal, SIZE bytes per integer\n\
357 SIZE is a number. For TYPE in doux, SIZE may also be C for\n\
358 sizeof(char), S for sizeof(short), I for sizeof(int) or L for\n\
359 sizeof(long). If TYPE is f, SIZE may also be F for sizeof(float), D\n\
360 for sizeof(double) or L for sizeof(long double).\n\
364 RADIX is d for decimal, o for octal, x for hexadecimal or n for none.\n\
365 BYTES is hexadecimal with 0x or 0X prefix, it is multiplied by 512\n\
366 with b suffix, by 1024 with k and by 1048576 with m. Adding a z suffix to\n\
367 any type adds a display of printable characters to the end of each line\n\
371 --string without a number implies 3. --width without a number\n\
372 implies 32. By default, od uses -A o -t d2 -w 16.\n\
374 printf (_("\nReport bugs to <%s>.\n"), PACKAGE_BUGREPORT);
376 exit (status == 0 ? EXIT_SUCCESS : EXIT_FAILURE);
379 /* Compute the greatest common denominator of U and V
380 using Euclid's algorithm. */
383 gcd (unsigned int u, unsigned int v)
395 /* Compute the least common multiple of U and V. */
398 lcm (unsigned int u, unsigned int v)
400 unsigned int t = gcd (u, v);
407 print_s_char (size_t n_bytes, const char *block, const char *fmt_string)
410 for (i = n_bytes; i > 0; i--)
412 int tmp = (unsigned) *(const unsigned char *) block;
414 tmp -= SCHAR_MAX - SCHAR_MIN + 1;
415 assert (tmp <= SCHAR_MAX);
416 printf (fmt_string, tmp);
417 block += sizeof (unsigned char);
422 print_char (size_t n_bytes, const char *block, const char *fmt_string)
425 for (i = n_bytes; i > 0; i--)
427 unsigned int tmp = *(const unsigned char *) block;
428 printf (fmt_string, tmp);
429 block += sizeof (unsigned char);
434 print_s_short (size_t n_bytes, const char *block, const char *fmt_string)
437 for (i = n_bytes / sizeof (unsigned short); i > 0; i--)
439 int tmp = (unsigned) *(const unsigned short *) block;
441 tmp -= SHRT_MAX - SHRT_MIN + 1;
442 assert (tmp <= SHRT_MAX);
443 printf (fmt_string, tmp);
444 block += sizeof (unsigned short);
449 print_short (size_t n_bytes, const char *block, const char *fmt_string)
452 for (i = n_bytes / sizeof (unsigned short); i > 0; i--)
454 unsigned int tmp = *(const unsigned short *) block;
455 printf (fmt_string, tmp);
456 block += sizeof (unsigned short);
461 print_int (size_t n_bytes, const char *block, const char *fmt_string)
464 for (i = n_bytes / sizeof (unsigned int); i > 0; i--)
466 unsigned int tmp = *(const unsigned int *) block;
467 printf (fmt_string, tmp);
468 block += sizeof (unsigned int);
473 print_long (size_t n_bytes, const char *block, const char *fmt_string)
476 for (i = n_bytes / sizeof (unsigned long); i > 0; i--)
478 unsigned long tmp = *(const unsigned long *) block;
479 printf (fmt_string, tmp);
480 block += sizeof (unsigned long);
485 print_long_long (size_t n_bytes, const char *block, const char *fmt_string)
488 for (i = n_bytes / sizeof (ulonglong_t); i > 0; i--)
490 ulonglong_t tmp = *(const ulonglong_t *) block;
491 printf (fmt_string, tmp);
492 block += sizeof (ulonglong_t);
497 print_float (size_t n_bytes, const char *block, const char *fmt_string)
500 for (i = n_bytes / sizeof (float); i > 0; i--)
502 float tmp = *(const float *) block;
503 printf (fmt_string, tmp);
504 block += sizeof (float);
509 print_double (size_t n_bytes, const char *block, const char *fmt_string)
512 for (i = n_bytes / sizeof (double); i > 0; i--)
514 double tmp = *(const double *) block;
515 printf (fmt_string, tmp);
516 block += sizeof (double);
520 #ifdef HAVE_LONG_DOUBLE
522 print_long_double (size_t n_bytes, const char *block, const char *fmt_string)
525 for (i = n_bytes / sizeof (LONG_DOUBLE); i > 0; i--)
527 LONG_DOUBLE tmp = *(const LONG_DOUBLE *) block;
528 printf (fmt_string, tmp);
529 block += sizeof (LONG_DOUBLE);
536 dump_hexl_mode_trailer (size_t n_bytes, const char *block)
539 fputs (" >", stdout);
540 for (i = n_bytes; i > 0; i--)
542 unsigned int c = *(const unsigned char *) block;
543 unsigned int c2 = (ISPRINT(c) ? c : '.');
545 block += sizeof (unsigned char);
551 print_named_ascii (size_t n_bytes, const char *block,
552 const char *unused_fmt_string ATTRIBUTE_UNUSED)
555 for (i = n_bytes; i > 0; i--)
557 unsigned int c = *(const unsigned char *) block;
558 unsigned int masked_c = (0x7f & c);
564 else if (masked_c <= 040)
565 s = charname[masked_c];
568 sprintf (buf, " %c", masked_c);
573 block += sizeof (unsigned char);
578 print_ascii (size_t n_bytes, const char *block,
579 const char *unused_fmt_string ATTRIBUTE_UNUSED)
582 for (i = n_bytes; i > 0; i--)
584 unsigned int c = *(const unsigned char *) block;
623 sprintf (buf, (ISPRINT (c) ? " %c" : "%03o"), c);
624 s = (const char *) buf;
628 block += sizeof (unsigned char);
632 /* Convert a null-terminated (possibly zero-length) string S to an
633 unsigned long integer value. If S points to a non-digit set *P to S,
634 *VAL to 0, and return 0. Otherwise, accumulate the integer value of
635 the string of digits. If the string of digits represents a value
636 larger than ULONG_MAX, don't modify *VAL or *P and return nonzero.
637 Otherwise, advance *P to the first non-digit after S, set *VAL to
638 the result of the conversion and return zero. */
641 simple_strtoul (const char *s, const char **p, long unsigned int *val)
643 unsigned long int sum;
648 unsigned int c = *s++ - '0';
649 if (sum > (ULONG_MAX - c) / 10)
658 /* If S points to a single valid modern od format string, put
659 a description of that format in *TSPEC, make *NEXT point at the
660 character following the just-decoded format (if *NEXT is non-NULL),
661 and return zero. If S is not valid, don't modify *NEXT or *TSPEC,
662 give a diagnostic, and return nonzero. For example, if S were
663 "d4afL" *NEXT would be set to "afL" and *TSPEC would be
665 fmt = SIGNED_DECIMAL;
666 size = INT or LONG; (whichever integral_type_size[4] resolves to)
667 print_function = print_int; (assuming size == INT)
668 fmt_string = "%011d%c";
670 S_ORIG is solely for reporting errors. It should be the full format
675 decode_one_format (const char *s_orig, const char *s, const char **next,
678 enum size_spec size_spec;
679 unsigned long int size;
680 enum output_format fmt;
681 const char *pre_fmt_string;
683 void (*print_function) PARAMS ((size_t, const char *, const char *));
686 unsigned int field_width = 0;
688 assert (tspec != NULL);
702 size = sizeof (char);
707 size = sizeof (short);
717 size = sizeof (long int);
721 if (simple_strtoul (s, &p, &size) != 0)
723 /* The integer at P in S would overflow an unsigned long.
724 A digit string that long is sufficiently odd looking
725 that the following diagnostic is sufficient. */
726 error (0, 0, _("invalid type string `%s'"), s_orig);
733 if (MAX_INTEGRAL_TYPE_SIZE < size
734 || integral_type_size[size] == NO_SIZE)
736 error (0, 0, _("invalid type string `%s';\n\
737 this system doesn't provide a %lu-byte integral type"), s_orig, size);
745 #define ISPEC_TO_FORMAT(Spec, Min_format, Long_format, Max_format) \
746 ((Spec) == LONG_LONG ? (Max_format) \
747 : ((Spec) == LONG ? (Long_format) \
750 #define FMT_BYTES_ALLOCATED 9
751 fmt_string = xmalloc (FMT_BYTES_ALLOCATED);
753 size_spec = integral_type_size[size];
758 fmt = SIGNED_DECIMAL;
759 sprintf (fmt_string, " %%%u%s",
760 (field_width = bytes_to_signed_dec_digits[size]),
761 ISPEC_TO_FORMAT (size_spec, "d", "ld", PRIdMAX));
766 sprintf (fmt_string, " %%0%u%s",
767 (field_width = bytes_to_oct_digits[size]),
768 ISPEC_TO_FORMAT (size_spec, "o", "lo", PRIoMAX));
772 fmt = UNSIGNED_DECIMAL;
773 sprintf (fmt_string, " %%%u%s",
774 (field_width = bytes_to_unsigned_dec_digits[size]),
775 ISPEC_TO_FORMAT (size_spec, "u", "lu", PRIuMAX));
780 sprintf (fmt_string, " %%0%u%s",
781 (field_width = bytes_to_hex_digits[size]),
782 ISPEC_TO_FORMAT (size_spec, "x", "lx", PRIxMAX));
789 assert (strlen (fmt_string) < FMT_BYTES_ALLOCATED);
794 print_function = (fmt == SIGNED_DECIMAL
800 print_function = (fmt == SIGNED_DECIMAL
806 print_function = print_int;
810 print_function = print_long;
814 print_function = print_long_long;
823 fmt = FLOATING_POINT;
829 size = sizeof (float);
834 size = sizeof (double);
839 size = sizeof (LONG_DOUBLE);
843 if (simple_strtoul (s, &p, &size) != 0)
845 /* The integer at P in S would overflow an unsigned long.
846 A digit string that long is sufficiently odd looking
847 that the following diagnostic is sufficient. */
848 error (0, 0, _("invalid type string `%s'"), s_orig);
852 size = sizeof (double);
855 if (size > MAX_FP_TYPE_SIZE
856 || fp_type_size[size] == NO_SIZE)
858 error (0, 0, _("invalid type string `%s';\n\
859 this system doesn't provide a %lu-byte floating point type"), s_orig, size);
866 size_spec = fp_type_size[size];
871 print_function = print_float;
872 /* Don't use %#e; not all systems support it. */
873 pre_fmt_string = " %%%d.%de";
874 fmt_string = xmalloc (strlen (pre_fmt_string));
875 sprintf (fmt_string, pre_fmt_string,
876 (field_width = FLT_DIG + 8), FLT_DIG);
880 print_function = print_double;
881 pre_fmt_string = " %%%d.%de";
882 fmt_string = xmalloc (strlen (pre_fmt_string));
883 sprintf (fmt_string, pre_fmt_string,
884 (field_width = DBL_DIG + 8), DBL_DIG);
887 #ifdef HAVE_LONG_DOUBLE
888 case FLOAT_LONG_DOUBLE:
889 print_function = print_long_double;
890 pre_fmt_string = " %%%d.%dLe";
891 fmt_string = xmalloc (strlen (pre_fmt_string));
892 sprintf (fmt_string, pre_fmt_string,
893 (field_width = LDBL_DIG + 8), LDBL_DIG);
904 fmt = NAMED_CHARACTER;
907 print_function = print_named_ascii;
916 print_function = print_ascii;
921 error (0, 0, _("invalid character `%c' in type string `%s'"),
926 tspec->size = size_spec;
928 tspec->print_function = print_function;
929 tspec->fmt_string = fmt_string;
931 tspec->field_width = field_width;
932 tspec->hexl_mode_trailer = (*s == 'z');
933 if (tspec->hexl_mode_trailer)
942 /* Given a list of one or more input filenames FILE_LIST, set the global
943 file pointer IN_STREAM and the global string INPUT_FILENAME to the
944 first one that can be successfully opened. Modify FILE_LIST to
945 reference the next filename in the list. A file name of "-" is
946 interpreted as standard input. If any file open fails, give an error
947 message and return nonzero. */
950 open_next_file (void)
956 input_filename = *file_list;
957 if (input_filename == NULL)
961 if (STREQ (input_filename, "-"))
963 input_filename = _("standard input");
969 in_stream = fopen (input_filename, "r");
970 if (in_stream == NULL)
972 error (0, errno, "%s", input_filename);
977 while (in_stream == NULL);
979 if (limit_bytes_to_format && !flag_dump_strings)
980 SETVBUF (in_stream, NULL, _IONBF, 0);
981 SET_BINARY (fileno (in_stream));
986 /* Test whether there have been errors on in_stream, and close it if
987 it is not standard input. Return nonzero if there has been an error
988 on in_stream or stdout; return zero otherwise. This function will
989 report more than one error only if both a read and a write error
993 check_and_close (void)
997 if (in_stream != NULL)
999 if (ferror (in_stream))
1001 error (0, errno, "%s", input_filename);
1002 if (in_stream != stdin)
1006 else if (in_stream != stdin && fclose (in_stream) == EOF)
1008 error (0, errno, "%s", input_filename);
1015 if (ferror (stdout))
1017 error (0, errno, _("standard output"));
1024 /* Decode the modern od format string S. Append the decoded
1025 representation to the global array SPEC, reallocating SPEC if
1026 necessary. Return zero if S is valid, nonzero otherwise. */
1029 decode_format_string (const char *s)
1031 const char *s_orig = s;
1039 if (decode_one_format (s_orig, s, &next, &tspec))
1045 if (n_specs >= n_specs_allocated)
1047 n_specs_allocated = 1 + (3 * n_specs_allocated) / 2;
1048 spec = (struct tspec *) xrealloc ((char *) spec,
1050 * sizeof (struct tspec)));
1053 memcpy ((char *) &spec[n_specs], (char *) &tspec,
1054 sizeof (struct tspec));
1061 /* Given a list of one or more input filenames FILE_LIST, set the global
1062 file pointer IN_STREAM to position N_SKIP in the concatenation of
1063 those files. If any file operation fails or if there are fewer than
1064 N_SKIP bytes in the combined input, give an error message and return
1065 nonzero. When possible, use seek rather than read operations to
1066 advance IN_STREAM. */
1069 skip (uintmax_t n_skip)
1076 while (in_stream != NULL) /* EOF. */
1078 struct stat file_stats;
1080 /* First try seeking. For large offsets, this extra work is
1081 worthwhile. If the offset is below some threshold it may be
1082 more efficient to move the pointer by reading. There are two
1083 issues when trying to seek:
1084 - the file must be seekable.
1085 - before seeking to the specified position, make sure
1086 that the new position is in the current file.
1087 Try to do that by getting file's size using fstat.
1088 But that will work only for regular files. */
1090 if (fstat (fileno (in_stream), &file_stats) == 0)
1092 /* The st_size field is valid only for regular files
1093 (and for symbolic links, which cannot occur here).
1094 If the number of bytes left to skip is at least
1095 as large as the size of the current file, we can
1096 decrement n_skip and go on to the next file. */
1098 if (S_ISREG (file_stats.st_mode) && 0 <= file_stats.st_size)
1100 if ((uintmax_t) file_stats.st_size <= n_skip)
1101 n_skip -= file_stats.st_size;
1104 if (fseeko (in_stream, n_skip, SEEK_CUR) != 0)
1106 error (0, errno, "%s", input_filename);
1113 /* If it's not a regular file with nonnegative size,
1114 position the file pointer by reading. */
1119 size_t n_bytes_read, n_bytes_to_read = BUFSIZ;
1123 if (n_skip < n_bytes_to_read)
1124 n_bytes_to_read = n_skip;
1125 n_bytes_read = fread (buf, 1, n_bytes_to_read, in_stream);
1126 n_skip -= n_bytes_read;
1127 if (n_bytes_read != n_bytes_to_read)
1136 else /* cannot fstat() file */
1138 error (0, errno, "%s", input_filename);
1142 err |= check_and_close ();
1144 err |= open_next_file ();
1148 error (EXIT_FAILURE, 0, _("cannot skip past end of combined input"));
1154 format_address_none (uintmax_t address ATTRIBUTE_UNUSED, char c ATTRIBUTE_UNUSED)
1159 format_address_std (uintmax_t address, char c)
1161 char buf[MAX_ADDRESS_LENGTH + 2];
1162 char *p = buf + sizeof buf;
1167 pbound = p - address_pad_len;
1169 /* Use a special case of the code for each base. This is measurably
1170 faster than generic code. */
1171 switch (address_base)
1175 *--p = '0' + (address & 7);
1176 while ((address >>= 3) != 0);
1181 *--p = '0' + (address % 10);
1182 while ((address /= 10) != 0);
1187 *--p = "0123456789abcdef"[address & 15];
1188 while ((address >>= 4) != 0);
1199 format_address_paren (uintmax_t address, char c)
1202 format_address_std (address, ')');
1207 format_address_label (uintmax_t address, char c)
1209 format_address_std (address, ' ');
1210 format_address_paren (address + pseudo_offset, c);
1213 /* Write N_BYTES bytes from CURR_BLOCK to standard output once for each
1214 of the N_SPEC format specs. CURRENT_OFFSET is the byte address of
1215 CURR_BLOCK in the concatenation of input files, and it is printed
1216 (optionally) only before the output line associated with the first
1217 format spec. When duplicate blocks are being abbreviated, the output
1218 for a sequence of identical input blocks is the output for the first
1219 block followed by an asterisk alone on a line. It is valid to compare
1220 the blocks PREV_BLOCK and CURR_BLOCK only when N_BYTES == BYTES_PER_BLOCK.
1221 That condition may be false only for the last input block -- and then
1222 only when it has not been padded to length BYTES_PER_BLOCK. */
1225 write_block (uintmax_t current_offset, size_t n_bytes,
1226 const char *prev_block, const char *curr_block)
1228 static int first = 1;
1229 static int prev_pair_equal = 0;
1231 #define EQUAL_BLOCKS(b1, b2) (memcmp ((b1), (b2), bytes_per_block) == 0)
1233 if (abbreviate_duplicate_blocks
1234 && !first && n_bytes == bytes_per_block
1235 && EQUAL_BLOCKS (prev_block, curr_block))
1237 if (prev_pair_equal)
1239 /* The two preceding blocks were equal, and the current
1240 block is the same as the last one, so print nothing. */
1245 prev_pair_equal = 1;
1252 prev_pair_equal = 0;
1253 for (i = 0; i < n_specs; i++)
1256 format_address (current_offset, '\0');
1258 printf ("%*s", address_pad_len, "");
1259 (*spec[i].print_function) (n_bytes, curr_block, spec[i].fmt_string);
1260 if (spec[i].hexl_mode_trailer)
1262 /* space-pad out to full line width, then dump the trailer */
1263 int datum_width = width_bytes[spec[i].size];
1264 int blank_fields = (bytes_per_block - n_bytes) / datum_width;
1265 int field_width = spec[i].field_width + 1;
1266 printf ("%*s", blank_fields * field_width, "");
1267 dump_hexl_mode_trailer (n_bytes, curr_block);
1275 /* Read a single byte into *C from the concatenation of the input files
1276 named in the global array FILE_LIST. On the first call to this
1277 function, the global variable IN_STREAM is expected to be an open
1278 stream associated with the input file INPUT_FILENAME. If IN_STREAM
1279 is at end-of-file, close it and update the global variables IN_STREAM
1280 and INPUT_FILENAME so they correspond to the next file in the list.
1281 Then try to read a byte from the newly opened file. Repeat if
1282 necessary until EOF is reached for the last file in FILE_LIST, then
1283 set *C to EOF and return. Subsequent calls do likewise. The return
1284 value is nonzero if any errors occured, zero otherwise. */
1293 while (in_stream != NULL) /* EOF. */
1295 *c = fgetc (in_stream);
1300 err |= check_and_close ();
1302 err |= open_next_file ();
1308 /* Read N bytes into BLOCK from the concatenation of the input files
1309 named in the global array FILE_LIST. On the first call to this
1310 function, the global variable IN_STREAM is expected to be an open
1311 stream associated with the input file INPUT_FILENAME. If all N
1312 bytes cannot be read from IN_STREAM, close IN_STREAM and update
1313 the global variables IN_STREAM and INPUT_FILENAME. Then try to
1314 read the remaining bytes from the newly opened file. Repeat if
1315 necessary until EOF is reached for the last file in FILE_LIST.
1316 On subsequent calls, don't modify BLOCK and return zero. Set
1317 *N_BYTES_IN_BUFFER to the number of bytes read. If an error occurs,
1318 it will be detected through ferror when the stream is about to be
1319 closed. If there is an error, give a message but continue reading
1320 as usual and return nonzero. Otherwise return zero. */
1323 read_block (size_t n, char *block, size_t *n_bytes_in_buffer)
1327 assert (0 < n && n <= bytes_per_block);
1329 *n_bytes_in_buffer = 0;
1334 while (in_stream != NULL) /* EOF. */
1339 n_needed = n - *n_bytes_in_buffer;
1340 n_read = fread (block + *n_bytes_in_buffer, 1, n_needed, in_stream);
1342 *n_bytes_in_buffer += n_read;
1344 if (n_read == n_needed)
1347 err |= check_and_close ();
1349 err |= open_next_file ();
1355 /* Return the least common multiple of the sizes associated
1356 with the format specs. */
1364 for (i = 0; i < n_specs; i++)
1365 l_c_m = lcm (l_c_m, width_bytes[(int) spec[i].size]);
1369 /* If S is a valid traditional offset specification with an optional
1370 leading '+' return nonzero and set *OFFSET to the offset it denotes. */
1373 parse_old_offset (const char *s, uintmax_t *offset)
1376 enum strtol_error s_err;
1381 /* Skip over any leading '+'. */
1385 /* Determine the radix we'll use to interpret S. If there is a `.',
1386 it's decimal, otherwise, if the string begins with `0X'or `0x',
1387 it's hexadecimal, else octal. */
1388 if (strchr (s, '.') != NULL)
1392 if (s[0] == '0' && (s[1] == 'x' || s[1] == 'X'))
1398 s_err = xstrtoumax (s, NULL, radix, offset, "Bb");
1399 if (s_err != LONGINT_OK)
1401 STRTOL_FAIL_WARN (s, _("old-style offset"), s_err);
1407 /* Read a chunk of size BYTES_PER_BLOCK from the input files, write the
1408 formatted block to standard output, and repeat until the specified
1409 maximum number of bytes has been read or until all input has been
1410 processed. If the last block read is smaller than BYTES_PER_BLOCK
1411 and its size is not a multiple of the size associated with a format
1412 spec, extend the input block with zero bytes until its length is a
1413 multiple of all format spec sizes. Write the final block. Finally,
1414 write on a line by itself the offset of the byte after the last byte
1415 read. Accumulate return values from calls to read_block and
1416 check_and_close, and if any was nonzero, return nonzero.
1417 Otherwise, return zero. */
1423 uintmax_t current_offset;
1426 size_t n_bytes_read;
1428 block[0] = (char *) alloca (bytes_per_block);
1429 block[1] = (char *) alloca (bytes_per_block);
1431 current_offset = n_bytes_to_skip;
1435 if (limit_bytes_to_format)
1440 if (current_offset >= end_offset)
1445 n_needed = MIN (end_offset - current_offset,
1446 (uintmax_t) bytes_per_block);
1447 err |= read_block (n_needed, block[idx], &n_bytes_read);
1448 if (n_bytes_read < bytes_per_block)
1450 assert (n_bytes_read == bytes_per_block);
1451 write_block (current_offset, n_bytes_read,
1452 block[!idx], block[idx]);
1453 current_offset += n_bytes_read;
1461 err |= read_block (bytes_per_block, block[idx], &n_bytes_read);
1462 if (n_bytes_read < bytes_per_block)
1464 assert (n_bytes_read == bytes_per_block);
1465 write_block (current_offset, n_bytes_read,
1466 block[!idx], block[idx]);
1467 current_offset += n_bytes_read;
1472 if (n_bytes_read > 0)
1475 size_t bytes_to_write;
1479 /* Make bytes_to_write the smallest multiple of l_c_m that
1480 is at least as large as n_bytes_read. */
1481 bytes_to_write = l_c_m * ((n_bytes_read + l_c_m - 1) / l_c_m);
1483 memset (block[idx] + n_bytes_read, 0, bytes_to_write - n_bytes_read);
1484 write_block (current_offset, bytes_to_write,
1485 block[!idx], block[idx]);
1486 current_offset += n_bytes_read;
1489 format_address (current_offset, '\n');
1491 if (limit_bytes_to_format && current_offset >= end_offset)
1492 err |= check_and_close ();
1497 /* STRINGS mode. Find each "string constant" in the input.
1498 A string constant is a run of at least `string_min' ASCII
1499 graphic (or formatting) characters terminated by a null.
1500 Based on a function written by Richard Stallman for a
1501 traditional version of od. Return nonzero if an error
1502 occurs. Otherwise, return zero. */
1507 size_t bufsize = MAX (100, string_min);
1508 char *buf = xmalloc (bufsize);
1509 uintmax_t address = n_bytes_to_skip;
1518 /* See if the next `string_min' chars are all printing chars. */
1521 if (limit_bytes_to_format
1522 && (end_offset < string_min || end_offset - string_min <= address))
1525 for (i = 0; i < string_min; i++)
1527 err |= read_char (&c);
1535 /* Found a non-printing. Try again starting with next char. */
1540 /* We found a run of `string_min' printable characters.
1541 Now see if it is terminated with a null byte. */
1542 while (!limit_bytes_to_format || address < end_offset)
1546 bufsize = 1 + 3 * bufsize / 2;
1547 buf = xrealloc (buf, bufsize);
1549 err |= read_char (&c);
1557 break; /* It is; print this string. */
1559 goto tryline; /* It isn't; give up on this string. */
1560 buf[i++] = c; /* String continues; store it all. */
1563 /* If we get here, the string is all printable and null-terminated,
1564 so print it. It is all in `buf' and `i' is its length. */
1566 format_address (address - i - 1, ' ');
1568 for (i = 0; (c = buf[i]); i++)
1573 fputs ("\\a", stdout);
1577 fputs ("\\b", stdout);
1581 fputs ("\\f", stdout);
1585 fputs ("\\n", stdout);
1589 fputs ("\\r", stdout);
1593 fputs ("\\t", stdout);
1597 fputs ("\\v", stdout);
1607 /* We reach this point only if we search through
1608 (max_bytes_to_format - string_min) bytes before reaching EOF. */
1612 err |= check_and_close ();
1617 main (int argc, char **argv)
1623 size_t desired_width IF_LINT (= 0);
1624 int width_specified = 0;
1625 int n_failed_decodes = 0;
1627 char const *short_options = (posix2_version () < 200112
1628 ? COMMON_SHORT_OPTIONS "s::w::"
1629 : COMMON_SHORT_OPTIONS "s:w:");
1631 /* The old-style `pseudo starting address' to be printed in parentheses
1632 after any true address. */
1633 uintmax_t pseudo_start IF_LINT (= 0);
1635 program_name = argv[0];
1636 setlocale (LC_ALL, "");
1637 bindtextdomain (PACKAGE, LOCALEDIR);
1638 textdomain (PACKAGE);
1640 atexit (close_stdout);
1644 for (i = 0; i <= MAX_INTEGRAL_TYPE_SIZE; i++)
1645 integral_type_size[i] = NO_SIZE;
1647 integral_type_size[sizeof (char)] = CHAR;
1648 integral_type_size[sizeof (short int)] = SHORT;
1649 integral_type_size[sizeof (int)] = INT;
1650 integral_type_size[sizeof (long int)] = LONG;
1651 #if HAVE_UNSIGNED_LONG_LONG
1652 /* If `long' and `long long' have the same size, it's fine
1653 to overwrite the entry for `long' with this one. */
1654 integral_type_size[sizeof (ulonglong_t)] = LONG_LONG;
1657 for (i = 0; i <= MAX_FP_TYPE_SIZE; i++)
1658 fp_type_size[i] = NO_SIZE;
1660 fp_type_size[sizeof (float)] = FLOAT_SINGLE;
1661 /* The array entry for `double' is filled in after that for LONG_DOUBLE
1662 so that if `long double' is the same type or if long double isn't
1663 supported FLOAT_LONG_DOUBLE will never be used. */
1664 fp_type_size[sizeof (LONG_DOUBLE)] = FLOAT_LONG_DOUBLE;
1665 fp_type_size[sizeof (double)] = FLOAT_DOUBLE;
1668 n_specs_allocated = 5;
1669 spec = (struct tspec *) xmalloc (n_specs_allocated * sizeof (struct tspec));
1671 format_address = format_address_std;
1673 address_pad_len = 7;
1674 flag_dump_strings = 0;
1676 while ((c = getopt_long (argc, argv, short_options, long_options, NULL))
1680 enum strtol_error s_err;
1691 format_address = format_address_std;
1693 address_pad_len = 7;
1696 format_address = format_address_std;
1698 address_pad_len = 7;
1701 format_address = format_address_std;
1703 address_pad_len = 6;
1706 format_address = format_address_none;
1707 address_pad_len = 0;
1710 error (EXIT_FAILURE, 0,
1711 _("invalid output address radix `%c'; \
1712 it must be one character from [doxn]"),
1719 s_err = xstrtoumax (optarg, NULL, 0, &n_bytes_to_skip, "bkm");
1720 if (s_err != LONGINT_OK)
1721 STRTOL_FATAL_ERROR (optarg, _("skip argument"), s_err);
1725 limit_bytes_to_format = 1;
1727 s_err = xstrtoumax (optarg, NULL, 0, &max_bytes_to_format, "bkm");
1728 if (s_err != LONGINT_OK)
1729 STRTOL_FATAL_ERROR (optarg, _("limit argument"), s_err);
1737 s_err = xstrtoumax (optarg, NULL, 0, &tmp, "bkm");
1738 if (s_err != LONGINT_OK)
1739 STRTOL_FATAL_ERROR (optarg, _("minimum string length"), s_err);
1741 /* The minimum string length may be no larger than SIZE_MAX,
1742 since we may allocate a buffer of this size. */
1744 error (EXIT_FAILURE, 0, _("%s is too large"), optarg);
1748 flag_dump_strings = 1;
1752 if (decode_format_string (optarg))
1757 abbreviate_duplicate_blocks = 0;
1760 case TRADITIONAL_OPTION:
1764 /* The next several cases map the traditional format
1765 specification options to the corresponding modern format
1766 specs. GNU od accepts any combination of old- and
1767 new-style options. Format specification options accumulate. */
1769 #define CASE_OLD_ARG(old_char,new_string) \
1772 if (decode_format_string (new_string)) \
1773 ++n_failed_decodes; \
1777 CASE_OLD_ARG ('a', "a");
1778 CASE_OLD_ARG ('b', "oC");
1779 CASE_OLD_ARG ('c', "c");
1780 CASE_OLD_ARG ('d', "u2");
1781 CASE_OLD_ARG ('f', "fF");
1782 CASE_OLD_ARG ('h', "x2");
1783 CASE_OLD_ARG ('i', "d2");
1784 CASE_OLD_ARG ('l', "d4");
1785 CASE_OLD_ARG ('o', "o2");
1786 CASE_OLD_ARG ('x', "x2");
1788 /* FIXME: POSIX 1003.1-2001 with XSI requires this:
1790 CASE_OLD_ARG ('s', "d2");
1792 for the traditional syntax, but this conflicts with case
1798 width_specified = 1;
1806 s_err = xstrtoumax (optarg, NULL, 10, &w_tmp, "");
1807 if (s_err != LONGINT_OK)
1808 STRTOL_FATAL_ERROR (optarg, _("width specification"), s_err);
1809 if (SIZE_MAX < w_tmp)
1810 error (EXIT_FAILURE, 0, _("%s is too large"), optarg);
1811 desired_width = w_tmp;
1815 case_GETOPT_HELP_CHAR;
1817 case_GETOPT_VERSION_CHAR (PROGRAM_NAME, AUTHORS);
1820 usage (EXIT_FAILURE);
1825 if (n_failed_decodes > 0)
1826 exit (EXIT_FAILURE);
1828 if (flag_dump_strings && n_specs > 0)
1829 error (EXIT_FAILURE, 0,
1830 _("no type may be specified when dumping strings"));
1832 n_files = argc - optind;
1834 /* If the --traditional option is used, there may be from
1835 0 to 3 remaining command line arguments; handle each case
1837 od [file] [[+]offset[.][b] [[+]label[.][b]]]
1838 The offset and pseudo_start have the same syntax.
1840 FIXME: POSIX 1003.1-2001 with XSI requires support for the
1841 traditional syntax even if --traditional is not given. */
1849 if (parse_old_offset (argv[optind], &offset))
1851 n_bytes_to_skip = offset;
1856 else if (n_files == 2)
1859 if (parse_old_offset (argv[optind], &o1)
1860 && parse_old_offset (argv[optind + 1], &o2))
1862 n_bytes_to_skip = o1;
1863 flag_pseudo_start = 1;
1868 else if (parse_old_offset (argv[optind + 1], &o2))
1870 n_bytes_to_skip = o2;
1872 argv[optind + 1] = argv[optind];
1878 _("invalid second operand in compatibility mode `%s'"),
1880 usage (EXIT_FAILURE);
1883 else if (n_files == 3)
1886 if (parse_old_offset (argv[optind + 1], &o1)
1887 && parse_old_offset (argv[optind + 2], &o2))
1889 n_bytes_to_skip = o1;
1890 flag_pseudo_start = 1;
1892 argv[optind + 2] = argv[optind];
1899 _("in compatibility mode, the last two arguments must be offsets"));
1900 usage (EXIT_FAILURE);
1903 else if (n_files > 3)
1906 _("compatibility mode supports at most three arguments"));
1907 usage (EXIT_FAILURE);
1910 if (flag_pseudo_start)
1912 if (format_address == format_address_none)
1915 address_pad_len = 7;
1916 format_address = format_address_paren;
1919 format_address = format_address_label;
1923 if (limit_bytes_to_format)
1925 end_offset = n_bytes_to_skip + max_bytes_to_format;
1926 if (end_offset < n_bytes_to_skip)
1927 error (EXIT_FAILURE, 0, "skip-bytes + read-bytes is too large");
1932 if (decode_one_format ("o2", "o2", NULL, &(spec[0])))
1934 /* This happens on Cray systems that don't have a 2-byte
1936 exit (EXIT_FAILURE);
1944 /* Set the global pointer FILE_LIST so that it
1945 references the first file-argument on the command-line. */
1947 file_list = (char const *const *) &argv[optind];
1951 /* No files were listed on the command line.
1952 Set the global pointer FILE_LIST so that it
1953 references the null-terminated list of one name: "-". */
1955 file_list = default_file_list;
1958 /* open the first input file */
1959 err |= open_next_file ();
1960 if (in_stream == NULL)
1963 /* skip over any unwanted header bytes */
1964 err |= skip (n_bytes_to_skip);
1965 if (in_stream == NULL)
1968 pseudo_offset = (flag_pseudo_start ? pseudo_start - n_bytes_to_skip : 0);
1970 /* Compute output block length. */
1973 if (width_specified)
1975 if (desired_width != 0 && desired_width % l_c_m == 0)
1976 bytes_per_block = desired_width;
1979 error (0, 0, _("warning: invalid width %lu; using %d instead"),
1980 (unsigned long) desired_width, l_c_m);
1981 bytes_per_block = l_c_m;
1986 if (l_c_m < DEFAULT_BYTES_PER_BLOCK)
1987 bytes_per_block = l_c_m * (DEFAULT_BYTES_PER_BLOCK / l_c_m);
1989 bytes_per_block = l_c_m;
1993 for (i = 0; i < n_specs; i++)
1995 printf (_("%d: fmt=\"%s\" width=%d\n"),
1996 i, spec[i].fmt_string, width_bytes[spec[i].size]);
2000 err |= (flag_dump_strings ? dump_strings () : dump ());
2004 if (have_read_stdin && fclose (stdin) == EOF)
2005 error (EXIT_FAILURE, errno, _("standard input"));
2007 exit (err == 0 ? EXIT_SUCCESS : EXIT_FAILURE);