1 /* od -- dump files in octal and other formats
2 Copyright (C) 92, 1995-1999 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>
28 #include "long-options.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;
51 # define MAX(a, b) ((a) > (b) ? (a) : (b))
55 # define MIN(a,b) (((a) < (b)) ? (a) : (b))
58 /* The default number of input bytes per output line. */
59 #define DEFAULT_BYTES_PER_BLOCK 16
61 /* The number of decimal digits of precision in a float. */
66 /* The number of decimal digits of precision in a double. */
71 /* The number of decimal digits of precision in a long double. */
73 # define LDBL_DIG DBL_DIG
78 # define fseeko(Stream, Offset, Whence) (-1)
104 /* Each output format specification (from POSIX `-t spec' or from
105 old-style options) is represented by one of these structures. */
108 enum output_format fmt;
110 void (*print_function) ();
112 int hexl_mode_trailer;
116 /* The name this program was run with. */
119 /* Convert the number of 8-bit bytes of a binary representation to
120 the number of characters (digits + sign if the type is signed)
121 required to represent the same quantity in the specified base/type.
122 For example, a 32-bit (4-byte) quantity may require a field width
123 as wide as the following for these types:
127 8 unsigned hexadecimal */
129 static const unsigned int bytes_to_oct_digits[] =
130 {0, 3, 6, 8, 11, 14, 16, 19, 22, 25, 27, 30, 32, 35, 38, 41, 43};
132 static const unsigned int bytes_to_signed_dec_digits[] =
133 {1, 4, 6, 8, 11, 13, 16, 18, 20, 23, 25, 28, 30, 33, 35, 37, 40};
135 static const unsigned int bytes_to_unsigned_dec_digits[] =
136 {0, 3, 5, 8, 10, 13, 15, 17, 20, 22, 25, 27, 29, 32, 34, 37, 39};
138 static const unsigned int bytes_to_hex_digits[] =
139 {0, 2, 4, 6, 8, 10, 12, 14, 16, 18, 20, 22, 24, 26, 28, 30, 32};
141 /* Convert enum size_spec to the size of the named type. */
142 static const int width_bytes[] =
154 /* Names for some non-printing characters. */
155 static const char *const charname[33] =
157 "nul", "soh", "stx", "etx", "eot", "enq", "ack", "bel",
158 "bs", "ht", "nl", "vt", "ff", "cr", "so", "si",
159 "dle", "dc1", "dc2", "dc3", "dc4", "nak", "syn", "etb",
160 "can", "em", "sub", "esc", "fs", "gs", "rs", "us",
164 /* A printf control string for printing a file offset. */
165 static const char *output_address_fmt_string;
167 /* FIXME: make this the number of octal digits in an unsigned long. */
168 #define MAX_ADDRESS_LENGTH 13
170 /* Space for a normal address, a space, a pseudo address, parentheses
171 around the pseudo address, and a trailing zero byte. */
172 static char address_fmt_buffer[2 * MAX_ADDRESS_LENGTH + 4];
173 static char address_pad[MAX_ADDRESS_LENGTH + 1];
175 static unsigned long int string_min;
176 static unsigned long int flag_dump_strings;
178 /* Non-zero if we should recognize the pre-POSIX non-option arguments
179 that specified at most one file and optional arguments specifying
180 offset and pseudo-start address. */
181 static int traditional;
183 /* Non-zero if an old-style `pseudo-address' was specified. */
184 static long int flag_pseudo_start;
186 /* The difference between the old-style pseudo starting address and
187 the number of bytes to skip. */
188 static long int pseudo_offset;
190 /* Function to format an address and optionally an additional parenthesized
191 pseudo-address; it returns the formatted string. */
192 static const char *(*format_address) PARAMS ((long unsigned int));
194 /* The number of input bytes to skip before formatting and writing. */
195 static off_t n_bytes_to_skip = 0;
197 /* When nonzero, MAX_BYTES_TO_FORMAT is the maximum number of bytes
198 to be read and formatted. Otherwise all input is formatted. */
199 static int limit_bytes_to_format = 0;
201 /* The maximum number of bytes that will be formatted. This
202 value is used only when LIMIT_BYTES_TO_FORMAT is nonzero. */
203 static off_t max_bytes_to_format;
205 /* When nonzero and two or more consecutive blocks are equal, format
206 only the first block and output an asterisk alone on the following
207 line to indicate that identical blocks have been elided. */
208 static int abbreviate_duplicate_blocks = 1;
210 /* An array of specs describing how to format each input block. */
211 static struct tspec *spec;
213 /* The number of format specs. */
214 static unsigned int n_specs;
216 /* The allocated length of SPEC. */
217 static unsigned int n_specs_allocated;
219 /* The number of input bytes formatted per output line. It must be
220 a multiple of the least common multiple of the sizes associated with
221 the specified output types. It should be as large as possible, but
222 no larger than 16 -- unless specified with the -w option. */
223 static unsigned int bytes_per_block;
225 /* Human-readable representation of *file_list (for error messages).
226 It differs from *file_list only when *file_list is "-". */
227 static char const *input_filename;
229 /* A NULL-terminated list of the file-arguments from the command line.
230 If no file-arguments were specified, this variable is initialized
232 static char const *const *file_list;
234 /* The input stream associated with the current file. */
235 static FILE *in_stream;
237 /* If nonzero, at least one of the files we read was standard input. */
238 static int have_read_stdin;
240 #define LONGEST_INTEGRAL_TYPE long int
242 #define MAX_INTEGRAL_TYPE_SIZE sizeof(LONGEST_INTEGRAL_TYPE)
243 static enum size_spec integral_type_size[MAX_INTEGRAL_TYPE_SIZE + 1];
245 #define MAX_FP_TYPE_SIZE sizeof(LONG_DOUBLE)
246 static enum size_spec fp_type_size[MAX_FP_TYPE_SIZE + 1];
248 static struct option const long_options[] =
251 {"skip-bytes", required_argument, NULL, 'j'},
252 {"address-radix", required_argument, NULL, 'A'},
253 {"read-bytes", required_argument, NULL, 'N'},
254 {"format", required_argument, NULL, 't'},
255 {"output-duplicates", no_argument, NULL, 'v'},
257 /* non-POSIX options. */
258 {"strings", optional_argument, NULL, 's'},
259 {"traditional", no_argument, NULL, 'B'},
260 {"width", optional_argument, NULL, 'w'},
268 fprintf (stderr, _("Try `%s --help' for more information.\n"),
273 Usage: %s [OPTION]... [FILE]...\n\
274 or: %s --traditional [FILE] [[+]OFFSET [[+]LABEL]]\n\
276 program_name, program_name);
278 Write an unambiguous representation, octal bytes by default, of FILE\n\
279 to standard output. With no FILE, or when FILE is -, read standard input.\n\
281 -A, --address-radix=RADIX decide how file offsets are printed\n\
282 -j, --skip-bytes=BYTES skip BYTES input bytes first on each file\n\
283 -N, --read-bytes=BYTES limit dump to BYTES input bytes per file\n\
284 -s, --strings[=BYTES] output strings of at least BYTES graphic chars\n\
285 -t, --format=TYPE select output format or formats\n\
286 -v, --output-duplicates do not use * to mark line suppression\n\
287 -w, --width[=BYTES] output BYTES bytes per output line\n\
288 --traditional accept arguments in pre-POSIX form\n\
289 --help display this help and exit\n\
290 --version output version information and exit\n\
292 Pre-POSIX format specifications may be intermixed, they accumulate:\n\
293 -a same as -t a, select named characters\n\
294 -b same as -t oC, select octal bytes\n\
295 -c same as -t c, select ASCII characters or backslash escapes\n\
296 -d same as -t u2, select unsigned decimal shorts\n\
297 -f same as -t fF, select floats\n\
298 -h same as -t x2, select hexadecimal shorts\n\
299 -i same as -t d2, select decimal shorts\n\
300 -l same as -t d4, select decimal longs\n\
301 -o same as -t o2, select octal shorts\n\
302 -x same as -t x2, select hexadecimal shorts\n\
306 For older syntax (second call format), OFFSET means -j OFFSET. LABEL\n\
307 is the pseudo-address at first byte printed, incremented when dump is\n\
308 progressing. For OFFSET and LABEL, a 0x or 0X prefix indicates\n\
309 hexadecimal, suffixes maybe . for octal and b multiply by 512.\n\
311 TYPE is made up of one or more of these specifications:\n\
314 c ASCII character or backslash escape\n\
315 d[SIZE] signed decimal, SIZE bytes per integer\n\
316 f[SIZE] floating point, SIZE bytes per integer\n\
317 o[SIZE] octal, SIZE bytes per integer\n\
318 u[SIZE] unsigned decimal, SIZE bytes per integer\n\
319 x[SIZE] hexadecimal, SIZE bytes per integer\n\
321 SIZE is a number. For TYPE in doux, SIZE may also be C for\n\
322 sizeof(char), S for sizeof(short), I for sizeof(int) or L for\n\
323 sizeof(long). If TYPE is f, SIZE may also be F for sizeof(float), D\n\
324 for sizeof(double) or L for sizeof(long double).\n\
326 RADIX is d for decimal, o for octal, x for hexadecimal or n for none.\n\
327 BYTES is hexadecimal with 0x or 0X prefix, it is multiplied by 512\n\
328 with b suffix, by 1024 with k and by 1048576 with m. Adding a z suffix to\n\
329 any type adds a display of printable characters to the end of each line\n\
330 of output. -s without a number implies 3. -w without a number implies 32.\n\
331 By default, od uses -A o -t d2 -w 16.\n\
333 puts (_("\nReport bugs to <bug-textutils@gnu.org>."));
335 exit (status == 0 ? EXIT_SUCCESS : EXIT_FAILURE);
338 /* Compute the greatest common denominator of U and V
339 using Euclid's algorithm. */
342 gcd (unsigned int u, unsigned int v)
354 /* Compute the least common multiple of U and V. */
357 lcm (unsigned int u, unsigned int v)
359 unsigned int t = gcd (u, v);
366 print_s_char (long unsigned int n_bytes, const char *block,
367 const char *fmt_string)
370 for (i = n_bytes; i > 0; i--)
372 int tmp = (unsigned) *(const unsigned char *) block;
374 tmp -= SCHAR_MAX - SCHAR_MIN + 1;
375 assert (tmp <= SCHAR_MAX);
376 printf (fmt_string, tmp);
377 block += sizeof (unsigned char);
382 print_char (long unsigned int n_bytes, const char *block,
383 const char *fmt_string)
386 for (i = n_bytes; i > 0; i--)
388 unsigned int tmp = *(const unsigned char *) block;
389 printf (fmt_string, tmp);
390 block += sizeof (unsigned char);
395 print_s_short (long unsigned int n_bytes, const char *block,
396 const char *fmt_string)
399 for (i = n_bytes / sizeof (unsigned short); i > 0; i--)
401 int tmp = (unsigned) *(const unsigned short *) block;
403 tmp -= SHRT_MAX - SHRT_MIN + 1;
404 assert (tmp <= SHRT_MAX);
405 printf (fmt_string, tmp);
406 block += sizeof (unsigned short);
411 print_short (long unsigned int n_bytes, const char *block,
412 const char *fmt_string)
415 for (i = n_bytes / sizeof (unsigned short); i > 0; i--)
417 unsigned int tmp = *(const unsigned short *) block;
418 printf (fmt_string, tmp);
419 block += sizeof (unsigned short);
424 print_int (long unsigned int n_bytes, const char *block,
425 const char *fmt_string)
428 for (i = n_bytes / sizeof (unsigned int); i > 0; i--)
430 unsigned int tmp = *(const unsigned int *) block;
431 printf (fmt_string, tmp);
432 block += sizeof (unsigned int);
437 print_long (long unsigned int n_bytes, const char *block,
438 const char *fmt_string)
441 for (i = n_bytes / sizeof (unsigned long); i > 0; i--)
443 unsigned long tmp = *(const unsigned long *) block;
444 printf (fmt_string, tmp);
445 block += sizeof (unsigned long);
450 print_float (long unsigned int n_bytes, const char *block,
451 const char *fmt_string)
454 for (i = n_bytes / sizeof (float); i > 0; i--)
456 float tmp = *(const float *) block;
457 printf (fmt_string, tmp);
458 block += sizeof (float);
463 print_double (long unsigned int n_bytes, const char *block,
464 const char *fmt_string)
467 for (i = n_bytes / sizeof (double); i > 0; i--)
469 double tmp = *(const double *) block;
470 printf (fmt_string, tmp);
471 block += sizeof (double);
475 #ifdef HAVE_LONG_DOUBLE
477 print_long_double (long unsigned int n_bytes, const char *block,
478 const char *fmt_string)
481 for (i = n_bytes / sizeof (LONG_DOUBLE); i > 0; i--)
483 LONG_DOUBLE tmp = *(const LONG_DOUBLE *) block;
484 printf (fmt_string, tmp);
485 block += sizeof (LONG_DOUBLE);
492 dump_hexl_mode_trailer (long unsigned int n_bytes, const char *block)
495 fputs (" >", stdout);
496 for (i = n_bytes; i > 0; i--)
498 unsigned int c = *(const unsigned char *) block;
499 unsigned int c2 = (ISPRINT(c) ? c : '.');
501 block += sizeof (unsigned char);
507 print_named_ascii (long unsigned int n_bytes, const char *block,
508 const char *unused_fmt_string)
511 for (i = n_bytes; i > 0; i--)
513 unsigned int c = *(const unsigned char *) block;
514 unsigned int masked_c = (0x7f & c);
520 else if (masked_c <= 040)
521 s = charname[masked_c];
524 sprintf (buf, " %c", masked_c);
529 block += sizeof (unsigned char);
534 print_ascii (long unsigned int n_bytes, const char *block,
535 const char *unused_fmt_string)
538 for (i = n_bytes; i > 0; i--)
540 unsigned int c = *(const unsigned char *) block;
579 sprintf (buf, (ISPRINT (c) ? " %c" : "%03o"), c);
580 s = (const char *) buf;
584 block += sizeof (unsigned char);
588 /* Convert a null-terminated (possibly zero-length) string S to an
589 unsigned long integer value. If S points to a non-digit set *P to S,
590 *VAL to 0, and return 0. Otherwise, accumulate the integer value of
591 the string of digits. If the string of digits represents a value
592 larger than ULONG_MAX, don't modify *VAL or *P and return nonzero.
593 Otherwise, advance *P to the first non-digit after S, set *VAL to
594 the result of the conversion and return zero. */
597 simple_strtoul (const char *s, const char **p, long unsigned int *val)
599 unsigned long int sum;
604 unsigned int c = *s++ - '0';
605 if (sum > (ULONG_MAX - c) / 10)
614 /* If S points to a single valid POSIX-style od format string, put
615 a description of that format in *TSPEC, make *NEXT point at the
616 character following the just-decoded format (if *NEXT is non-NULL),
617 and return zero. If S is not valid, don't modify *NEXT or *TSPEC,
618 give a diagnostic, and return nonzero. For example, if S were
619 "d4afL" *NEXT would be set to "afL" and *TSPEC would be
621 fmt = SIGNED_DECIMAL;
622 size = INT or LONG; (whichever integral_type_size[4] resolves to)
623 print_function = print_int; (assuming size == INT)
624 fmt_string = "%011d%c";
626 S_ORIG is solely for reporting errors. It should be the full format
631 decode_one_format (const char *s_orig, const char *s, const char **next,
634 enum size_spec size_spec;
635 unsigned long int size;
636 enum output_format fmt;
637 const char *pre_fmt_string;
639 void (*print_function) ();
642 unsigned int field_width = 0;
644 assert (tspec != NULL);
658 size = sizeof (char);
663 size = sizeof (short);
673 size = sizeof (long int);
677 if (simple_strtoul (s, &p, &size) != 0)
679 /* The integer at P in S would overflow an unsigned long.
680 A digit string that long is sufficiently odd looking
681 that the following diagnostic is sufficient. */
682 error (0, 0, _("invalid type string `%s'"), s_orig);
689 if (size > MAX_INTEGRAL_TYPE_SIZE
690 || integral_type_size[size] == NO_SIZE)
692 error (0, 0, _("invalid type string `%s';\n\
693 this system doesn't provide a %lu-byte integral type"), s_orig, size);
701 #define FMT_BYTES_ALLOCATED 9
702 fmt_string = xmalloc (FMT_BYTES_ALLOCATED);
704 size_spec = integral_type_size[size];
709 fmt = SIGNED_DECIMAL;
710 sprintf (fmt_string, " %%%u%sd",
711 (field_width = bytes_to_signed_dec_digits[size]),
712 (size_spec == LONG ? "l" : ""));
717 sprintf (fmt_string, " %%0%u%so",
718 (field_width = bytes_to_oct_digits[size]),
719 (size_spec == LONG ? "l" : ""));
723 fmt = UNSIGNED_DECIMAL;
724 sprintf (fmt_string, " %%%u%su",
725 (field_width = bytes_to_unsigned_dec_digits[size]),
726 (size_spec == LONG ? "l" : ""));
731 sprintf (fmt_string, " %%0%u%sx",
732 (field_width = bytes_to_hex_digits[size]),
733 (size_spec == LONG ? "l" : ""));
740 assert (strlen (fmt_string) < FMT_BYTES_ALLOCATED);
745 print_function = (fmt == SIGNED_DECIMAL
751 print_function = (fmt == SIGNED_DECIMAL
757 print_function = print_int;
761 print_function = print_long;
770 fmt = FLOATING_POINT;
776 size = sizeof (float);
781 size = sizeof (double);
786 size = sizeof (LONG_DOUBLE);
790 if (simple_strtoul (s, &p, &size) != 0)
792 /* The integer at P in S would overflow an unsigned long.
793 A digit string that long is sufficiently odd looking
794 that the following diagnostic is sufficient. */
795 error (0, 0, _("invalid type string `%s'"), s_orig);
799 size = sizeof (double);
802 if (size > MAX_FP_TYPE_SIZE
803 || fp_type_size[size] == NO_SIZE)
805 error (0, 0, _("invalid type string `%s';\n\
806 this system doesn't provide a %lu-byte floating point type"), s_orig, size);
813 size_spec = fp_type_size[size];
818 print_function = print_float;
819 /* Don't use %#e; not all systems support it. */
820 pre_fmt_string = " %%%d.%de";
821 fmt_string = xmalloc (strlen (pre_fmt_string));
822 sprintf (fmt_string, pre_fmt_string,
823 (field_width = FLT_DIG + 8), FLT_DIG);
827 print_function = print_double;
828 pre_fmt_string = " %%%d.%de";
829 fmt_string = xmalloc (strlen (pre_fmt_string));
830 sprintf (fmt_string, pre_fmt_string,
831 (field_width = DBL_DIG + 8), DBL_DIG);
834 #ifdef HAVE_LONG_DOUBLE
835 case FLOAT_LONG_DOUBLE:
836 print_function = print_long_double;
837 pre_fmt_string = " %%%d.%dLe";
838 fmt_string = xmalloc (strlen (pre_fmt_string));
839 sprintf (fmt_string, pre_fmt_string,
840 (field_width = LDBL_DIG + 8), LDBL_DIG);
851 fmt = NAMED_CHARACTER;
854 print_function = print_named_ascii;
863 print_function = print_ascii;
868 error (0, 0, _("invalid character `%c' in type string `%s'"),
873 tspec->size = size_spec;
875 tspec->print_function = print_function;
876 tspec->fmt_string = fmt_string;
878 tspec->field_width = field_width;
879 tspec->hexl_mode_trailer = (*s == 'z');
880 if (tspec->hexl_mode_trailer)
889 /* Decode the POSIX-style od format string S. Append the decoded
890 representation to the global array SPEC, reallocating SPEC if
891 necessary. Return zero if S is valid, nonzero otherwise. */
894 decode_format_string (const char *s)
896 const char *s_orig = s;
904 if (decode_one_format (s_orig, s, &next, &tspec))
910 if (n_specs >= n_specs_allocated)
912 n_specs_allocated = 1 + (3 * n_specs_allocated) / 2;
913 spec = (struct tspec *) xrealloc ((char *) spec,
915 * sizeof (struct tspec)));
918 memcpy ((char *) &spec[n_specs], (char *) &tspec,
919 sizeof (struct tspec));
926 /* Given a list of one or more input filenames FILE_LIST, set the global
927 file pointer IN_STREAM to position N_SKIP in the concatenation of
928 those files. If any file operation fails or if there are fewer than
929 N_SKIP bytes in the combined input, give an error message and return
930 nonzero. When possible, use seek- rather than read operations to
931 advance IN_STREAM. A file name of "-" is interpreted as standard
940 for ( /* empty */ ; *file_list != NULL; ++file_list)
942 struct stat file_stats;
945 if (STREQ (*file_list, "-"))
947 input_filename = _("standard input");
953 input_filename = *file_list;
954 in_stream = fopen (input_filename, "r");
955 if (in_stream == NULL)
957 error (0, errno, "%s", input_filename);
962 SET_BINARY (fileno (in_stream));
967 /* First try using fseek. For large offsets, this extra work is
968 worthwhile. If the offset is below some threshold it may be
969 more efficient to move the pointer by reading. There are two
970 issues when trying to use fseek:
971 - the file must be seekable.
972 - before seeking to the specified position, make sure
973 that the new position is in the current file.
974 Try to do that by getting file's size using fstat().
975 But that will work only for regular files and dirs. */
977 if (fstat (fileno (in_stream), &file_stats))
979 error (0, errno, "%s", input_filename);
984 /* The st_size field is valid only for regular files and
985 directories. FIXME: is the preceding true?
986 If the number of bytes left to skip is at least as large as
987 the size of the current file, we can decrement
988 n_skip and go on to the next file. */
989 if (S_ISREG (file_stats.st_mode) || S_ISDIR (file_stats.st_mode))
991 if (n_skip >= file_stats.st_size)
993 n_skip -= file_stats.st_size;
994 if (in_stream != stdin && fclose (in_stream) == EOF)
996 error (0, errno, "%s", input_filename);
1003 /* Try fseeko if available, fseek otherwise. */
1004 if (fseeko (in_stream, n_skip, SEEK_SET) == 0
1005 || (n_skip <= LONG_MAX
1006 && fseek (in_stream, (long) n_skip, SEEK_SET) == 0))
1014 /* Seek didn't work or wasn't attempted; position the file pointer
1017 for (j = n_skip / BUFSIZ; j >= 0; j--)
1020 size_t n_bytes_to_read = (j > 0
1023 size_t n_bytes_read;
1024 n_bytes_read = fread (buf, 1, n_bytes_to_read, in_stream);
1025 n_skip -= n_bytes_read;
1026 if (n_bytes_read != n_bytes_to_read)
1035 error (EXIT_FAILURE, 0, _("cannot skip past end of combined input"));
1041 format_address_none (long unsigned int address)
1047 format_address_std (long unsigned int address)
1049 const char *address_string;
1051 sprintf (address_fmt_buffer, output_address_fmt_string, address);
1052 address_string = address_fmt_buffer;
1053 return address_string;
1057 format_address_label (long unsigned int address)
1059 const char *address_string;
1060 assert (output_address_fmt_string != NULL);
1062 sprintf (address_fmt_buffer, output_address_fmt_string,
1063 address, address + pseudo_offset);
1064 address_string = address_fmt_buffer;
1065 return address_string;
1068 /* Write N_BYTES bytes from CURR_BLOCK to standard output once for each
1069 of the N_SPEC format specs. CURRENT_OFFSET is the byte address of
1070 CURR_BLOCK in the concatenation of input files, and it is printed
1071 (optionally) only before the output line associated with the first
1072 format spec. When duplicate blocks are being abbreviated, the output
1073 for a sequence of identical input blocks is the output for the first
1074 block followed by an asterisk alone on a line. It is valid to compare
1075 the blocks PREV_BLOCK and CURR_BLOCK only when N_BYTES == BYTES_PER_BLOCK.
1076 That condition may be false only for the last input block -- and then
1077 only when it has not been padded to length BYTES_PER_BLOCK. */
1080 write_block (long unsigned int current_offset, long unsigned int n_bytes,
1081 const char *prev_block, const char *curr_block)
1083 static int first = 1;
1084 static int prev_pair_equal = 0;
1086 #define EQUAL_BLOCKS(b1, b2) (memcmp ((b1), (b2), bytes_per_block) == 0)
1088 if (abbreviate_duplicate_blocks
1089 && !first && n_bytes == bytes_per_block
1090 && EQUAL_BLOCKS (prev_block, curr_block))
1092 if (prev_pair_equal)
1094 /* The two preceding blocks were equal, and the current
1095 block is the same as the last one, so print nothing. */
1100 prev_pair_equal = 1;
1107 prev_pair_equal = 0;
1108 for (i = 0; i < n_specs; i++)
1110 const char *addr_or_pad = (i == 0
1111 ? format_address (current_offset)
1114 fputs (addr_or_pad, stdout);
1115 (*spec[i].print_function) (n_bytes, curr_block, spec[i].fmt_string);
1116 if (spec[i].hexl_mode_trailer)
1118 /* space-pad out to full line width, then dump the trailer */
1119 int datum_width = width_bytes[spec[i].size];
1120 int blank_fields = (bytes_per_block - n_bytes) / datum_width;
1121 int field_width = spec[i].field_width + 1;
1122 printf ("%*s", blank_fields * field_width, "");
1123 dump_hexl_mode_trailer (n_bytes, curr_block);
1131 /* Test whether there have been errors on in_stream, and close it if
1132 it is not standard input. Return nonzero if there has been an error
1133 on in_stream or stdout; return zero otherwise. This function will
1134 report more than one error only if both a read and a write error
1138 check_and_close (void)
1143 if (ferror (in_stream))
1145 error (0, errno, "%s", input_filename);
1146 if (in_stream != stdin)
1150 else if (in_stream != stdin && fclose (in_stream) == EOF)
1152 error (0, errno, "%s", input_filename);
1156 if (ferror (stdout))
1158 error (0, errno, _("standard output"));
1165 /* Read a single byte into *C from the concatenation of the input files
1166 named in the global array FILE_LIST. On the first call to this
1167 function, the global variable IN_STREAM is expected to be an open
1168 stream associated with the input file *FILE_LIST. If IN_STREAM is
1169 at end-of-file, close it and update the global variables IN_STREAM,
1170 FILE_LIST, and INPUT_FILENAME so they correspond to the next file in
1171 the list. Then try to read a byte from the newly opened file.
1172 Repeat if necessary until *FILE_LIST is NULL. When EOF is reached
1173 for the last file in FILE_LIST, set *C to EOF and return. Subsequent
1174 calls do likewise. The return value is nonzero if any errors
1175 occured, zero otherwise. */
1182 if (*file_list == NULL)
1191 *c = fgetc (in_stream);
1196 err |= check_and_close ();
1201 if (*file_list == NULL)
1204 if (STREQ (*file_list, "-"))
1206 input_filename = _("standard input");
1208 have_read_stdin = 1;
1212 input_filename = *file_list;
1213 in_stream = fopen (input_filename, "r");
1214 if (in_stream == NULL)
1216 error (0, errno, "%s", input_filename);
1220 SET_BINARY (fileno (in_stream));
1222 while (in_stream == NULL);
1226 /* Read N bytes into BLOCK from the concatenation of the input files
1227 named in the global array FILE_LIST. On the first call to this
1228 function, the global variable IN_STREAM is expected to be an open
1229 stream associated with the input file *FILE_LIST. On subsequent
1230 calls, if *FILE_LIST is NULL, don't modify BLOCK and return zero.
1231 If all N bytes cannot be read from IN_STREAM, close IN_STREAM and
1232 update the global variables IN_STREAM, FILE_LIST, and INPUT_FILENAME.
1233 Then try to read the remaining bytes from the newly opened file.
1234 Repeat if necessary until *FILE_LIST is NULL. Set *N_BYTES_IN_BUFFER
1235 to the number of bytes read. If an error occurs, it will be detected
1236 through ferror when the stream is about to be closed. If there is an
1237 error, give a message but continue reading as usual and return nonzero.
1238 Otherwise return zero. */
1241 read_block (size_t n, char *block, size_t *n_bytes_in_buffer)
1245 assert (n > 0 && n <= bytes_per_block);
1247 *n_bytes_in_buffer = 0;
1252 if (*file_list == NULL)
1253 return 0; /* EOF. */
1261 n_needed = n - *n_bytes_in_buffer;
1262 n_read = fread (block + *n_bytes_in_buffer, 1, n_needed, in_stream);
1264 *n_bytes_in_buffer += n_read;
1266 if (n_read == n_needed)
1269 err |= check_and_close ();
1274 if (*file_list == NULL)
1277 if (STREQ (*file_list, "-"))
1279 input_filename = _("standard input");
1281 have_read_stdin = 1;
1285 input_filename = *file_list;
1286 in_stream = fopen (input_filename, "r");
1287 if (in_stream == NULL)
1289 error (0, errno, "%s", input_filename);
1293 SET_BINARY (fileno (in_stream));
1295 while (in_stream == NULL);
1299 /* Return the least common multiple of the sizes associated
1300 with the format specs. */
1308 for (i = 0; i < n_specs; i++)
1309 l_c_m = lcm (l_c_m, width_bytes[(int) spec[i].size]);
1313 /* If S is a valid pre-POSIX offset specification with an optional leading '+'
1314 return the offset it denotes. Otherwise, return -1. */
1317 parse_old_offset (const char *s)
1321 enum strtol_error s_err;
1322 long unsigned int tmp;
1327 /* Skip over any leading '+'. */
1331 /* Determine the radix we'll use to interpret S. If there is a `.',
1332 it's decimal, otherwise, if the string begins with `0X'or `0x',
1333 it's hexadecimal, else octal. */
1334 if (strchr (s, '.') != NULL)
1338 if (s[0] == '0' && (s[1] == 'x' || s[1] == 'X'))
1344 s_err = xstrtoul (s, NULL, radix, &tmp, "Bb");
1345 if (s_err != LONGINT_OK)
1347 STRTOL_FAIL_WARN (s, _("old-style offset"), s_err);
1354 /* Read a chunk of size BYTES_PER_BLOCK from the input files, write the
1355 formatted block to standard output, and repeat until the specified
1356 maximum number of bytes has been read or until all input has been
1357 processed. If the last block read is smaller than BYTES_PER_BLOCK
1358 and its size is not a multiple of the size associated with a format
1359 spec, extend the input block with zero bytes until its length is a
1360 multiple of all format spec sizes. Write the final block. Finally,
1361 write on a line by itself the offset of the byte after the last byte
1362 read. Accumulate return values from calls to read_block and
1363 check_and_close, and if any was nonzero, return nonzero.
1364 Otherwise, return zero. */
1370 off_t current_offset;
1374 size_t n_bytes_read;
1376 #ifdef lint /* Suppress `used before initialized' warning. */
1380 block[0] = (char *) alloca (bytes_per_block);
1381 block[1] = (char *) alloca (bytes_per_block);
1383 current_offset = n_bytes_to_skip;
1387 if (limit_bytes_to_format)
1389 end_offset = n_bytes_to_skip + max_bytes_to_format;
1394 if (current_offset >= end_offset)
1399 n_needed = MIN (end_offset - current_offset,
1400 (off_t) bytes_per_block);
1401 err |= read_block (n_needed, block[idx], &n_bytes_read);
1402 if (n_bytes_read < bytes_per_block)
1404 assert (n_bytes_read == bytes_per_block);
1405 write_block (current_offset, n_bytes_read,
1406 block[!idx], block[idx]);
1407 current_offset += n_bytes_read;
1415 err |= read_block (bytes_per_block, block[idx], &n_bytes_read);
1416 if (n_bytes_read < bytes_per_block)
1418 assert (n_bytes_read == bytes_per_block);
1419 write_block (current_offset, n_bytes_read,
1420 block[!idx], block[idx]);
1421 current_offset += n_bytes_read;
1426 if (n_bytes_read > 0)
1429 size_t bytes_to_write;
1433 /* Make bytes_to_write the smallest multiple of l_c_m that
1434 is at least as large as n_bytes_read. */
1435 bytes_to_write = l_c_m * (int) ((n_bytes_read + l_c_m - 1) / l_c_m);
1437 memset (block[idx] + n_bytes_read, 0, bytes_to_write - n_bytes_read);
1438 write_block (current_offset, bytes_to_write,
1439 block[!idx], block[idx]);
1440 current_offset += n_bytes_read;
1443 if (output_address_fmt_string != NULL)
1444 printf ("%s\n", format_address (current_offset));
1446 if (limit_bytes_to_format && current_offset > end_offset)
1447 err |= check_and_close ();
1452 /* STRINGS mode. Find each "string constant" in the input.
1453 A string constant is a run of at least `string_min' ASCII
1454 graphic (or formatting) characters terminated by a null.
1455 Based on a function written by Richard Stallman for a
1456 pre-POSIX version of od. Return nonzero if an error
1457 occurs. Otherwise, return zero. */
1462 size_t bufsize = MAX (100, string_min);
1463 char *buf = xmalloc (bufsize);
1464 off_t address = n_bytes_to_skip;
1473 /* See if the next `string_min' chars are all printing chars. */
1476 if (limit_bytes_to_format
1477 && address >= (n_bytes_to_skip + max_bytes_to_format -
1478 (off_t) string_min))
1481 for (i = 0; i < string_min; i++)
1483 err |= read_char (&c);
1491 /* Found a non-printing. Try again starting with next char. */
1496 /* We found a run of `string_min' printable characters.
1497 Now see if it is terminated with a null byte. */
1498 while (!limit_bytes_to_format
1499 || address < n_bytes_to_skip + max_bytes_to_format)
1503 bufsize = 1 + 3 * bufsize / 2;
1504 buf = xrealloc (buf, bufsize);
1506 err |= read_char (&c);
1514 break; /* It is; print this string. */
1516 goto tryline; /* It isn't; give up on this string. */
1517 buf[i++] = c; /* String continues; store it all. */
1520 /* If we get here, the string is all printable and null-terminated,
1521 so print it. It is all in `buf' and `i' is its length. */
1523 if (output_address_fmt_string != NULL)
1525 printf ("%s ", format_address (address - i - 1));
1527 for (i = 0; (c = buf[i]); i++)
1532 fputs ("\\a", stdout);
1536 fputs ("\\b", stdout);
1540 fputs ("\\f", stdout);
1544 fputs ("\\n", stdout);
1548 fputs ("\\r", stdout);
1552 fputs ("\\t", stdout);
1556 fputs ("\\v", stdout);
1566 /* We reach this point only if we search through
1567 (max_bytes_to_format - string_min) bytes before reachine EOF. */
1571 err |= check_and_close ();
1576 main (int argc, char **argv)
1582 unsigned int address_pad_len;
1583 unsigned long int desired_width;
1584 int width_specified = 0;
1585 int n_failed_decodes = 0;
1588 /* The old-style `pseudo starting address' to be printed in parentheses
1589 after any true address. */
1590 long int pseudo_start;
1592 #ifdef lint /* Suppress `used before initialized' warning. */
1596 program_name = argv[0];
1597 setlocale (LC_ALL, "");
1598 bindtextdomain (PACKAGE, LOCALEDIR);
1599 textdomain (PACKAGE);
1601 parse_long_options (argc, argv, PROGRAM_NAME, GNU_PACKAGE, VERSION,
1602 "Jim Meyering", usage);
1606 for (i = 0; i <= MAX_INTEGRAL_TYPE_SIZE; i++)
1607 integral_type_size[i] = NO_SIZE;
1609 integral_type_size[sizeof (char)] = CHAR;
1610 integral_type_size[sizeof (short int)] = SHORT;
1611 integral_type_size[sizeof (int)] = INT;
1612 integral_type_size[sizeof (long int)] = LONG;
1614 for (i = 0; i <= MAX_FP_TYPE_SIZE; i++)
1615 fp_type_size[i] = NO_SIZE;
1617 fp_type_size[sizeof (float)] = FLOAT_SINGLE;
1618 /* The array entry for `double' is filled in after that for LONG_DOUBLE
1619 so that if `long double' is the same type or if long double isn't
1620 supported FLOAT_LONG_DOUBLE will never be used. */
1621 fp_type_size[sizeof (LONG_DOUBLE)] = FLOAT_LONG_DOUBLE;
1622 fp_type_size[sizeof (double)] = FLOAT_DOUBLE;
1625 n_specs_allocated = 5;
1626 spec = (struct tspec *) xmalloc (n_specs_allocated * sizeof (struct tspec));
1628 output_address_fmt_string = "%07o";
1629 format_address = format_address_std;
1630 address_pad_len = 7;
1631 flag_dump_strings = 0;
1633 while ((c = getopt_long (argc, argv, "abcdfhilos::xw::A:j:N:t:v",
1634 long_options, NULL)) != -1)
1636 unsigned long int tmp;
1637 enum strtol_error s_err;
1648 output_address_fmt_string = "%07d";
1649 format_address = format_address_std;
1650 address_pad_len = 7;
1653 output_address_fmt_string = "%07o";
1654 format_address = format_address_std;
1655 address_pad_len = 7;
1658 output_address_fmt_string = "%06x";
1659 format_address = format_address_std;
1660 address_pad_len = 6;
1663 output_address_fmt_string = NULL;
1664 format_address = format_address_none;
1665 address_pad_len = 0;
1668 error (EXIT_FAILURE, 0,
1669 _("invalid output address radix `%c'; \
1670 it must be one character from [doxn]"),
1677 s_err = xstrtoul (optarg, NULL, 0, &tmp, "bkm");
1678 n_bytes_to_skip = tmp;
1679 if (s_err != LONGINT_OK)
1680 STRTOL_FATAL_ERROR (optarg, _("skip argument"), s_err);
1684 limit_bytes_to_format = 1;
1686 /* FIXME: if off_t is long long and that's an 8-byte type,
1687 use xstrtouq here. */
1688 s_err = xstrtoul (optarg, NULL, 0, &tmp, "bkm");
1689 max_bytes_to_format = tmp;
1690 if (s_err != LONGINT_OK)
1691 STRTOL_FATAL_ERROR (optarg, _("limit argument"), s_err);
1694 error (EXIT_FAILURE, 0,
1695 _("specified number of bytes `%s' is larger than \
1696 the maximum\nrepresentable value of type `long'"), optarg);
1704 s_err = xstrtoul (optarg, NULL, 0, &string_min, "bkm");
1705 if (s_err != LONGINT_OK)
1706 STRTOL_FATAL_ERROR (optarg, _("minimum string length"), s_err);
1708 ++flag_dump_strings;
1712 if (decode_format_string (optarg))
1717 abbreviate_duplicate_blocks = 0;
1724 /* The next several cases map the old, pre-POSIX format
1725 specification options to the corresponding POSIX format
1726 specs. GNU od accepts any combination of old- and
1727 new-style options. Format specification options accumulate. */
1729 #define CASE_OLD_ARG(old_char,new_string) \
1732 if (decode_format_string (new_string)) \
1733 ++n_failed_decodes; \
1737 CASE_OLD_ARG ('a', "a");
1738 CASE_OLD_ARG ('b', "oC");
1739 CASE_OLD_ARG ('c', "c");
1740 CASE_OLD_ARG ('d', "u2");
1741 CASE_OLD_ARG ('f', "fF");
1742 CASE_OLD_ARG ('h', "x2");
1743 CASE_OLD_ARG ('i', "d2");
1744 CASE_OLD_ARG ('l', "d4");
1745 CASE_OLD_ARG ('o', "o2");
1746 CASE_OLD_ARG ('x', "x2");
1751 width_specified = 1;
1758 s_err = xstrtoul (optarg, NULL, 10, &desired_width, "");
1759 if (s_err != LONGINT_OK)
1760 STRTOL_FATAL_ERROR (optarg, _("width specification"), s_err);
1770 if (n_failed_decodes > 0)
1771 exit (EXIT_FAILURE);
1773 if (flag_dump_strings && n_specs > 0)
1774 error (EXIT_FAILURE, 0,
1775 _("no type may be specified when dumping strings"));
1777 n_files = argc - optind;
1779 /* If the --backward-compatible option is used, there may be from
1780 0 to 3 remaining command line arguments; handle each case
1782 od [file] [[+]offset[.][b] [[+]label[.][b]]]
1783 The offset and pseudo_start have the same syntax. */
1791 if ((offset = parse_old_offset (argv[optind])) >= 0)
1793 n_bytes_to_skip = offset;
1798 else if (n_files == 2)
1801 if ((o1 = parse_old_offset (argv[optind])) >= 0
1802 && (o2 = parse_old_offset (argv[optind + 1])) >= 0)
1804 n_bytes_to_skip = o1;
1805 flag_pseudo_start = 1;
1810 else if ((o2 = parse_old_offset (argv[optind + 1])) >= 0)
1812 n_bytes_to_skip = o2;
1814 argv[optind + 1] = argv[optind];
1820 _("invalid second operand in compatibility mode `%s'"),
1825 else if (n_files == 3)
1828 if ((o1 = parse_old_offset (argv[optind + 1])) >= 0
1829 && (o2 = parse_old_offset (argv[optind + 2])) >= 0)
1831 n_bytes_to_skip = o1;
1832 flag_pseudo_start = 1;
1834 argv[optind + 2] = argv[optind];
1841 _("in compatibility mode, the last two arguments must be offsets"));
1845 else if (n_files > 3)
1848 _("compatibility mode supports at most three arguments"));
1852 if (flag_pseudo_start)
1854 static char buf[10];
1856 if (output_address_fmt_string == NULL)
1858 output_address_fmt_string = "(%07o)";
1859 format_address = format_address_std;
1863 sprintf (buf, "%s (%s)",
1864 output_address_fmt_string,
1865 output_address_fmt_string);
1866 output_address_fmt_string = buf;
1867 format_address = format_address_label;
1872 assert (address_pad_len <= MAX_ADDRESS_LENGTH);
1873 for (i = 0; i < address_pad_len; i++)
1874 address_pad[i] = ' ';
1875 address_pad[address_pad_len] = '\0';
1879 if (decode_one_format ("o2", "o2", NULL, &(spec[0])))
1881 /* This happens on Cray systems that don't have a 2-byte
1883 exit (EXIT_FAILURE);
1890 file_list = (char const *const *) &argv[optind];
1893 /* If no files were listed on the command line, set up the
1894 global array FILE_LIST so that it contains the null-terminated
1895 list of one name: "-". */
1896 static char const *const default_file_list[] = {"-", NULL};
1898 file_list = default_file_list;
1901 err |= skip (n_bytes_to_skip);
1902 if (in_stream == NULL)
1905 pseudo_offset = (flag_pseudo_start ? pseudo_start - n_bytes_to_skip : 0);
1907 /* Compute output block length. */
1910 if (width_specified)
1912 if (desired_width != 0 && desired_width % l_c_m == 0)
1913 bytes_per_block = desired_width;
1916 error (0, 0, _("warning: invalid width %lu; using %d instead"),
1917 desired_width, l_c_m);
1918 bytes_per_block = l_c_m;
1923 if (l_c_m < DEFAULT_BYTES_PER_BLOCK)
1924 bytes_per_block = l_c_m * (int) (DEFAULT_BYTES_PER_BLOCK / l_c_m);
1926 bytes_per_block = l_c_m;
1930 for (i = 0; i < n_specs; i++)
1932 printf (_("%d: fmt=\"%s\" width=%d\n"),
1933 i, spec[i].fmt_string, width_bytes[spec[i].size]);
1937 err |= (flag_dump_strings ? dump_strings () : dump ());
1941 if (have_read_stdin && fclose (stdin) == EOF)
1942 error (EXIT_FAILURE, errno, _("standard input"));
1944 if (fclose (stdout) == EOF)
1945 error (EXIT_FAILURE, errno, _("write error"));
1947 exit (err == 0 ? EXIT_SUCCESS : EXIT_FAILURE);