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., 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;
47 /* The default number of input bytes per output line. */
48 #define DEFAULT_BYTES_PER_BLOCK 16
50 /* The number of decimal digits of precision in a float. */
55 /* The number of decimal digits of precision in a double. */
60 /* The number of decimal digits of precision in a long double. */
62 # define LDBL_DIG DBL_DIG
65 #if HAVE_UNSIGNED_LONG_LONG
66 typedef unsigned long long int ulonglong_t;
68 /* This is just a place-holder to avoid a few `#if' directives.
69 In this case, the type isn't actually used. */
70 typedef unsigned long int ulonglong_t;
81 /* FIXME: add INTMAX support, too */
99 /* The maximum number of bytes needed for a format string,
100 including the trailing null. */
103 FMT_BYTES_ALLOCATED =
104 MAX ((sizeof " %0" - 1 + INT_STRLEN_BOUND (int)
110 sizeof " %.Le" + 2 * INT_STRLEN_BOUND (int))
113 /* Each output format specification (from `-t spec' or from
114 old-style options) is represented by one of these structures. */
117 enum output_format fmt;
119 void (*print_function) (size_t, void const *, char const *);
120 char fmt_string[FMT_BYTES_ALLOCATED];
121 bool hexl_mode_trailer;
125 /* The name this program was run with. */
128 /* Convert the number of 8-bit bytes of a binary representation to
129 the number of characters (digits + sign if the type is signed)
130 required to represent the same quantity in the specified base/type.
131 For example, a 32-bit (4-byte) quantity may require a field width
132 as wide as the following for these types:
136 8 unsigned hexadecimal */
138 static char const bytes_to_oct_digits[] =
139 {0, 3, 6, 8, 11, 14, 16, 19, 22, 25, 27, 30, 32, 35, 38, 41, 43};
141 static char const bytes_to_signed_dec_digits[] =
142 {1, 4, 6, 8, 11, 13, 16, 18, 20, 23, 25, 28, 30, 33, 35, 37, 40};
144 static char const bytes_to_unsigned_dec_digits[] =
145 {0, 3, 5, 8, 10, 13, 15, 17, 20, 22, 25, 27, 29, 32, 34, 37, 39};
147 static char const bytes_to_hex_digits[] =
148 {0, 2, 4, 6, 8, 10, 12, 14, 16, 18, 20, 22, 24, 26, 28, 30, 32};
150 /* Convert enum size_spec to the size of the named type. */
151 static const int width_bytes[] =
158 sizeof (ulonglong_t),
164 /* Ensure that for each member of `enum size_spec' there is an
165 initializer in the width_bytes array. */
166 VERIFY (assert_width_bytes_matches_size_spec_decl,
167 sizeof width_bytes / sizeof width_bytes[0] == N_SIZE_SPECS);
169 /* Names for some non-printing characters. */
170 static const char *const charname[33] =
172 "nul", "soh", "stx", "etx", "eot", "enq", "ack", "bel",
173 "bs", "ht", "nl", "vt", "ff", "cr", "so", "si",
174 "dle", "dc1", "dc2", "dc3", "dc4", "nak", "syn", "etb",
175 "can", "em", "sub", "esc", "fs", "gs", "rs", "us",
179 /* Address base (8, 10 or 16). */
180 static int address_base;
182 /* The number of octal digits required to represent the largest
184 #define MAX_ADDRESS_LENGTH \
185 ((sizeof (uintmax_t) * CHAR_BIT + CHAR_BIT - 1) / 3)
187 /* Width of a normal address. */
188 static int address_pad_len;
190 static size_t string_min;
191 static bool flag_dump_strings;
193 /* True if we should recognize the older non-option arguments
194 that specified at most one file and optional arguments specifying
195 offset and pseudo-start address. */
196 static bool traditional;
198 /* True if an old-style `pseudo-address' was specified. */
199 static bool flag_pseudo_start;
201 /* The difference between the old-style pseudo starting address and
202 the number of bytes to skip. */
203 static uintmax_t pseudo_offset;
205 /* Function that accepts an address and an optional following char,
206 and prints the address and char to stdout. */
207 static void (*format_address) (uintmax_t, char);
209 /* The number of input bytes to skip before formatting and writing. */
210 static uintmax_t n_bytes_to_skip = 0;
212 /* When false, MAX_BYTES_TO_FORMAT and END_OFFSET are ignored, and all
213 input is formatted. */
214 static bool limit_bytes_to_format = false;
216 /* The maximum number of bytes that will be formatted. */
217 static uintmax_t max_bytes_to_format;
219 /* The offset of the first byte after the last byte to be formatted. */
220 static uintmax_t end_offset;
222 /* When true and two or more consecutive blocks are equal, format
223 only the first block and output an asterisk alone on the following
224 line to indicate that identical blocks have been elided. */
225 static bool abbreviate_duplicate_blocks = true;
227 /* An array of specs describing how to format each input block. */
228 static struct tspec *spec;
230 /* The number of format specs. */
231 static size_t n_specs;
233 /* The allocated length of SPEC. */
234 static size_t n_specs_allocated;
236 /* The number of input bytes formatted per output line. It must be
237 a multiple of the least common multiple of the sizes associated with
238 the specified output types. It should be as large as possible, but
239 no larger than 16 -- unless specified with the -w option. */
240 static size_t bytes_per_block;
242 /* Human-readable representation of *file_list (for error messages).
243 It differs from file_list[-1] only when file_list[-1] is "-". */
244 static char const *input_filename;
246 /* A NULL-terminated list of the file-arguments from the command line. */
247 static char const *const *file_list;
249 /* Initializer for file_list if no file-arguments
250 were specified on the command line. */
251 static char const *const default_file_list[] = {"-", NULL};
253 /* The input stream associated with the current file. */
254 static FILE *in_stream;
256 /* If true, at least one of the files we read was standard input. */
257 static bool have_read_stdin;
259 #define MAX_INTEGRAL_TYPE_SIZE sizeof (ulonglong_t)
260 static enum size_spec integral_type_size[MAX_INTEGRAL_TYPE_SIZE + 1];
262 #define MAX_FP_TYPE_SIZE sizeof (LONG_DOUBLE)
263 static enum size_spec fp_type_size[MAX_FP_TYPE_SIZE + 1];
265 #define COMMON_SHORT_OPTIONS "A:aBbcDdeFfHhIij:LlN:OoS:st:vXx"
267 /* For long options that have no equivalent short option, use a
268 non-character as a pseudo short option, starting with CHAR_MAX + 1. */
271 TRADITIONAL_OPTION = CHAR_MAX + 1
274 static struct option const long_options[] =
276 {"skip-bytes", required_argument, NULL, 'j'},
277 {"address-radix", required_argument, NULL, 'A'},
278 {"read-bytes", required_argument, NULL, 'N'},
279 {"format", required_argument, NULL, 't'},
280 {"output-duplicates", no_argument, NULL, 'v'},
281 {"strings", optional_argument, NULL, 'S'},
282 {"traditional", no_argument, NULL, TRADITIONAL_OPTION},
283 {"width", optional_argument, NULL, 'w'},
285 {GETOPT_HELP_OPTION_DECL},
286 {GETOPT_VERSION_OPTION_DECL},
293 if (status != EXIT_SUCCESS)
294 fprintf (stderr, _("Try `%s --help' for more information.\n"),
299 Usage: %s [OPTION]... [FILE]...\n\
300 or: %s [-abcdfilosx]... [FILE] [[+]OFFSET[.][b]]\n\
301 or: %s --traditional [OPTION]... [FILE] [[+]OFFSET[.][b] [+][LABEL][.][b]]\n\
303 program_name, program_name, program_name);
305 Write an unambiguous representation, octal bytes by default,\n\
306 of FILE to standard output. With more than one FILE argument,\n\
307 concatenate them in the listed order to form the input.\n\
308 With no FILE, or when FILE is -, read standard input.\n\
312 All arguments to long options are mandatory for short options.\n\
315 -A, --address-radix=RADIX decide how file offsets are printed\n\
316 -j, --skip-bytes=BYTES skip BYTES input bytes first\n\
319 -N, --read-bytes=BYTES limit dump to BYTES input bytes\n\
320 -S, --strings[=BYTES] output strings of at least BYTES graphic chars\n\
321 -t, --format=TYPE select output format or formats\n\
322 -v, --output-duplicates do not use * to mark line suppression\n\
323 -w, --width[=BYTES] output BYTES bytes per output line\n\
324 --traditional accept arguments in traditional form\n\
326 fputs (HELP_OPTION_DESCRIPTION, stdout);
327 fputs (VERSION_OPTION_DESCRIPTION, stdout);
330 Traditional format specifications may be intermixed; they accumulate:\n\
331 -a same as -t a, select named characters\n\
332 -b same as -t o1, select octal bytes\n\
333 -c same as -t c, select ASCII characters or backslash escapes\n\
334 -d same as -t u2, select unsigned decimal 2-byte units\n\
337 -f same as -t fF, select floats\n\
338 -i same as -t dI, select decimal ints\n\
339 -l same as -t dL, select decimal longs\n\
340 -o same as -t o2, select octal 2-byte units\n\
341 -s same as -t d2, select decimal 2-byte units\n\
342 -x same as -t x2, select hexadecimal 2-byte units\n\
346 If first and second call formats both apply, the second format is assumed\n\
347 if the last operand begins with + or (if there are 2 operands) a digit.\n\
348 An OFFSET operand means -j OFFSET. LABEL is the pseudo-address\n\
349 at first byte printed, incremented when dump is progressing.\n\
350 For OFFSET and LABEL, a 0x or 0X prefix indicates hexadecimal;\n\
351 suffixes may be . for octal and b for multiply by 512.\n\
353 TYPE is made up of one or more of these specifications:\n\
356 c ASCII character or backslash escape\n\
359 d[SIZE] signed decimal, SIZE bytes per integer\n\
360 f[SIZE] floating point, SIZE bytes per integer\n\
361 o[SIZE] octal, SIZE bytes per integer\n\
362 u[SIZE] unsigned decimal, SIZE bytes per integer\n\
363 x[SIZE] hexadecimal, SIZE bytes per integer\n\
367 SIZE is a number. For TYPE in doux, SIZE may also be C for\n\
368 sizeof(char), S for sizeof(short), I for sizeof(int) or L for\n\
369 sizeof(long). If TYPE is f, SIZE may also be F for sizeof(float), D\n\
370 for sizeof(double) or L for sizeof(long double).\n\
374 RADIX is d for decimal, o for octal, x for hexadecimal or n for none.\n\
375 BYTES is hexadecimal with 0x or 0X prefix, it is multiplied by 512\n\
376 with b suffix, by 1024 with k and by 1048576 with m. Adding a z suffix to\n\
377 any type adds a display of printable characters to the end of each line\n\
381 --string without a number implies 3. --width without a number\n\
382 implies 32. By default, od uses -A o -t d2 -w 16.\n\
384 printf (_("\nReport bugs to <%s>.\n"), PACKAGE_BUGREPORT);
389 /* Define the print functions. */
392 print_s_char (size_t n_bytes, void const *block, char const *fmt_string)
394 signed char const *p = block;
396 for (i = n_bytes / sizeof *p; i != 0; i--)
397 printf (fmt_string, *p++);
401 print_char (size_t n_bytes, void const *block, char const *fmt_string)
403 unsigned char const *p = block;
405 for (i = n_bytes / sizeof *p; i != 0; i--)
406 printf (fmt_string, *p++);
410 print_s_short (size_t n_bytes, void const *block, char const *fmt_string)
412 short int const *p = block;
414 for (i = n_bytes / sizeof *p; i != 0; i--)
415 printf (fmt_string, *p++);
419 print_short (size_t n_bytes, void const *block, char const *fmt_string)
421 unsigned short int const *p = block;
423 for (i = n_bytes / sizeof *p; i != 0; i--)
424 printf (fmt_string, *p++);
428 print_int (size_t n_bytes, void const *block, char const *fmt_string)
430 unsigned int const *p = block;
432 for (i = n_bytes / sizeof *p; i != 0; i--)
433 printf (fmt_string, *p++);
437 print_long (size_t n_bytes, void const *block, char const *fmt_string)
439 unsigned long int const *p = block;
441 for (i = n_bytes / sizeof *p; i != 0; i--)
442 printf (fmt_string, *p++);
446 print_long_long (size_t n_bytes, void const *block, char const *fmt_string)
448 ulonglong_t const *p = block;
450 for (i = n_bytes / sizeof *p; i != 0; i--)
451 printf (fmt_string, *p++);
455 print_float (size_t n_bytes, void const *block, char const *fmt_string)
457 float const *p = block;
459 for (i = n_bytes / sizeof *p; i != 0; i--)
460 printf (fmt_string, *p++);
464 print_double (size_t n_bytes, void const *block, char const *fmt_string)
466 double const *p = block;
468 for (i = n_bytes / sizeof *p; i != 0; i--)
469 printf (fmt_string, *p++);
472 #ifdef HAVE_LONG_DOUBLE
474 print_long_double (size_t n_bytes, void const *block, char const *fmt_string)
476 long double const *p = block;
478 for (i = n_bytes / sizeof *p; i != 0; i--)
479 printf (fmt_string, *p++);
484 dump_hexl_mode_trailer (size_t n_bytes, const char *block)
487 fputs (" >", stdout);
488 for (i = n_bytes; i > 0; i--)
490 unsigned char c = *block++;
491 unsigned char c2 = (ISPRINT(c) ? c : '.');
498 print_named_ascii (size_t n_bytes, void const *block,
499 const char *unused_fmt_string ATTRIBUTE_UNUSED)
501 unsigned char const *p = block;
503 for (i = n_bytes; i > 0; i--)
505 int masked_c = *p++ & 0x7f;
511 else if (masked_c <= 040)
512 s = charname[masked_c];
515 sprintf (buf, " %c", masked_c);
524 print_ascii (size_t n_bytes, void const *block,
525 const char *unused_fmt_string ATTRIBUTE_UNUSED)
527 unsigned char const *p = block;
529 for (i = n_bytes; i > 0; i--)
531 unsigned char c = *p++;
570 sprintf (buf, (ISPRINT (c) ? " %c" : "%03o"), c);
578 /* Convert a null-terminated (possibly zero-length) string S to an
579 unsigned long integer value. If S points to a non-digit set *P to S,
580 *VAL to 0, and return true. Otherwise, accumulate the integer value of
581 the string of digits. If the string of digits represents a value
582 larger than ULONG_MAX, don't modify *VAL or *P and return false.
583 Otherwise, advance *P to the first non-digit after S, set *VAL to
584 the result of the conversion and return true. */
587 simple_strtoul (const char *s, const char **p, unsigned long int *val)
589 unsigned long int sum;
595 if (sum > (ULONG_MAX - c) / 10)
604 /* If S points to a single valid modern od format string, put
605 a description of that format in *TSPEC, make *NEXT point at the
606 character following the just-decoded format (if *NEXT is non-NULL),
607 and return true. If S is not valid, don't modify *NEXT or *TSPEC,
608 give a diagnostic, and return false. For example, if S were
609 "d4afL" *NEXT would be set to "afL" and *TSPEC would be
611 fmt = SIGNED_DECIMAL;
612 size = INT or LONG; (whichever integral_type_size[4] resolves to)
613 print_function = print_int; (assuming size == INT)
614 fmt_string = "%011d%c";
616 S_ORIG is solely for reporting errors. It should be the full format
621 decode_one_format (const char *s_orig, const char *s, const char **next,
624 enum size_spec size_spec;
625 unsigned long int size;
626 enum output_format fmt;
627 const char *pre_fmt_string;
628 void (*print_function) (size_t, void const *, char const *);
634 assert (tspec != NULL);
648 size = sizeof (char);
653 size = sizeof (short int);
663 size = sizeof (long int);
667 if (! simple_strtoul (s, &p, &size))
669 /* The integer at P in S would overflow an unsigned long int.
670 A digit string that long is sufficiently odd looking
671 that the following diagnostic is sufficient. */
672 error (0, 0, _("invalid type string `%s'"), s_orig);
679 if (MAX_INTEGRAL_TYPE_SIZE < size
680 || integral_type_size[size] == NO_SIZE)
682 error (0, 0, _("invalid type string `%s';\n\
683 this system doesn't provide a %lu-byte integral type"), s_orig, size);
691 #define ISPEC_TO_FORMAT(Spec, Min_format, Long_format, Max_format) \
692 ((Spec) == LONG_LONG ? (Max_format) \
693 : ((Spec) == LONG ? (Long_format) \
696 size_spec = integral_type_size[size];
701 fmt = SIGNED_DECIMAL;
702 sprintf (tspec->fmt_string, " %%%d%s",
703 (field_width = bytes_to_signed_dec_digits[size]),
704 ISPEC_TO_FORMAT (size_spec, "d", "ld", PRIdMAX));
709 sprintf (tspec->fmt_string, " %%0%d%s",
710 (field_width = bytes_to_oct_digits[size]),
711 ISPEC_TO_FORMAT (size_spec, "o", "lo", PRIoMAX));
715 fmt = UNSIGNED_DECIMAL;
716 sprintf (tspec->fmt_string, " %%%d%s",
717 (field_width = bytes_to_unsigned_dec_digits[size]),
718 ISPEC_TO_FORMAT (size_spec, "u", "lu", PRIuMAX));
723 sprintf (tspec->fmt_string, " %%0%d%s",
724 (field_width = bytes_to_hex_digits[size]),
725 ISPEC_TO_FORMAT (size_spec, "x", "lx", PRIxMAX));
732 assert (strlen (tspec->fmt_string) < FMT_BYTES_ALLOCATED);
737 print_function = (fmt == SIGNED_DECIMAL
743 print_function = (fmt == SIGNED_DECIMAL
749 print_function = print_int;
753 print_function = print_long;
757 print_function = print_long_long;
766 fmt = FLOATING_POINT;
772 size = sizeof (float);
777 size = sizeof (double);
782 size = sizeof (LONG_DOUBLE);
786 if (! simple_strtoul (s, &p, &size))
788 /* The integer at P in S would overflow an unsigned long int.
789 A digit string that long is sufficiently odd looking
790 that the following diagnostic is sufficient. */
791 error (0, 0, _("invalid type string `%s'"), s_orig);
795 size = sizeof (double);
798 if (size > MAX_FP_TYPE_SIZE
799 || fp_type_size[size] == NO_SIZE)
801 error (0, 0, _("invalid type string `%s';\n\
802 this system doesn't provide a %lu-byte floating point type"), s_orig, size);
809 size_spec = fp_type_size[size];
814 print_function = print_float;
815 /* Don't use %#e; not all systems support it. */
816 pre_fmt_string = " %%%d.%de";
821 print_function = print_double;
822 pre_fmt_string = " %%%d.%de";
826 #ifdef HAVE_LONG_DOUBLE
827 case FLOAT_LONG_DOUBLE:
828 print_function = print_long_double;
829 pre_fmt_string = " %%%d.%dLe";
830 precision = LDBL_DIG;
838 field_width = precision + 8;
839 sprintf (tspec->fmt_string, pre_fmt_string, field_width, precision);
844 fmt = NAMED_CHARACTER;
846 print_function = print_named_ascii;
854 print_function = print_ascii;
859 error (0, 0, _("invalid character `%c' in type string `%s'"),
864 tspec->size = size_spec;
866 tspec->print_function = print_function;
868 tspec->field_width = field_width;
869 tspec->hexl_mode_trailer = (*s == 'z');
870 if (tspec->hexl_mode_trailer)
879 /* Given a list of one or more input filenames FILE_LIST, set the global
880 file pointer IN_STREAM and the global string INPUT_FILENAME to the
881 first one that can be successfully opened. Modify FILE_LIST to
882 reference the next filename in the list. A file name of "-" is
883 interpreted as standard input. If any file open fails, give an error
884 message and return false. */
887 open_next_file (void)
893 input_filename = *file_list;
894 if (input_filename == NULL)
898 if (STREQ (input_filename, "-"))
900 input_filename = _("standard input");
902 have_read_stdin = true;
906 in_stream = fopen (input_filename, "r");
907 if (in_stream == NULL)
909 error (0, errno, "%s", input_filename);
914 while (in_stream == NULL);
916 if (limit_bytes_to_format & !flag_dump_strings)
917 SETVBUF (in_stream, NULL, _IONBF, 0);
918 SET_BINARY (fileno (in_stream));
923 /* Test whether there have been errors on in_stream, and close it if
924 it is not standard input. Return false if there has been an error
925 on in_stream or stdout; return true otherwise. This function will
926 report more than one error only if both a read and a write error
927 have occurred. IN_ERRNO, if nonzero, is the error number
928 corresponding to the most recent action for IN_STREAM. */
931 check_and_close (int in_errno)
935 if (in_stream != NULL)
937 if (ferror (in_stream))
939 error (0, in_errno, _("%s: read error"), input_filename);
940 if (! STREQ (file_list[-1], "-"))
944 else if (! STREQ (file_list[-1], "-") && fclose (in_stream) != 0)
946 error (0, errno, "%s", input_filename);
955 error (0, 0, _("write error"));
962 /* Decode the modern od format string S. Append the decoded
963 representation to the global array SPEC, reallocating SPEC if
964 necessary. Return true if S is valid. */
967 decode_format_string (const char *s)
969 const char *s_orig = s;
976 if (n_specs_allocated <= n_specs)
977 spec = x2nrealloc (spec, &n_specs_allocated, sizeof *spec);
979 if (! decode_one_format (s_orig, s, &next, &spec[n_specs]))
990 /* Given a list of one or more input filenames FILE_LIST, set the global
991 file pointer IN_STREAM to position N_SKIP in the concatenation of
992 those files. If any file operation fails or if there are fewer than
993 N_SKIP bytes in the combined input, give an error message and return
994 false. When possible, use seek rather than read operations to
995 advance IN_STREAM. */
998 skip (uintmax_t n_skip)
1006 while (in_stream != NULL) /* EOF. */
1008 struct stat file_stats;
1010 /* First try seeking. For large offsets, this extra work is
1011 worthwhile. If the offset is below some threshold it may be
1012 more efficient to move the pointer by reading. There are two
1013 issues when trying to seek:
1014 - the file must be seekable.
1015 - before seeking to the specified position, make sure
1016 that the new position is in the current file.
1017 Try to do that by getting file's size using fstat.
1018 But that will work only for regular files. */
1020 if (fstat (fileno (in_stream), &file_stats) == 0)
1022 /* The st_size field is valid only for regular files
1023 (and for symbolic links, which cannot occur here).
1024 If the number of bytes left to skip is at least
1025 as large as the size of the current file, we can
1026 decrement n_skip and go on to the next file. */
1028 if (S_ISREG (file_stats.st_mode) && 0 <= file_stats.st_size)
1030 if ((uintmax_t) file_stats.st_size <= n_skip)
1031 n_skip -= file_stats.st_size;
1034 if (fseeko (in_stream, n_skip, SEEK_CUR) != 0)
1043 /* If it's not a regular file with nonnegative size,
1044 position the file pointer by reading. */
1049 size_t n_bytes_read, n_bytes_to_read = BUFSIZ;
1053 if (n_skip < n_bytes_to_read)
1054 n_bytes_to_read = n_skip;
1055 n_bytes_read = fread (buf, 1, n_bytes_to_read, in_stream);
1056 n_skip -= n_bytes_read;
1057 if (n_bytes_read != n_bytes_to_read)
1071 else /* cannot fstat() file */
1073 error (0, errno, "%s", input_filename);
1077 ok &= check_and_close (in_errno);
1079 ok &= open_next_file ();
1083 error (EXIT_FAILURE, 0, _("cannot skip past end of combined input"));
1089 format_address_none (uintmax_t address ATTRIBUTE_UNUSED, char c ATTRIBUTE_UNUSED)
1094 format_address_std (uintmax_t address, char c)
1096 char buf[MAX_ADDRESS_LENGTH + 2];
1097 char *p = buf + sizeof buf;
1102 pbound = p - address_pad_len;
1104 /* Use a special case of the code for each base. This is measurably
1105 faster than generic code. */
1106 switch (address_base)
1110 *--p = '0' + (address & 7);
1111 while ((address >>= 3) != 0);
1116 *--p = '0' + (address % 10);
1117 while ((address /= 10) != 0);
1122 *--p = "0123456789abcdef"[address & 15];
1123 while ((address >>= 4) != 0);
1134 format_address_paren (uintmax_t address, char c)
1137 format_address_std (address, ')');
1143 format_address_label (uintmax_t address, char c)
1145 format_address_std (address, ' ');
1146 format_address_paren (address + pseudo_offset, c);
1149 /* Write N_BYTES bytes from CURR_BLOCK to standard output once for each
1150 of the N_SPEC format specs. CURRENT_OFFSET is the byte address of
1151 CURR_BLOCK in the concatenation of input files, and it is printed
1152 (optionally) only before the output line associated with the first
1153 format spec. When duplicate blocks are being abbreviated, the output
1154 for a sequence of identical input blocks is the output for the first
1155 block followed by an asterisk alone on a line. It is valid to compare
1156 the blocks PREV_BLOCK and CURR_BLOCK only when N_BYTES == BYTES_PER_BLOCK.
1157 That condition may be false only for the last input block -- and then
1158 only when it has not been padded to length BYTES_PER_BLOCK. */
1161 write_block (uintmax_t current_offset, size_t n_bytes,
1162 const char *prev_block, const char *curr_block)
1164 static bool first = true;
1165 static bool prev_pair_equal = false;
1167 #define EQUAL_BLOCKS(b1, b2) (memcmp ((b1), (b2), bytes_per_block) == 0)
1169 if (abbreviate_duplicate_blocks
1170 && !first && n_bytes == bytes_per_block
1171 && EQUAL_BLOCKS (prev_block, curr_block))
1173 if (prev_pair_equal)
1175 /* The two preceding blocks were equal, and the current
1176 block is the same as the last one, so print nothing. */
1181 prev_pair_equal = true;
1188 prev_pair_equal = false;
1189 for (i = 0; i < n_specs; i++)
1192 format_address (current_offset, '\0');
1194 printf ("%*s", address_pad_len, "");
1195 (*spec[i].print_function) (n_bytes, curr_block, spec[i].fmt_string);
1196 if (spec[i].hexl_mode_trailer)
1198 /* space-pad out to full line width, then dump the trailer */
1199 int datum_width = width_bytes[spec[i].size];
1200 int blank_fields = (bytes_per_block - n_bytes) / datum_width;
1201 int field_width = spec[i].field_width + 1;
1202 printf ("%*s", blank_fields * field_width, "");
1203 dump_hexl_mode_trailer (n_bytes, curr_block);
1211 /* Read a single byte into *C from the concatenation of the input files
1212 named in the global array FILE_LIST. On the first call to this
1213 function, the global variable IN_STREAM is expected to be an open
1214 stream associated with the input file INPUT_FILENAME. If IN_STREAM
1215 is at end-of-file, close it and update the global variables IN_STREAM
1216 and INPUT_FILENAME so they correspond to the next file in the list.
1217 Then try to read a byte from the newly opened file. Repeat if
1218 necessary until EOF is reached for the last file in FILE_LIST, then
1219 set *C to EOF and return. Subsequent calls do likewise. Return
1220 true if successful. */
1229 while (in_stream != NULL) /* EOF. */
1231 *c = fgetc (in_stream);
1236 ok &= check_and_close (errno);
1238 ok &= open_next_file ();
1244 /* Read N bytes into BLOCK from the concatenation of the input files
1245 named in the global array FILE_LIST. On the first call to this
1246 function, the global variable IN_STREAM is expected to be an open
1247 stream associated with the input file INPUT_FILENAME. If all N
1248 bytes cannot be read from IN_STREAM, close IN_STREAM and update
1249 the global variables IN_STREAM and INPUT_FILENAME. Then try to
1250 read the remaining bytes from the newly opened file. Repeat if
1251 necessary until EOF is reached for the last file in FILE_LIST.
1252 On subsequent calls, don't modify BLOCK and return true. Set
1253 *N_BYTES_IN_BUFFER to the number of bytes read. If an error occurs,
1254 it will be detected through ferror when the stream is about to be
1255 closed. If there is an error, give a message but continue reading
1256 as usual and return false. Otherwise return true. */
1259 read_block (size_t n, char *block, size_t *n_bytes_in_buffer)
1263 assert (0 < n && n <= bytes_per_block);
1265 *n_bytes_in_buffer = 0;
1270 while (in_stream != NULL) /* EOF. */
1275 n_needed = n - *n_bytes_in_buffer;
1276 n_read = fread (block + *n_bytes_in_buffer, 1, n_needed, in_stream);
1278 *n_bytes_in_buffer += n_read;
1280 if (n_read == n_needed)
1283 ok &= check_and_close (errno);
1285 ok &= open_next_file ();
1291 /* Return the least common multiple of the sizes associated
1292 with the format specs. */
1300 for (i = 0; i < n_specs; i++)
1301 l_c_m = lcm (l_c_m, width_bytes[spec[i].size]);
1305 /* If S is a valid traditional offset specification with an optional
1306 leading '+' return true and set *OFFSET to the offset it denotes. */
1309 parse_old_offset (const char *s, uintmax_t *offset)
1316 /* Skip over any leading '+'. */
1320 /* Determine the radix we'll use to interpret S. If there is a `.',
1321 it's decimal, otherwise, if the string begins with `0X'or `0x',
1322 it's hexadecimal, else octal. */
1323 if (strchr (s, '.') != NULL)
1327 if (s[0] == '0' && (s[1] == 'x' || s[1] == 'X'))
1333 return xstrtoumax (s, NULL, radix, offset, "Bb") == LONGINT_OK;
1336 /* Read a chunk of size BYTES_PER_BLOCK from the input files, write the
1337 formatted block to standard output, and repeat until the specified
1338 maximum number of bytes has been read or until all input has been
1339 processed. If the last block read is smaller than BYTES_PER_BLOCK
1340 and its size is not a multiple of the size associated with a format
1341 spec, extend the input block with zero bytes until its length is a
1342 multiple of all format spec sizes. Write the final block. Finally,
1343 write on a line by itself the offset of the byte after the last byte
1344 read. Accumulate return values from calls to read_block and
1345 check_and_close, and if any was false, return false.
1346 Otherwise, return true. */
1352 uintmax_t current_offset;
1355 size_t n_bytes_read;
1357 block[0] = xnmalloc (2, bytes_per_block);
1358 block[1] = block[0] + bytes_per_block;
1360 current_offset = n_bytes_to_skip;
1362 if (limit_bytes_to_format)
1367 if (current_offset >= end_offset)
1372 n_needed = MIN (end_offset - current_offset,
1373 (uintmax_t) bytes_per_block);
1374 ok &= read_block (n_needed, block[idx], &n_bytes_read);
1375 if (n_bytes_read < bytes_per_block)
1377 assert (n_bytes_read == bytes_per_block);
1378 write_block (current_offset, n_bytes_read,
1379 block[!idx], block[idx]);
1380 current_offset += n_bytes_read;
1388 ok &= read_block (bytes_per_block, block[idx], &n_bytes_read);
1389 if (n_bytes_read < bytes_per_block)
1391 assert (n_bytes_read == bytes_per_block);
1392 write_block (current_offset, n_bytes_read,
1393 block[!idx], block[idx]);
1394 current_offset += n_bytes_read;
1399 if (n_bytes_read > 0)
1402 size_t bytes_to_write;
1406 /* Make bytes_to_write the smallest multiple of l_c_m that
1407 is at least as large as n_bytes_read. */
1408 bytes_to_write = l_c_m * ((n_bytes_read + l_c_m - 1) / l_c_m);
1410 memset (block[idx] + n_bytes_read, 0, bytes_to_write - n_bytes_read);
1411 write_block (current_offset, bytes_to_write,
1412 block[!idx], block[idx]);
1413 current_offset += n_bytes_read;
1416 format_address (current_offset, '\n');
1418 if (limit_bytes_to_format && current_offset >= end_offset)
1419 ok &= check_and_close (0);
1426 /* STRINGS mode. Find each "string constant" in the input.
1427 A string constant is a run of at least `string_min' ASCII
1428 graphic (or formatting) characters terminated by a null.
1429 Based on a function written by Richard Stallman for a
1430 traditional version of od. Return true if successful. */
1435 size_t bufsize = MAX (100, string_min);
1436 char *buf = xmalloc (bufsize);
1437 uintmax_t address = n_bytes_to_skip;
1445 /* See if the next `string_min' chars are all printing chars. */
1448 if (limit_bytes_to_format
1449 && (end_offset < string_min || end_offset - string_min <= address))
1452 for (i = 0; i < string_min; i++)
1454 ok &= read_char (&c);
1462 /* Found a non-printing. Try again starting with next char. */
1467 /* We found a run of `string_min' printable characters.
1468 Now see if it is terminated with a null byte. */
1469 while (!limit_bytes_to_format || address < end_offset)
1473 buf = x2nrealloc (buf, &bufsize, sizeof *buf);
1475 ok &= read_char (&c);
1483 break; /* It is; print this string. */
1485 goto tryline; /* It isn't; give up on this string. */
1486 buf[i++] = c; /* String continues; store it all. */
1489 /* If we get here, the string is all printable and null-terminated,
1490 so print it. It is all in `buf' and `i' is its length. */
1492 format_address (address - i - 1, ' ');
1494 for (i = 0; (c = buf[i]); i++)
1499 fputs ("\\a", stdout);
1503 fputs ("\\b", stdout);
1507 fputs ("\\f", stdout);
1511 fputs ("\\n", stdout);
1515 fputs ("\\r", stdout);
1519 fputs ("\\t", stdout);
1523 fputs ("\\v", stdout);
1533 /* We reach this point only if we search through
1534 (max_bytes_to_format - string_min) bytes before reaching EOF. */
1538 ok &= check_and_close (0);
1543 main (int argc, char **argv)
1549 size_t desired_width IF_LINT (= 0);
1550 bool modern = false;
1551 bool width_specified = false;
1553 char const *short_options = (posix2_version () < 200112
1554 ? COMMON_SHORT_OPTIONS "w::"
1555 : COMMON_SHORT_OPTIONS "w:");
1557 /* The old-style `pseudo starting address' to be printed in parentheses
1558 after any true address. */
1559 uintmax_t pseudo_start IF_LINT (= 0);
1561 initialize_main (&argc, &argv);
1562 program_name = argv[0];
1563 setlocale (LC_ALL, "");
1564 bindtextdomain (PACKAGE, LOCALEDIR);
1565 textdomain (PACKAGE);
1567 atexit (close_stdout);
1569 for (i = 0; i <= MAX_INTEGRAL_TYPE_SIZE; i++)
1570 integral_type_size[i] = NO_SIZE;
1572 integral_type_size[sizeof (char)] = CHAR;
1573 integral_type_size[sizeof (short int)] = SHORT;
1574 integral_type_size[sizeof (int)] = INT;
1575 integral_type_size[sizeof (long int)] = LONG;
1576 #if HAVE_UNSIGNED_LONG_LONG
1577 /* If `long int' and `long long int' have the same size, it's fine
1578 to overwrite the entry for `long' with this one. */
1579 integral_type_size[sizeof (ulonglong_t)] = LONG_LONG;
1582 for (i = 0; i <= MAX_FP_TYPE_SIZE; i++)
1583 fp_type_size[i] = NO_SIZE;
1585 fp_type_size[sizeof (float)] = FLOAT_SINGLE;
1586 /* The array entry for `double' is filled in after that for LONG_DOUBLE
1587 so that if `long double' is the same type or if long double isn't
1588 supported FLOAT_LONG_DOUBLE will never be used. */
1589 fp_type_size[sizeof (LONG_DOUBLE)] = FLOAT_LONG_DOUBLE;
1590 fp_type_size[sizeof (double)] = FLOAT_DOUBLE;
1593 n_specs_allocated = 0;
1596 format_address = format_address_std;
1598 address_pad_len = 7;
1599 flag_dump_strings = false;
1601 while ((c = getopt_long (argc, argv, short_options, long_options, NULL))
1605 enum strtol_error s_err;
1614 format_address = format_address_std;
1616 address_pad_len = 7;
1619 format_address = format_address_std;
1621 address_pad_len = 7;
1624 format_address = format_address_std;
1626 address_pad_len = 6;
1629 format_address = format_address_none;
1630 address_pad_len = 0;
1633 error (EXIT_FAILURE, 0,
1634 _("invalid output address radix `%c'; \
1635 it must be one character from [doxn]"),
1643 s_err = xstrtoumax (optarg, NULL, 0, &n_bytes_to_skip, "bkm");
1644 if (s_err != LONGINT_OK)
1645 STRTOL_FATAL_ERROR (optarg, _("skip argument"), s_err);
1650 limit_bytes_to_format = true;
1652 s_err = xstrtoumax (optarg, NULL, 0, &max_bytes_to_format, "bkm");
1653 if (s_err != LONGINT_OK)
1654 STRTOL_FATAL_ERROR (optarg, _("limit argument"), s_err);
1663 s_err = xstrtoumax (optarg, NULL, 0, &tmp, "bkm");
1664 if (s_err != LONGINT_OK)
1665 STRTOL_FATAL_ERROR (optarg, _("minimum string length"), s_err);
1667 /* The minimum string length may be no larger than SIZE_MAX,
1668 since we may allocate a buffer of this size. */
1670 error (EXIT_FAILURE, 0, _("%s is too large"), optarg);
1674 flag_dump_strings = true;
1679 ok &= decode_format_string (optarg);
1684 abbreviate_duplicate_blocks = false;
1687 case TRADITIONAL_OPTION:
1691 /* The next several cases map the traditional format
1692 specification options to the corresponding modern format
1693 specs. GNU od accepts any combination of old- and
1694 new-style options. Format specification options accumulate.
1695 The obsolescent and undocumented formats are compatible
1696 with FreeBSD 4.10 od. */
1698 #define CASE_OLD_ARG(old_char,new_string) \
1700 ok &= decode_format_string (new_string); \
1703 CASE_OLD_ARG ('a', "a");
1704 CASE_OLD_ARG ('b', "o1");
1705 CASE_OLD_ARG ('c', "c");
1706 CASE_OLD_ARG ('D', "u4"); /* obsolescent and undocumented */
1707 CASE_OLD_ARG ('d', "u2");
1708 case 'F': /* obsolescent and undocumented alias */
1709 CASE_OLD_ARG ('e', "fD"); /* obsolescent and undocumented */
1710 CASE_OLD_ARG ('f', "fF");
1711 case 'X': /* obsolescent and undocumented alias */
1712 CASE_OLD_ARG ('H', "x4"); /* obsolescent and undocumented */
1713 CASE_OLD_ARG ('i', "dI");
1714 case 'I': case 'L': /* obsolescent and undocumented aliases */
1715 CASE_OLD_ARG ('l', "dL");
1716 CASE_OLD_ARG ('O', "o4"); /* obsolesent and undocumented */
1717 case 'B': /* obsolescent and undocumented alias */
1718 CASE_OLD_ARG ('o', "o2");
1719 CASE_OLD_ARG ('s', "d2");
1720 case 'h': /* obsolescent and undocumented alias */
1721 CASE_OLD_ARG ('x', "x2");
1727 width_specified = true;
1735 s_err = xstrtoumax (optarg, NULL, 10, &w_tmp, "");
1736 if (s_err != LONGINT_OK)
1737 STRTOL_FATAL_ERROR (optarg, _("width specification"), s_err);
1738 if (SIZE_MAX < w_tmp)
1739 error (EXIT_FAILURE, 0, _("%s is too large"), optarg);
1740 desired_width = w_tmp;
1744 case_GETOPT_HELP_CHAR;
1746 case_GETOPT_VERSION_CHAR (PROGRAM_NAME, AUTHORS);
1749 usage (EXIT_FAILURE);
1755 exit (EXIT_FAILURE);
1757 if (flag_dump_strings && n_specs > 0)
1758 error (EXIT_FAILURE, 0,
1759 _("no type may be specified when dumping strings"));
1761 n_files = argc - optind;
1763 /* If the --traditional option is used, there may be from
1764 0 to 3 remaining command line arguments; handle each case
1766 od [file] [[+]offset[.][b] [[+]label[.][b]]]
1767 The offset and label have the same syntax.
1769 If --traditional is not given, and if no modern options are
1770 given, and if the offset begins with + or (if there are two
1771 operands) a digit, accept only this form, as per POSIX:
1772 od [file] [[+]offset[.][b]]
1775 if (!modern | traditional)
1783 if ((traditional || argv[optind][0] == '+')
1784 && parse_old_offset (argv[optind], &o1))
1786 n_bytes_to_skip = o1;
1793 if ((traditional || argv[optind + 1][0] == '+'
1794 || ISDIGIT (argv[optind + 1][0]))
1795 && parse_old_offset (argv[optind + 1], &o2))
1797 if (traditional && parse_old_offset (argv[optind], &o1))
1799 n_bytes_to_skip = o1;
1800 flag_pseudo_start = true;
1807 n_bytes_to_skip = o2;
1809 argv[optind + 1] = argv[optind];
1817 && parse_old_offset (argv[optind + 1], &o1)
1818 && parse_old_offset (argv[optind + 2], &o2))
1820 n_bytes_to_skip = o1;
1821 flag_pseudo_start = true;
1823 argv[optind + 2] = argv[optind];
1830 if (traditional && 1 < n_files)
1832 error (0, 0, _("extra operand %s"), quote (argv[optind + 1]));
1833 error (0, 0, "%s\n",
1834 _("Compatibility mode supports at most one file."));
1835 usage (EXIT_FAILURE);
1839 if (flag_pseudo_start)
1841 if (format_address == format_address_none)
1844 address_pad_len = 7;
1845 format_address = format_address_paren;
1848 format_address = format_address_label;
1851 if (limit_bytes_to_format)
1853 end_offset = n_bytes_to_skip + max_bytes_to_format;
1854 if (end_offset < n_bytes_to_skip)
1855 error (EXIT_FAILURE, 0, _("skip-bytes + read-bytes is too large"));
1859 decode_format_string ("oS");
1863 /* Set the global pointer FILE_LIST so that it
1864 references the first file-argument on the command-line. */
1866 file_list = (char const *const *) &argv[optind];
1870 /* No files were listed on the command line.
1871 Set the global pointer FILE_LIST so that it
1872 references the null-terminated list of one name: "-". */
1874 file_list = default_file_list;
1877 /* open the first input file */
1878 ok = open_next_file ();
1879 if (in_stream == NULL)
1882 /* skip over any unwanted header bytes */
1883 ok &= skip (n_bytes_to_skip);
1884 if (in_stream == NULL)
1887 pseudo_offset = (flag_pseudo_start ? pseudo_start - n_bytes_to_skip : 0);
1889 /* Compute output block length. */
1892 if (width_specified)
1894 if (desired_width != 0 && desired_width % l_c_m == 0)
1895 bytes_per_block = desired_width;
1898 error (0, 0, _("warning: invalid width %lu; using %d instead"),
1899 (unsigned long int) desired_width, l_c_m);
1900 bytes_per_block = l_c_m;
1905 if (l_c_m < DEFAULT_BYTES_PER_BLOCK)
1906 bytes_per_block = l_c_m * (DEFAULT_BYTES_PER_BLOCK / l_c_m);
1908 bytes_per_block = l_c_m;
1912 for (i = 0; i < n_specs; i++)
1914 printf (_("%d: fmt=\"%s\" width=%d\n"),
1915 i, spec[i].fmt_string, width_bytes[spec[i].size]);
1919 ok &= (flag_dump_strings ? dump_strings () : dump ());
1923 if (have_read_stdin && fclose (stdin) == EOF)
1924 error (EXIT_FAILURE, errno, _("standard input"));
1926 exit (ok ? EXIT_SUCCESS : EXIT_FAILURE);