1 /* od -- dump files in octal and other formats
2 Copyright (C) 92, 1995-2005 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., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301, 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;
46 /* The default number of input bytes per output line. */
47 #define DEFAULT_BYTES_PER_BLOCK 16
49 /* The number of decimal digits of precision in a float. */
54 /* The number of decimal digits of precision in a double. */
59 /* The number of decimal digits of precision in a long double. */
61 # define LDBL_DIG DBL_DIG
64 #if HAVE_UNSIGNED_LONG_LONG
65 typedef unsigned long long int ulonglong_t;
67 /* This is just a place-holder to avoid a few `#if' directives.
68 In this case, the type isn't actually used. */
69 typedef unsigned long int ulonglong_t;
80 /* FIXME: add INTMAX support, too */
98 /* The maximum number of bytes needed for a format string,
99 including the trailing null. */
102 FMT_BYTES_ALLOCATED =
103 MAX ((sizeof " %0" - 1 + INT_STRLEN_BOUND (int)
109 sizeof " %.Le" + 2 * INT_STRLEN_BOUND (int))
112 /* Each output format specification (from `-t spec' or from
113 old-style options) is represented by one of these structures. */
116 enum output_format fmt;
118 void (*print_function) (size_t, void const *, char const *);
119 char fmt_string[FMT_BYTES_ALLOCATED];
120 bool hexl_mode_trailer;
124 /* The name this program was run with. */
127 /* Convert the number of 8-bit bytes of a binary representation to
128 the number of characters (digits + sign if the type is signed)
129 required to represent the same quantity in the specified base/type.
130 For example, a 32-bit (4-byte) quantity may require a field width
131 as wide as the following for these types:
135 8 unsigned hexadecimal */
137 static char const bytes_to_oct_digits[] =
138 {0, 3, 6, 8, 11, 14, 16, 19, 22, 25, 27, 30, 32, 35, 38, 41, 43};
140 static char const bytes_to_signed_dec_digits[] =
141 {1, 4, 6, 8, 11, 13, 16, 18, 20, 23, 25, 28, 30, 33, 35, 37, 40};
143 static char const bytes_to_unsigned_dec_digits[] =
144 {0, 3, 5, 8, 10, 13, 15, 17, 20, 22, 25, 27, 29, 32, 34, 37, 39};
146 static char const bytes_to_hex_digits[] =
147 {0, 2, 4, 6, 8, 10, 12, 14, 16, 18, 20, 22, 24, 26, 28, 30, 32};
149 /* Convert enum size_spec to the size of the named type. */
150 static const int width_bytes[] =
157 sizeof (ulonglong_t),
163 /* Ensure that for each member of `enum size_spec' there is an
164 initializer in the width_bytes array. */
165 VERIFY (assert_width_bytes_matches_size_spec_decl,
166 sizeof width_bytes / sizeof width_bytes[0] == N_SIZE_SPECS);
168 /* Names for some non-printing characters. */
169 static const char *const charname[33] =
171 "nul", "soh", "stx", "etx", "eot", "enq", "ack", "bel",
172 "bs", "ht", "nl", "vt", "ff", "cr", "so", "si",
173 "dle", "dc1", "dc2", "dc3", "dc4", "nak", "syn", "etb",
174 "can", "em", "sub", "esc", "fs", "gs", "rs", "us",
178 /* Address base (8, 10 or 16). */
179 static int address_base;
181 /* The number of octal digits required to represent the largest
183 #define MAX_ADDRESS_LENGTH \
184 ((sizeof (uintmax_t) * CHAR_BIT + CHAR_BIT - 1) / 3)
186 /* Width of a normal address. */
187 static int address_pad_len;
189 static size_t string_min;
190 static bool flag_dump_strings;
192 /* True if we should recognize the older non-option arguments
193 that specified at most one file and optional arguments specifying
194 offset and pseudo-start address. */
195 static bool traditional;
197 /* True if an old-style `pseudo-address' was specified. */
198 static bool flag_pseudo_start;
200 /* The difference between the old-style pseudo starting address and
201 the number of bytes to skip. */
202 static uintmax_t pseudo_offset;
204 /* Function that accepts an address and an optional following char,
205 and prints the address and char to stdout. */
206 static void (*format_address) (uintmax_t, char);
208 /* The number of input bytes to skip before formatting and writing. */
209 static uintmax_t n_bytes_to_skip = 0;
211 /* When false, MAX_BYTES_TO_FORMAT and END_OFFSET are ignored, and all
212 input is formatted. */
213 static bool limit_bytes_to_format = false;
215 /* The maximum number of bytes that will be formatted. */
216 static uintmax_t max_bytes_to_format;
218 /* The offset of the first byte after the last byte to be formatted. */
219 static uintmax_t end_offset;
221 /* When true and two or more consecutive blocks are equal, format
222 only the first block and output an asterisk alone on the following
223 line to indicate that identical blocks have been elided. */
224 static bool abbreviate_duplicate_blocks = true;
226 /* An array of specs describing how to format each input block. */
227 static struct tspec *spec;
229 /* The number of format specs. */
230 static size_t n_specs;
232 /* The allocated length of SPEC. */
233 static size_t n_specs_allocated;
235 /* The number of input bytes formatted per output line. It must be
236 a multiple of the least common multiple of the sizes associated with
237 the specified output types. It should be as large as possible, but
238 no larger than 16 -- unless specified with the -w option. */
239 static size_t bytes_per_block;
241 /* Human-readable representation of *file_list (for error messages).
242 It differs from file_list[-1] only when file_list[-1] is "-". */
243 static char const *input_filename;
245 /* A NULL-terminated list of the file-arguments from the command line. */
246 static char const *const *file_list;
248 /* Initializer for file_list if no file-arguments
249 were specified on the command line. */
250 static char const *const default_file_list[] = {"-", NULL};
252 /* The input stream associated with the current file. */
253 static FILE *in_stream;
255 /* If true, at least one of the files we read was standard input. */
256 static bool have_read_stdin;
258 #define MAX_INTEGRAL_TYPE_SIZE sizeof (ulonglong_t)
259 static enum size_spec integral_type_size[MAX_INTEGRAL_TYPE_SIZE + 1];
261 #define MAX_FP_TYPE_SIZE sizeof (LONG_DOUBLE)
262 static enum size_spec fp_type_size[MAX_FP_TYPE_SIZE + 1];
264 static char const short_options[] = "A:aBbcDdeFfHhIij:LlN:OoS:st:vw::Xx";
266 /* For long options that have no equivalent short option, use a
267 non-character as a pseudo short option, starting with CHAR_MAX + 1. */
270 TRADITIONAL_OPTION = CHAR_MAX + 1
273 static struct option const long_options[] =
275 {"skip-bytes", required_argument, NULL, 'j'},
276 {"address-radix", required_argument, NULL, 'A'},
277 {"read-bytes", required_argument, NULL, 'N'},
278 {"format", required_argument, NULL, 't'},
279 {"output-duplicates", no_argument, NULL, 'v'},
280 {"strings", optional_argument, NULL, 'S'},
281 {"traditional", no_argument, NULL, TRADITIONAL_OPTION},
282 {"width", optional_argument, NULL, 'w'},
284 {GETOPT_HELP_OPTION_DECL},
285 {GETOPT_VERSION_OPTION_DECL},
292 if (status != EXIT_SUCCESS)
293 fprintf (stderr, _("Try `%s --help' for more information.\n"),
298 Usage: %s [OPTION]... [FILE]...\n\
299 or: %s [-abcdfilosx]... [FILE] [[+]OFFSET[.][b]]\n\
300 or: %s --traditional [OPTION]... [FILE] [[+]OFFSET[.][b] [+][LABEL][.][b]]\n\
302 program_name, program_name, program_name);
304 Write an unambiguous representation, octal bytes by default,\n\
305 of FILE to standard output. With more than one FILE argument,\n\
306 concatenate them in the listed order to form the input.\n\
307 With no FILE, or when FILE is -, read standard input.\n\
311 All arguments to long options are mandatory for short options.\n\
314 -A, --address-radix=RADIX decide how file offsets are printed\n\
315 -j, --skip-bytes=BYTES skip BYTES input bytes first\n\
318 -N, --read-bytes=BYTES limit dump to BYTES input bytes\n\
319 -S, --strings[=BYTES] output strings of at least BYTES graphic chars\n\
320 -t, --format=TYPE select output format or formats\n\
321 -v, --output-duplicates do not use * to mark line suppression\n\
322 -w, --width[=BYTES] output BYTES bytes per output line\n\
323 --traditional accept arguments in traditional form\n\
325 fputs (HELP_OPTION_DESCRIPTION, stdout);
326 fputs (VERSION_OPTION_DESCRIPTION, stdout);
329 Traditional format specifications may be intermixed; they accumulate:\n\
330 -a same as -t a, select named characters\n\
331 -b same as -t o1, select octal bytes\n\
332 -c same as -t c, select ASCII characters or backslash escapes\n\
333 -d same as -t u2, select unsigned decimal 2-byte units\n\
336 -f same as -t fF, select floats\n\
337 -i same as -t dI, select decimal ints\n\
338 -l same as -t dL, select decimal longs\n\
339 -o same as -t o2, select octal 2-byte units\n\
340 -s same as -t d2, select decimal 2-byte units\n\
341 -x same as -t x2, select hexadecimal 2-byte units\n\
345 If first and second call formats both apply, the second format is assumed\n\
346 if the last operand begins with + or (if there are 2 operands) a digit.\n\
347 An OFFSET operand means -j OFFSET. LABEL is the pseudo-address\n\
348 at first byte printed, incremented when dump is progressing.\n\
349 For OFFSET and LABEL, a 0x or 0X prefix indicates hexadecimal;\n\
350 suffixes may be . for octal and b for multiply by 512.\n\
352 TYPE is made up of one or more of these specifications:\n\
355 c ASCII character or backslash escape\n\
358 d[SIZE] signed decimal, SIZE bytes per integer\n\
359 f[SIZE] floating point, SIZE bytes per integer\n\
360 o[SIZE] octal, SIZE bytes per integer\n\
361 u[SIZE] unsigned decimal, SIZE bytes per integer\n\
362 x[SIZE] hexadecimal, SIZE bytes per integer\n\
366 SIZE is a number. For TYPE in doux, SIZE may also be C for\n\
367 sizeof(char), S for sizeof(short), I for sizeof(int) or L for\n\
368 sizeof(long). If TYPE is f, SIZE may also be F for sizeof(float), D\n\
369 for sizeof(double) or L for sizeof(long double).\n\
373 RADIX is d for decimal, o for octal, x for hexadecimal or n for none.\n\
374 BYTES is hexadecimal with 0x or 0X prefix, it is multiplied by 512\n\
375 with b suffix, by 1024 with k and by 1048576 with m. Adding a z suffix to\n\
376 any type adds a display of printable characters to the end of each line\n\
380 --string without a number implies 3. --width without a number\n\
381 implies 32. By default, od uses -A o -t d2 -w 16.\n\
383 printf (_("\nReport bugs to <%s>.\n"), PACKAGE_BUGREPORT);
388 /* Define the print functions. */
391 print_s_char (size_t n_bytes, void const *block, char const *fmt_string)
393 signed char const *p = block;
395 for (i = n_bytes / sizeof *p; i != 0; i--)
396 printf (fmt_string, *p++);
400 print_char (size_t n_bytes, void const *block, char const *fmt_string)
402 unsigned char const *p = block;
404 for (i = n_bytes / sizeof *p; i != 0; i--)
405 printf (fmt_string, *p++);
409 print_s_short (size_t n_bytes, void const *block, char const *fmt_string)
411 short int const *p = block;
413 for (i = n_bytes / sizeof *p; i != 0; i--)
414 printf (fmt_string, *p++);
418 print_short (size_t n_bytes, void const *block, char const *fmt_string)
420 unsigned short int const *p = block;
422 for (i = n_bytes / sizeof *p; i != 0; i--)
423 printf (fmt_string, *p++);
427 print_int (size_t n_bytes, void const *block, char const *fmt_string)
429 unsigned int const *p = block;
431 for (i = n_bytes / sizeof *p; i != 0; i--)
432 printf (fmt_string, *p++);
436 print_long (size_t n_bytes, void const *block, char const *fmt_string)
438 unsigned long int const *p = block;
440 for (i = n_bytes / sizeof *p; i != 0; i--)
441 printf (fmt_string, *p++);
445 print_long_long (size_t n_bytes, void const *block, char const *fmt_string)
447 ulonglong_t const *p = block;
449 for (i = n_bytes / sizeof *p; i != 0; i--)
450 printf (fmt_string, *p++);
454 print_float (size_t n_bytes, void const *block, char const *fmt_string)
456 float const *p = block;
458 for (i = n_bytes / sizeof *p; i != 0; i--)
459 printf (fmt_string, *p++);
463 print_double (size_t n_bytes, void const *block, char const *fmt_string)
465 double const *p = block;
467 for (i = n_bytes / sizeof *p; i != 0; i--)
468 printf (fmt_string, *p++);
471 #ifdef HAVE_LONG_DOUBLE
473 print_long_double (size_t n_bytes, void const *block, char const *fmt_string)
475 long double const *p = block;
477 for (i = n_bytes / sizeof *p; i != 0; i--)
478 printf (fmt_string, *p++);
483 dump_hexl_mode_trailer (size_t n_bytes, const char *block)
486 fputs (" >", stdout);
487 for (i = n_bytes; i > 0; i--)
489 unsigned char c = *block++;
490 unsigned char c2 = (ISPRINT(c) ? c : '.');
497 print_named_ascii (size_t n_bytes, void const *block,
498 const char *unused_fmt_string ATTRIBUTE_UNUSED)
500 unsigned char const *p = block;
502 for (i = n_bytes; i > 0; i--)
504 int masked_c = *p++ & 0x7f;
510 else if (masked_c <= 040)
511 s = charname[masked_c];
514 sprintf (buf, " %c", masked_c);
523 print_ascii (size_t n_bytes, void const *block,
524 const char *unused_fmt_string ATTRIBUTE_UNUSED)
526 unsigned char const *p = block;
528 for (i = n_bytes; i > 0; i--)
530 unsigned char c = *p++;
569 sprintf (buf, (ISPRINT (c) ? " %c" : "%03o"), c);
577 /* Convert a null-terminated (possibly zero-length) string S to an
578 unsigned long integer value. If S points to a non-digit set *P to S,
579 *VAL to 0, and return true. Otherwise, accumulate the integer value of
580 the string of digits. If the string of digits represents a value
581 larger than ULONG_MAX, don't modify *VAL or *P and return false.
582 Otherwise, advance *P to the first non-digit after S, set *VAL to
583 the result of the conversion and return true. */
586 simple_strtoul (const char *s, const char **p, unsigned long int *val)
588 unsigned long int sum;
594 if (sum > (ULONG_MAX - c) / 10)
603 /* If S points to a single valid modern od format string, put
604 a description of that format in *TSPEC, make *NEXT point at the
605 character following the just-decoded format (if *NEXT is non-NULL),
606 and return true. If S is not valid, don't modify *NEXT or *TSPEC,
607 give a diagnostic, and return false. For example, if S were
608 "d4afL" *NEXT would be set to "afL" and *TSPEC would be
610 fmt = SIGNED_DECIMAL;
611 size = INT or LONG; (whichever integral_type_size[4] resolves to)
612 print_function = print_int; (assuming size == INT)
613 fmt_string = "%011d%c";
615 S_ORIG is solely for reporting errors. It should be the full format
620 decode_one_format (const char *s_orig, const char *s, const char **next,
623 enum size_spec size_spec;
624 unsigned long int size;
625 enum output_format fmt;
626 const char *pre_fmt_string;
627 void (*print_function) (size_t, void const *, char const *);
633 assert (tspec != NULL);
647 size = sizeof (char);
652 size = sizeof (short int);
662 size = sizeof (long int);
666 if (! simple_strtoul (s, &p, &size))
668 /* The integer at P in S would overflow an unsigned long int.
669 A digit string that long is sufficiently odd looking
670 that the following diagnostic is sufficient. */
671 error (0, 0, _("invalid type string `%s'"), s_orig);
678 if (MAX_INTEGRAL_TYPE_SIZE < size
679 || integral_type_size[size] == NO_SIZE)
681 error (0, 0, _("invalid type string `%s';\n\
682 this system doesn't provide a %lu-byte integral type"), s_orig, size);
690 #define ISPEC_TO_FORMAT(Spec, Min_format, Long_format, Max_format) \
691 ((Spec) == LONG_LONG ? (Max_format) \
692 : ((Spec) == LONG ? (Long_format) \
695 size_spec = integral_type_size[size];
700 fmt = SIGNED_DECIMAL;
701 sprintf (tspec->fmt_string, " %%%d%s",
702 (field_width = bytes_to_signed_dec_digits[size]),
703 ISPEC_TO_FORMAT (size_spec, "d", "ld", PRIdMAX));
708 sprintf (tspec->fmt_string, " %%0%d%s",
709 (field_width = bytes_to_oct_digits[size]),
710 ISPEC_TO_FORMAT (size_spec, "o", "lo", PRIoMAX));
714 fmt = UNSIGNED_DECIMAL;
715 sprintf (tspec->fmt_string, " %%%d%s",
716 (field_width = bytes_to_unsigned_dec_digits[size]),
717 ISPEC_TO_FORMAT (size_spec, "u", "lu", PRIuMAX));
722 sprintf (tspec->fmt_string, " %%0%d%s",
723 (field_width = bytes_to_hex_digits[size]),
724 ISPEC_TO_FORMAT (size_spec, "x", "lx", PRIxMAX));
731 assert (strlen (tspec->fmt_string) < FMT_BYTES_ALLOCATED);
736 print_function = (fmt == SIGNED_DECIMAL
742 print_function = (fmt == SIGNED_DECIMAL
748 print_function = print_int;
752 print_function = print_long;
756 print_function = print_long_long;
765 fmt = FLOATING_POINT;
771 size = sizeof (float);
776 size = sizeof (double);
781 size = sizeof (LONG_DOUBLE);
785 if (! simple_strtoul (s, &p, &size))
787 /* The integer at P in S would overflow an unsigned long int.
788 A digit string that long is sufficiently odd looking
789 that the following diagnostic is sufficient. */
790 error (0, 0, _("invalid type string `%s'"), s_orig);
794 size = sizeof (double);
797 if (size > MAX_FP_TYPE_SIZE
798 || fp_type_size[size] == NO_SIZE)
800 error (0, 0, _("invalid type string `%s';\n\
801 this system doesn't provide a %lu-byte floating point type"), s_orig, size);
808 size_spec = fp_type_size[size];
813 print_function = print_float;
814 /* Don't use %#e; not all systems support it. */
815 pre_fmt_string = " %%%d.%de";
820 print_function = print_double;
821 pre_fmt_string = " %%%d.%de";
825 #ifdef HAVE_LONG_DOUBLE
826 case FLOAT_LONG_DOUBLE:
827 print_function = print_long_double;
828 pre_fmt_string = " %%%d.%dLe";
829 precision = LDBL_DIG;
837 field_width = precision + 8;
838 sprintf (tspec->fmt_string, pre_fmt_string, field_width, precision);
843 fmt = NAMED_CHARACTER;
845 print_function = print_named_ascii;
853 print_function = print_ascii;
858 error (0, 0, _("invalid character `%c' in type string `%s'"),
863 tspec->size = size_spec;
865 tspec->print_function = print_function;
867 tspec->field_width = field_width;
868 tspec->hexl_mode_trailer = (*s == 'z');
869 if (tspec->hexl_mode_trailer)
878 /* Given a list of one or more input filenames FILE_LIST, set the global
879 file pointer IN_STREAM and the global string INPUT_FILENAME to the
880 first one that can be successfully opened. Modify FILE_LIST to
881 reference the next filename in the list. A file name of "-" is
882 interpreted as standard input. If any file open fails, give an error
883 message and return false. */
886 open_next_file (void)
892 input_filename = *file_list;
893 if (input_filename == NULL)
897 if (STREQ (input_filename, "-"))
899 input_filename = _("standard input");
901 have_read_stdin = true;
905 in_stream = fopen (input_filename, "r");
906 if (in_stream == NULL)
908 error (0, errno, "%s", input_filename);
913 while (in_stream == NULL);
915 if (limit_bytes_to_format & !flag_dump_strings)
916 SETVBUF (in_stream, NULL, _IONBF, 0);
917 SET_BINARY (fileno (in_stream));
922 /* Test whether there have been errors on in_stream, and close it if
923 it is not standard input. Return false if there has been an error
924 on in_stream or stdout; return true otherwise. This function will
925 report more than one error only if both a read and a write error
926 have occurred. IN_ERRNO, if nonzero, is the error number
927 corresponding to the most recent action for IN_STREAM. */
930 check_and_close (int in_errno)
934 if (in_stream != NULL)
936 if (ferror (in_stream))
938 error (0, in_errno, _("%s: read error"), input_filename);
939 if (! STREQ (file_list[-1], "-"))
943 else if (! STREQ (file_list[-1], "-") && fclose (in_stream) != 0)
945 error (0, errno, "%s", input_filename);
954 error (0, 0, _("write error"));
961 /* Decode the modern od format string S. Append the decoded
962 representation to the global array SPEC, reallocating SPEC if
963 necessary. Return true if S is valid. */
966 decode_format_string (const char *s)
968 const char *s_orig = s;
975 if (n_specs_allocated <= n_specs)
976 spec = x2nrealloc (spec, &n_specs_allocated, sizeof *spec);
978 if (! decode_one_format (s_orig, s, &next, &spec[n_specs]))
989 /* Given a list of one or more input filenames FILE_LIST, set the global
990 file pointer IN_STREAM to position N_SKIP in the concatenation of
991 those files. If any file operation fails or if there are fewer than
992 N_SKIP bytes in the combined input, give an error message and return
993 false. When possible, use seek rather than read operations to
994 advance IN_STREAM. */
997 skip (uintmax_t n_skip)
1005 while (in_stream != NULL) /* EOF. */
1007 struct stat file_stats;
1009 /* First try seeking. For large offsets, this extra work is
1010 worthwhile. If the offset is below some threshold it may be
1011 more efficient to move the pointer by reading. There are two
1012 issues when trying to seek:
1013 - the file must be seekable.
1014 - before seeking to the specified position, make sure
1015 that the new position is in the current file.
1016 Try to do that by getting file's size using fstat.
1017 But that will work only for regular files. */
1019 if (fstat (fileno (in_stream), &file_stats) == 0)
1021 /* The st_size field is valid only for regular files
1022 (and for symbolic links, which cannot occur here).
1023 If the number of bytes left to skip is at least
1024 as large as the size of the current file, we can
1025 decrement n_skip and go on to the next file. */
1027 if (S_ISREG (file_stats.st_mode) && 0 <= file_stats.st_size)
1029 if ((uintmax_t) file_stats.st_size <= n_skip)
1030 n_skip -= file_stats.st_size;
1033 if (fseeko (in_stream, n_skip, SEEK_CUR) != 0)
1042 /* If it's not a regular file with nonnegative size,
1043 position the file pointer by reading. */
1048 size_t n_bytes_read, n_bytes_to_read = BUFSIZ;
1052 if (n_skip < n_bytes_to_read)
1053 n_bytes_to_read = n_skip;
1054 n_bytes_read = fread (buf, 1, n_bytes_to_read, in_stream);
1055 n_skip -= n_bytes_read;
1056 if (n_bytes_read != n_bytes_to_read)
1070 else /* cannot fstat() file */
1072 error (0, errno, "%s", input_filename);
1076 ok &= check_and_close (in_errno);
1078 ok &= open_next_file ();
1082 error (EXIT_FAILURE, 0, _("cannot skip past end of combined input"));
1088 format_address_none (uintmax_t address ATTRIBUTE_UNUSED, char c ATTRIBUTE_UNUSED)
1093 format_address_std (uintmax_t address, char c)
1095 char buf[MAX_ADDRESS_LENGTH + 2];
1096 char *p = buf + sizeof buf;
1101 pbound = p - address_pad_len;
1103 /* Use a special case of the code for each base. This is measurably
1104 faster than generic code. */
1105 switch (address_base)
1109 *--p = '0' + (address & 7);
1110 while ((address >>= 3) != 0);
1115 *--p = '0' + (address % 10);
1116 while ((address /= 10) != 0);
1121 *--p = "0123456789abcdef"[address & 15];
1122 while ((address >>= 4) != 0);
1133 format_address_paren (uintmax_t address, char c)
1136 format_address_std (address, ')');
1142 format_address_label (uintmax_t address, char c)
1144 format_address_std (address, ' ');
1145 format_address_paren (address + pseudo_offset, c);
1148 /* Write N_BYTES bytes from CURR_BLOCK to standard output once for each
1149 of the N_SPEC format specs. CURRENT_OFFSET is the byte address of
1150 CURR_BLOCK in the concatenation of input files, and it is printed
1151 (optionally) only before the output line associated with the first
1152 format spec. When duplicate blocks are being abbreviated, the output
1153 for a sequence of identical input blocks is the output for the first
1154 block followed by an asterisk alone on a line. It is valid to compare
1155 the blocks PREV_BLOCK and CURR_BLOCK only when N_BYTES == BYTES_PER_BLOCK.
1156 That condition may be false only for the last input block -- and then
1157 only when it has not been padded to length BYTES_PER_BLOCK. */
1160 write_block (uintmax_t current_offset, size_t n_bytes,
1161 const char *prev_block, const char *curr_block)
1163 static bool first = true;
1164 static bool prev_pair_equal = false;
1166 #define EQUAL_BLOCKS(b1, b2) (memcmp ((b1), (b2), bytes_per_block) == 0)
1168 if (abbreviate_duplicate_blocks
1169 && !first && n_bytes == bytes_per_block
1170 && EQUAL_BLOCKS (prev_block, curr_block))
1172 if (prev_pair_equal)
1174 /* The two preceding blocks were equal, and the current
1175 block is the same as the last one, so print nothing. */
1180 prev_pair_equal = true;
1187 prev_pair_equal = false;
1188 for (i = 0; i < n_specs; i++)
1191 format_address (current_offset, '\0');
1193 printf ("%*s", address_pad_len, "");
1194 (*spec[i].print_function) (n_bytes, curr_block, spec[i].fmt_string);
1195 if (spec[i].hexl_mode_trailer)
1197 /* space-pad out to full line width, then dump the trailer */
1198 int datum_width = width_bytes[spec[i].size];
1199 int blank_fields = (bytes_per_block - n_bytes) / datum_width;
1200 int field_width = spec[i].field_width + 1;
1201 printf ("%*s", blank_fields * field_width, "");
1202 dump_hexl_mode_trailer (n_bytes, curr_block);
1210 /* Read a single byte into *C from the concatenation of the input files
1211 named in the global array FILE_LIST. On the first call to this
1212 function, the global variable IN_STREAM is expected to be an open
1213 stream associated with the input file INPUT_FILENAME. If IN_STREAM
1214 is at end-of-file, close it and update the global variables IN_STREAM
1215 and INPUT_FILENAME so they correspond to the next file in the list.
1216 Then try to read a byte from the newly opened file. Repeat if
1217 necessary until EOF is reached for the last file in FILE_LIST, then
1218 set *C to EOF and return. Subsequent calls do likewise. Return
1219 true if successful. */
1228 while (in_stream != NULL) /* EOF. */
1230 *c = fgetc (in_stream);
1235 ok &= check_and_close (errno);
1237 ok &= open_next_file ();
1243 /* Read N bytes into BLOCK from the concatenation of the input files
1244 named in the global array FILE_LIST. On the first call to this
1245 function, the global variable IN_STREAM is expected to be an open
1246 stream associated with the input file INPUT_FILENAME. If all N
1247 bytes cannot be read from IN_STREAM, close IN_STREAM and update
1248 the global variables IN_STREAM and INPUT_FILENAME. Then try to
1249 read the remaining bytes from the newly opened file. Repeat if
1250 necessary until EOF is reached for the last file in FILE_LIST.
1251 On subsequent calls, don't modify BLOCK and return true. Set
1252 *N_BYTES_IN_BUFFER to the number of bytes read. If an error occurs,
1253 it will be detected through ferror when the stream is about to be
1254 closed. If there is an error, give a message but continue reading
1255 as usual and return false. Otherwise return true. */
1258 read_block (size_t n, char *block, size_t *n_bytes_in_buffer)
1262 assert (0 < n && n <= bytes_per_block);
1264 *n_bytes_in_buffer = 0;
1269 while (in_stream != NULL) /* EOF. */
1274 n_needed = n - *n_bytes_in_buffer;
1275 n_read = fread (block + *n_bytes_in_buffer, 1, n_needed, in_stream);
1277 *n_bytes_in_buffer += n_read;
1279 if (n_read == n_needed)
1282 ok &= check_and_close (errno);
1284 ok &= open_next_file ();
1290 /* Return the least common multiple of the sizes associated
1291 with the format specs. */
1299 for (i = 0; i < n_specs; i++)
1300 l_c_m = lcm (l_c_m, width_bytes[spec[i].size]);
1304 /* If S is a valid traditional offset specification with an optional
1305 leading '+' return true and set *OFFSET to the offset it denotes. */
1308 parse_old_offset (const char *s, uintmax_t *offset)
1315 /* Skip over any leading '+'. */
1319 /* Determine the radix we'll use to interpret S. If there is a `.',
1320 it's decimal, otherwise, if the string begins with `0X'or `0x',
1321 it's hexadecimal, else octal. */
1322 if (strchr (s, '.') != NULL)
1326 if (s[0] == '0' && (s[1] == 'x' || s[1] == 'X'))
1332 return xstrtoumax (s, NULL, radix, offset, "Bb") == LONGINT_OK;
1335 /* Read a chunk of size BYTES_PER_BLOCK from the input files, write the
1336 formatted block to standard output, and repeat until the specified
1337 maximum number of bytes has been read or until all input has been
1338 processed. If the last block read is smaller than BYTES_PER_BLOCK
1339 and its size is not a multiple of the size associated with a format
1340 spec, extend the input block with zero bytes until its length is a
1341 multiple of all format spec sizes. Write the final block. Finally,
1342 write on a line by itself the offset of the byte after the last byte
1343 read. Accumulate return values from calls to read_block and
1344 check_and_close, and if any was false, return false.
1345 Otherwise, return true. */
1351 uintmax_t current_offset;
1354 size_t n_bytes_read;
1356 block[0] = xnmalloc (2, bytes_per_block);
1357 block[1] = block[0] + bytes_per_block;
1359 current_offset = n_bytes_to_skip;
1361 if (limit_bytes_to_format)
1366 if (current_offset >= end_offset)
1371 n_needed = MIN (end_offset - current_offset,
1372 (uintmax_t) bytes_per_block);
1373 ok &= read_block (n_needed, block[idx], &n_bytes_read);
1374 if (n_bytes_read < bytes_per_block)
1376 assert (n_bytes_read == bytes_per_block);
1377 write_block (current_offset, n_bytes_read,
1378 block[!idx], block[idx]);
1379 current_offset += n_bytes_read;
1387 ok &= read_block (bytes_per_block, block[idx], &n_bytes_read);
1388 if (n_bytes_read < bytes_per_block)
1390 assert (n_bytes_read == bytes_per_block);
1391 write_block (current_offset, n_bytes_read,
1392 block[!idx], block[idx]);
1393 current_offset += n_bytes_read;
1398 if (n_bytes_read > 0)
1401 size_t bytes_to_write;
1405 /* Make bytes_to_write the smallest multiple of l_c_m that
1406 is at least as large as n_bytes_read. */
1407 bytes_to_write = l_c_m * ((n_bytes_read + l_c_m - 1) / l_c_m);
1409 memset (block[idx] + n_bytes_read, 0, bytes_to_write - n_bytes_read);
1410 write_block (current_offset, bytes_to_write,
1411 block[!idx], block[idx]);
1412 current_offset += n_bytes_read;
1415 format_address (current_offset, '\n');
1417 if (limit_bytes_to_format && current_offset >= end_offset)
1418 ok &= check_and_close (0);
1425 /* STRINGS mode. Find each "string constant" in the input.
1426 A string constant is a run of at least `string_min' ASCII
1427 graphic (or formatting) characters terminated by a null.
1428 Based on a function written by Richard Stallman for a
1429 traditional version of od. Return true if successful. */
1434 size_t bufsize = MAX (100, string_min);
1435 char *buf = xmalloc (bufsize);
1436 uintmax_t address = n_bytes_to_skip;
1444 /* See if the next `string_min' chars are all printing chars. */
1447 if (limit_bytes_to_format
1448 && (end_offset < string_min || end_offset - string_min <= address))
1451 for (i = 0; i < string_min; i++)
1453 ok &= read_char (&c);
1461 /* Found a non-printing. Try again starting with next char. */
1466 /* We found a run of `string_min' printable characters.
1467 Now see if it is terminated with a null byte. */
1468 while (!limit_bytes_to_format || address < end_offset)
1472 buf = x2nrealloc (buf, &bufsize, sizeof *buf);
1474 ok &= read_char (&c);
1482 break; /* It is; print this string. */
1484 goto tryline; /* It isn't; give up on this string. */
1485 buf[i++] = c; /* String continues; store it all. */
1488 /* If we get here, the string is all printable and null-terminated,
1489 so print it. It is all in `buf' and `i' is its length. */
1491 format_address (address - i - 1, ' ');
1493 for (i = 0; (c = buf[i]); i++)
1498 fputs ("\\a", stdout);
1502 fputs ("\\b", stdout);
1506 fputs ("\\f", stdout);
1510 fputs ("\\n", stdout);
1514 fputs ("\\r", stdout);
1518 fputs ("\\t", stdout);
1522 fputs ("\\v", stdout);
1532 /* We reach this point only if we search through
1533 (max_bytes_to_format - string_min) bytes before reaching EOF. */
1537 ok &= check_and_close (0);
1542 main (int argc, char **argv)
1548 size_t desired_width IF_LINT (= 0);
1549 bool modern = false;
1550 bool width_specified = false;
1553 /* The old-style `pseudo starting address' to be printed in parentheses
1554 after any true address. */
1555 uintmax_t pseudo_start IF_LINT (= 0);
1557 initialize_main (&argc, &argv);
1558 program_name = argv[0];
1559 setlocale (LC_ALL, "");
1560 bindtextdomain (PACKAGE, LOCALEDIR);
1561 textdomain (PACKAGE);
1563 atexit (close_stdout);
1565 for (i = 0; i <= MAX_INTEGRAL_TYPE_SIZE; i++)
1566 integral_type_size[i] = NO_SIZE;
1568 integral_type_size[sizeof (char)] = CHAR;
1569 integral_type_size[sizeof (short int)] = SHORT;
1570 integral_type_size[sizeof (int)] = INT;
1571 integral_type_size[sizeof (long int)] = LONG;
1572 #if HAVE_UNSIGNED_LONG_LONG
1573 /* If `long int' and `long long int' have the same size, it's fine
1574 to overwrite the entry for `long' with this one. */
1575 integral_type_size[sizeof (ulonglong_t)] = LONG_LONG;
1578 for (i = 0; i <= MAX_FP_TYPE_SIZE; i++)
1579 fp_type_size[i] = NO_SIZE;
1581 fp_type_size[sizeof (float)] = FLOAT_SINGLE;
1582 /* The array entry for `double' is filled in after that for LONG_DOUBLE
1583 so that if `long double' is the same type or if long double isn't
1584 supported FLOAT_LONG_DOUBLE will never be used. */
1585 fp_type_size[sizeof (LONG_DOUBLE)] = FLOAT_LONG_DOUBLE;
1586 fp_type_size[sizeof (double)] = FLOAT_DOUBLE;
1589 n_specs_allocated = 0;
1592 format_address = format_address_std;
1594 address_pad_len = 7;
1595 flag_dump_strings = false;
1597 while ((c = getopt_long (argc, argv, short_options, long_options, NULL))
1601 enum strtol_error s_err;
1610 format_address = format_address_std;
1612 address_pad_len = 7;
1615 format_address = format_address_std;
1617 address_pad_len = 7;
1620 format_address = format_address_std;
1622 address_pad_len = 6;
1625 format_address = format_address_none;
1626 address_pad_len = 0;
1629 error (EXIT_FAILURE, 0,
1630 _("invalid output address radix `%c'; \
1631 it must be one character from [doxn]"),
1639 s_err = xstrtoumax (optarg, NULL, 0, &n_bytes_to_skip, "bkm");
1640 if (s_err != LONGINT_OK)
1641 STRTOL_FATAL_ERROR (optarg, _("skip argument"), s_err);
1646 limit_bytes_to_format = true;
1648 s_err = xstrtoumax (optarg, NULL, 0, &max_bytes_to_format, "bkm");
1649 if (s_err != LONGINT_OK)
1650 STRTOL_FATAL_ERROR (optarg, _("limit argument"), s_err);
1659 s_err = xstrtoumax (optarg, NULL, 0, &tmp, "bkm");
1660 if (s_err != LONGINT_OK)
1661 STRTOL_FATAL_ERROR (optarg, _("minimum string length"), s_err);
1663 /* The minimum string length may be no larger than SIZE_MAX,
1664 since we may allocate a buffer of this size. */
1666 error (EXIT_FAILURE, 0, _("%s is too large"), optarg);
1670 flag_dump_strings = true;
1675 ok &= decode_format_string (optarg);
1680 abbreviate_duplicate_blocks = false;
1683 case TRADITIONAL_OPTION:
1687 /* The next several cases map the traditional format
1688 specification options to the corresponding modern format
1689 specs. GNU od accepts any combination of old- and
1690 new-style options. Format specification options accumulate.
1691 The obsolescent and undocumented formats are compatible
1692 with FreeBSD 4.10 od. */
1694 #define CASE_OLD_ARG(old_char,new_string) \
1696 ok &= decode_format_string (new_string); \
1699 CASE_OLD_ARG ('a', "a");
1700 CASE_OLD_ARG ('b', "o1");
1701 CASE_OLD_ARG ('c', "c");
1702 CASE_OLD_ARG ('D', "u4"); /* obsolescent and undocumented */
1703 CASE_OLD_ARG ('d', "u2");
1704 case 'F': /* obsolescent and undocumented alias */
1705 CASE_OLD_ARG ('e', "fD"); /* obsolescent and undocumented */
1706 CASE_OLD_ARG ('f', "fF");
1707 case 'X': /* obsolescent and undocumented alias */
1708 CASE_OLD_ARG ('H', "x4"); /* obsolescent and undocumented */
1709 CASE_OLD_ARG ('i', "dI");
1710 case 'I': case 'L': /* obsolescent and undocumented aliases */
1711 CASE_OLD_ARG ('l', "dL");
1712 CASE_OLD_ARG ('O', "o4"); /* obsolesent and undocumented */
1713 case 'B': /* obsolescent and undocumented alias */
1714 CASE_OLD_ARG ('o', "o2");
1715 CASE_OLD_ARG ('s', "d2");
1716 case 'h': /* obsolescent and undocumented alias */
1717 CASE_OLD_ARG ('x', "x2");
1723 width_specified = true;
1731 s_err = xstrtoumax (optarg, NULL, 10, &w_tmp, "");
1732 if (s_err != LONGINT_OK)
1733 STRTOL_FATAL_ERROR (optarg, _("width specification"), s_err);
1734 if (SIZE_MAX < w_tmp)
1735 error (EXIT_FAILURE, 0, _("%s is too large"), optarg);
1736 desired_width = w_tmp;
1740 case_GETOPT_HELP_CHAR;
1742 case_GETOPT_VERSION_CHAR (PROGRAM_NAME, AUTHORS);
1745 usage (EXIT_FAILURE);
1751 exit (EXIT_FAILURE);
1753 if (flag_dump_strings && n_specs > 0)
1754 error (EXIT_FAILURE, 0,
1755 _("no type may be specified when dumping strings"));
1757 n_files = argc - optind;
1759 /* If the --traditional option is used, there may be from
1760 0 to 3 remaining command line arguments; handle each case
1762 od [file] [[+]offset[.][b] [[+]label[.][b]]]
1763 The offset and label have the same syntax.
1765 If --traditional is not given, and if no modern options are
1766 given, and if the offset begins with + or (if there are two
1767 operands) a digit, accept only this form, as per POSIX:
1768 od [file] [[+]offset[.][b]]
1771 if (!modern | traditional)
1779 if ((traditional || argv[optind][0] == '+')
1780 && parse_old_offset (argv[optind], &o1))
1782 n_bytes_to_skip = o1;
1789 if ((traditional || argv[optind + 1][0] == '+'
1790 || ISDIGIT (argv[optind + 1][0]))
1791 && parse_old_offset (argv[optind + 1], &o2))
1793 if (traditional && parse_old_offset (argv[optind], &o1))
1795 n_bytes_to_skip = o1;
1796 flag_pseudo_start = true;
1803 n_bytes_to_skip = o2;
1805 argv[optind + 1] = argv[optind];
1813 && parse_old_offset (argv[optind + 1], &o1)
1814 && parse_old_offset (argv[optind + 2], &o2))
1816 n_bytes_to_skip = o1;
1817 flag_pseudo_start = true;
1819 argv[optind + 2] = argv[optind];
1826 if (traditional && 1 < n_files)
1828 error (0, 0, _("extra operand %s"), quote (argv[optind + 1]));
1829 error (0, 0, "%s\n",
1830 _("Compatibility mode supports at most one file."));
1831 usage (EXIT_FAILURE);
1835 if (flag_pseudo_start)
1837 if (format_address == format_address_none)
1840 address_pad_len = 7;
1841 format_address = format_address_paren;
1844 format_address = format_address_label;
1847 if (limit_bytes_to_format)
1849 end_offset = n_bytes_to_skip + max_bytes_to_format;
1850 if (end_offset < n_bytes_to_skip)
1851 error (EXIT_FAILURE, 0, _("skip-bytes + read-bytes is too large"));
1855 decode_format_string ("oS");
1859 /* Set the global pointer FILE_LIST so that it
1860 references the first file-argument on the command-line. */
1862 file_list = (char const *const *) &argv[optind];
1866 /* No files were listed on the command line.
1867 Set the global pointer FILE_LIST so that it
1868 references the null-terminated list of one name: "-". */
1870 file_list = default_file_list;
1873 /* open the first input file */
1874 ok = open_next_file ();
1875 if (in_stream == NULL)
1878 /* skip over any unwanted header bytes */
1879 ok &= skip (n_bytes_to_skip);
1880 if (in_stream == NULL)
1883 pseudo_offset = (flag_pseudo_start ? pseudo_start - n_bytes_to_skip : 0);
1885 /* Compute output block length. */
1888 if (width_specified)
1890 if (desired_width != 0 && desired_width % l_c_m == 0)
1891 bytes_per_block = desired_width;
1894 error (0, 0, _("warning: invalid width %lu; using %d instead"),
1895 (unsigned long int) desired_width, l_c_m);
1896 bytes_per_block = l_c_m;
1901 if (l_c_m < DEFAULT_BYTES_PER_BLOCK)
1902 bytes_per_block = l_c_m * (DEFAULT_BYTES_PER_BLOCK / l_c_m);
1904 bytes_per_block = l_c_m;
1908 for (i = 0; i < n_specs; i++)
1910 printf (_("%d: fmt=\"%s\" width=%d\n"),
1911 i, spec[i].fmt_string, width_bytes[spec[i].size]);
1915 ok &= (flag_dump_strings ? dump_strings () : dump ());
1919 if (have_read_stdin && fclose (stdin) == EOF)
1920 error (EXIT_FAILURE, errno, _("standard input"));
1922 exit (ok ? EXIT_SUCCESS : EXIT_FAILURE);