1 /* od -- dump files in octal and other formats
2 Copyright (C) 1992-2023 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 3 of the License, or
7 (at your option) any later version.
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, see <https://www.gnu.org/licenses/>. */
17 /* Written by Jim Meyering. */
23 #include <sys/types.h>
29 #include "stat-size.h"
30 #include "xbinary-io.h"
33 #include "xstrtol-error.h"
35 /* The official name of this program (e.g., no 'g' prefix). */
36 #define PROGRAM_NAME "od"
38 #define AUTHORS proper_name ("Jim Meyering")
40 /* The default number of input bytes per output line. */
41 #define DEFAULT_BYTES_PER_BLOCK 16
43 #if HAVE_UNSIGNED_LONG_LONG_INT
44 typedef unsigned long long int unsigned_long_long_int
;
46 /* This is just a place-holder to avoid a few '#if' directives.
47 In this case, the type isn't actually used. */
48 typedef unsigned long int unsigned_long_long_int
;
59 /* FIXME: add INTMAX support, too */
77 #define MAX_INTEGRAL_TYPE_SIZE sizeof (unsigned_long_long_int)
79 /* The maximum number of bytes needed for a format string, including
80 the trailing nul. Each format string expects a variable amount of
81 padding (guaranteed to be at least 1 plus the field width), then an
82 element that will be formatted in the field. */
94 /* Ensure that our choice for FMT_BYTES_ALLOCATED is reasonable. */
95 static_assert (MAX_INTEGRAL_TYPE_SIZE
* CHAR_BIT
/ 3 <= 99);
97 /* Each output format specification (from '-t spec' or from
98 old-style options) is represented by one of these structures. */
101 enum output_format fmt
;
102 enum size_spec size
; /* Type of input object. */
103 /* FIELDS is the number of fields per line, BLANK is the number of
104 fields to leave blank. WIDTH is width of one field, excluding
105 leading space, and PAD is total pad to divide among FIELDS.
106 PAD is at least as large as FIELDS. */
107 void (*print_function
) (size_t fields
, size_t blank
, void const *data
,
108 char const *fmt
, int width
, int pad
);
109 char fmt_string
[FMT_BYTES_ALLOCATED
]; /* Of the style "%*d". */
110 bool hexl_mode_trailer
;
111 int field_width
; /* Minimum width of a field, excluding leading space. */
112 int pad_width
; /* Total padding to be divided among fields. */
115 /* Convert the number of 8-bit bytes of a binary representation to
116 the number of characters (digits + sign if the type is signed)
117 required to represent the same quantity in the specified base/type.
118 For example, a 32-bit (4-byte) quantity may require a field width
119 as wide as the following for these types:
123 8 unsigned hexadecimal */
125 static unsigned int const bytes_to_oct_digits
[] =
126 {0, 3, 6, 8, 11, 14, 16, 19, 22, 25, 27, 30, 32, 35, 38, 41, 43};
128 static unsigned int const bytes_to_signed_dec_digits
[] =
129 {1, 4, 6, 8, 11, 13, 16, 18, 20, 23, 25, 28, 30, 33, 35, 37, 40};
131 static unsigned int const bytes_to_unsigned_dec_digits
[] =
132 {0, 3, 5, 8, 10, 13, 15, 17, 20, 22, 25, 27, 29, 32, 34, 37, 39};
134 static unsigned int const bytes_to_hex_digits
[] =
135 {0, 2, 4, 6, 8, 10, 12, 14, 16, 18, 20, 22, 24, 26, 28, 30, 32};
137 /* It'll be a while before we see integral types wider than 16 bytes,
138 but if/when it happens, this check will catch it. Without this check,
139 a wider type would provoke a buffer overrun. */
140 static_assert (MAX_INTEGRAL_TYPE_SIZE
141 < ARRAY_CARDINALITY (bytes_to_hex_digits
));
143 /* Make sure the other arrays have the same length. */
144 static_assert (sizeof bytes_to_oct_digits
== sizeof bytes_to_signed_dec_digits
);
145 static_assert (sizeof bytes_to_oct_digits
146 == sizeof bytes_to_unsigned_dec_digits
);
147 static_assert (sizeof bytes_to_oct_digits
== sizeof bytes_to_hex_digits
);
149 /* Convert enum size_spec to the size of the named type. */
150 static const int width_bytes
[] =
157 sizeof (unsigned_long_long_int
),
163 /* Ensure that for each member of 'enum size_spec' there is an
164 initializer in the width_bytes array. */
165 static_assert (ARRAY_CARDINALITY (width_bytes
) == N_SIZE_SPECS
);
167 /* Names for some non-printing characters. */
168 static char const charname
[33][4] =
170 "nul", "soh", "stx", "etx", "eot", "enq", "ack", "bel",
171 "bs", "ht", "nl", "vt", "ff", "cr", "so", "si",
172 "dle", "dc1", "dc2", "dc3", "dc4", "nak", "syn", "etb",
173 "can", "em", "sub", "esc", "fs", "gs", "rs", "us",
177 /* Address base (8, 10 or 16). */
178 static int address_base
;
180 /* The number of octal digits required to represent the largest
182 #define MAX_ADDRESS_LENGTH \
183 ((sizeof (uintmax_t) * CHAR_BIT + CHAR_BIT - 1) / 3)
185 /* Width of a normal address. */
186 static int address_pad_len
;
188 /* Minimum length when detecting --strings. */
189 static size_t string_min
;
191 /* True when in --strings mode. */
192 static bool flag_dump_strings
;
194 /* True if we should recognize the older non-option arguments
195 that specified at most one file and optional arguments specifying
196 offset and pseudo-start address. */
197 static bool traditional
;
199 /* True if an old-style 'pseudo-address' was specified. */
200 static bool flag_pseudo_start
;
202 /* The difference between the old-style pseudo starting address and
203 the number of bytes to skip. */
204 static uintmax_t pseudo_offset
;
206 /* Function that accepts an address and an optional following char,
207 and prints the address and char to stdout. */
208 static void (*format_address
) (uintmax_t, char);
210 /* The number of input bytes to skip before formatting and writing. */
211 static uintmax_t n_bytes_to_skip
= 0;
213 /* When false, MAX_BYTES_TO_FORMAT and END_OFFSET are ignored, and all
214 input is formatted. */
215 static bool limit_bytes_to_format
= false;
217 /* The maximum number of bytes that will be formatted. */
218 static uintmax_t max_bytes_to_format
;
220 /* The offset of the first byte after the last byte to be formatted. */
221 static uintmax_t end_offset
;
223 /* When true and two or more consecutive blocks are equal, format
224 only the first block and output an asterisk alone on the following
225 line to indicate that identical blocks have been elided. */
226 static bool abbreviate_duplicate_blocks
= true;
228 /* An array of specs describing how to format each input block. */
229 static struct tspec
*spec
;
231 /* The number of format specs. */
232 static size_t n_specs
;
234 /* The allocated length of SPEC. */
235 static size_t n_specs_allocated
;
237 /* The number of input bytes formatted per output line. It must be
238 a multiple of the least common multiple of the sizes associated with
239 the specified output types. It should be as large as possible, but
240 no larger than 16 -- unless specified with the -w option. */
241 static size_t bytes_per_block
;
243 /* Human-readable representation of *file_list (for error messages).
244 It differs from file_list[-1] only when file_list[-1] is "-". */
245 static char const *input_filename
;
247 /* A null-terminated list of the file-arguments from the command line. */
248 static char const *const *file_list
;
250 /* Initializer for file_list if no file-arguments
251 were specified on the command line. */
252 static char const *const default_file_list
[] = {"-", nullptr};
254 /* The input stream associated with the current file. */
255 static FILE *in_stream
;
257 /* If true, at least one of the files we read was standard input. */
258 static bool have_read_stdin
;
260 /* Map the size in bytes to a type identifier. */
261 static enum size_spec integral_type_size
[MAX_INTEGRAL_TYPE_SIZE
+ 1];
263 #define MAX_FP_TYPE_SIZE sizeof (long double)
264 static enum size_spec fp_type_size
[MAX_FP_TYPE_SIZE
+ 1];
266 #ifndef WORDS_BIGENDIAN
267 # define WORDS_BIGENDIAN 0
270 /* Use native endianess by default. */
271 static bool input_swap
;
273 static char const short_options
[] = "A:aBbcDdeFfHhIij:LlN:OoS:st:vw::Xx";
275 /* For long options that have no equivalent short option, use a
276 non-character as a pseudo short option, starting with CHAR_MAX + 1. */
279 TRADITIONAL_OPTION
= CHAR_MAX
+ 1,
289 static char const *const endian_args
[] =
291 "little", "big", nullptr
294 static enum endian_type
const endian_types
[] =
296 endian_little
, endian_big
299 static struct option
const long_options
[] =
301 {"skip-bytes", required_argument
, nullptr, 'j'},
302 {"address-radix", required_argument
, nullptr, 'A'},
303 {"read-bytes", required_argument
, nullptr, 'N'},
304 {"format", required_argument
, nullptr, 't'},
305 {"output-duplicates", no_argument
, nullptr, 'v'},
306 {"strings", optional_argument
, nullptr, 'S'},
307 {"traditional", no_argument
, nullptr, TRADITIONAL_OPTION
},
308 {"width", optional_argument
, nullptr, 'w'},
309 {"endian", required_argument
, nullptr, ENDIAN_OPTION
},
311 {GETOPT_HELP_OPTION_DECL
},
312 {GETOPT_VERSION_OPTION_DECL
},
313 {nullptr, 0, nullptr, 0}
319 if (status
!= EXIT_SUCCESS
)
324 Usage: %s [OPTION]... [FILE]...\n\
325 or: %s [-abcdfilosx]... [FILE] [[+]OFFSET[.][b]]\n\
326 or: %s --traditional [OPTION]... [FILE] [[+]OFFSET[.][b] [+][LABEL][.][b]]\n\
328 program_name
, program_name
, program_name
);
330 Write an unambiguous representation, octal bytes by default,\n\
331 of FILE to standard output. With more than one FILE argument,\n\
332 concatenate them in the listed order to form the input.\n\
339 If first and second call formats both apply, the second format is assumed\n\
340 if the last operand begins with + or (if there are 2 operands) a digit.\n\
341 An OFFSET operand means -j OFFSET. LABEL is the pseudo-address\n\
342 at first byte printed, incremented when dump is progressing.\n\
343 For OFFSET and LABEL, a 0x or 0X prefix indicates hexadecimal;\n\
344 suffixes may be . for octal and b for multiply by 512.\n\
347 emit_mandatory_arg_note ();
350 -A, --address-radix=RADIX output format for file offsets; RADIX is one\n\
351 of [doxn], for Decimal, Octal, Hex or None\n\
352 --endian={big|little} swap input bytes according the specified order\n\
353 -j, --skip-bytes=BYTES skip BYTES input bytes first\n\
356 -N, --read-bytes=BYTES limit dump to BYTES input bytes\n\
357 -S BYTES, --strings[=BYTES] show only NUL terminated strings\n\
358 of at least BYTES (3) printable characters\n\
359 -t, --format=TYPE select output format or formats\n\
360 -v, --output-duplicates do not use * to mark line suppression\n\
361 -w[BYTES], --width[=BYTES] output BYTES bytes per output line;\n\
362 32 is implied when BYTES is not specified\n\
363 --traditional accept arguments in third form above\n\
365 fputs (HELP_OPTION_DESCRIPTION
, stdout
);
366 fputs (VERSION_OPTION_DESCRIPTION
, stdout
);
370 Traditional format specifications may be intermixed; they accumulate:\n\
371 -a same as -t a, select named characters, ignoring high-order bit\n\
372 -b same as -t o1, select octal bytes\n\
373 -c same as -t c, select printable characters or backslash escapes\n\
374 -d same as -t u2, select unsigned decimal 2-byte units\n\
377 -f same as -t fF, select floats\n\
378 -i same as -t dI, select decimal ints\n\
379 -l same as -t dL, select decimal longs\n\
380 -o same as -t o2, select octal 2-byte units\n\
381 -s same as -t d2, select decimal 2-byte units\n\
382 -x same as -t x2, select hexadecimal 2-byte units\n\
387 TYPE is made up of one or more of these specifications:\n\
388 a named character, ignoring high-order bit\n\
389 c printable character or backslash escape\n\
392 d[SIZE] signed decimal, SIZE bytes per integer\n\
393 f[SIZE] floating point, SIZE bytes per float\n\
394 o[SIZE] octal, SIZE bytes per integer\n\
395 u[SIZE] unsigned decimal, SIZE bytes per integer\n\
396 x[SIZE] hexadecimal, SIZE bytes per integer\n\
400 SIZE is a number. For TYPE in [doux], SIZE may also be C for\n\
401 sizeof(char), S for sizeof(short), I for sizeof(int) or L for\n\
402 sizeof(long). If TYPE is f, SIZE may also be F for sizeof(float), D\n\
403 for sizeof(double) or L for sizeof(long double).\n\
407 Adding a z suffix to any type displays printable characters at the end of\n\
413 BYTES is hex with 0x or 0X prefix, and may have a multiplier suffix:\n\
419 and so on for G, T, P, E, Z, Y, R, Q.\n\
420 Binary prefixes can be used, too: KiB=K, MiB=M, and so on.\n\
422 emit_ancillary_info (PROGRAM_NAME
);
427 /* Define the print functions. */
429 #define PRINT_FIELDS(N, T, FMT_STRING_DECL, ACTION) \
431 N (size_t fields, size_t blank, void const *block, \
432 FMT_STRING_DECL, int width, int pad) \
434 T const *p = block; \
436 int pad_remaining = pad; \
437 for (i = fields; blank < i; i--) \
439 int next_pad = pad * (i - 1) / fields; \
440 int adjusted_width = pad_remaining - next_pad + width; \
442 if (input_swap && sizeof (T) > 1) \
447 char b[sizeof (T)]; \
449 for (j = 0; j < sizeof (T); j++) \
450 u.b[j] = ((char const *) p)[sizeof (T) - 1 - j]; \
457 pad_remaining = next_pad; \
461 #define PRINT_TYPE(N, T) \
462 PRINT_FIELDS (N, T, char const *fmt_string, \
463 xprintf (fmt_string, adjusted_width, x))
465 #define PRINT_FLOATTYPE(N, T, FTOASTR, BUFSIZE) \
466 PRINT_FIELDS (N, T, MAYBE_UNUSED char const *fmt_string, \
468 FTOASTR (buf, sizeof buf, 0, 0, x); \
469 xprintf ("%*s", adjusted_width, buf))
471 PRINT_TYPE (print_s_char
, signed char)
472 PRINT_TYPE (print_char
, unsigned char)
473 PRINT_TYPE (print_s_short
, short int)
474 PRINT_TYPE (print_short
, unsigned short int)
475 PRINT_TYPE (print_int
, unsigned int)
476 PRINT_TYPE (print_long
, unsigned long int)
477 PRINT_TYPE (print_long_long
, unsigned_long_long_int
)
479 PRINT_FLOATTYPE (print_float
, float, ftoastr
, FLT_BUFSIZE_BOUND
)
480 PRINT_FLOATTYPE (print_double
, double, dtoastr
, DBL_BUFSIZE_BOUND
)
481 PRINT_FLOATTYPE (print_long_double
, long double, ldtoastr
, LDBL_BUFSIZE_BOUND
)
484 #undef PRINT_FLOATTYPE
487 dump_hexl_mode_trailer (size_t n_bytes
, char const *block
)
489 fputs (" >", stdout
);
490 for (size_t i
= n_bytes
; i
> 0; i
--)
492 unsigned char c
= *block
++;
493 unsigned char c2
= (isprint (c
) ? c
: '.');
500 print_named_ascii (size_t fields
, size_t blank
, void const *block
,
501 MAYBE_UNUSED
char const *unused_fmt_string
,
504 unsigned char const *p
= block
;
506 int pad_remaining
= pad
;
507 for (i
= fields
; blank
< i
; i
--)
509 int next_pad
= pad
* (i
- 1) / fields
;
510 int masked_c
= *p
++ & 0x7f;
516 else if (masked_c
<= 040)
517 s
= charname
[masked_c
];
525 xprintf ("%*s", pad_remaining
- next_pad
+ width
, s
);
526 pad_remaining
= next_pad
;
531 print_ascii (size_t fields
, size_t blank
, void const *block
,
532 MAYBE_UNUSED
char const *unused_fmt_string
, int width
,
535 unsigned char const *p
= block
;
537 int pad_remaining
= pad
;
538 for (i
= fields
; blank
< i
; i
--)
540 int next_pad
= pad
* (i
- 1) / fields
;
541 unsigned char c
= *p
++;
580 sprintf (buf
, (isprint (c
) ? "%c" : "%03o"), c
);
584 xprintf ("%*s", pad_remaining
- next_pad
+ width
, s
);
585 pad_remaining
= next_pad
;
589 /* Convert a null-terminated (possibly zero-length) string S to an
590 unsigned long integer value. If S points to a non-digit set *P to S,
591 *VAL to 0, and return true. Otherwise, accumulate the integer value of
592 the string of digits. If the string of digits represents a value
593 larger than ULONG_MAX, don't modify *VAL or *P and return false.
594 Otherwise, advance *P to the first non-digit after S, set *VAL to
595 the result of the conversion and return true. */
598 simple_strtoul (char const *s
, char const **p
, unsigned long int *val
)
600 unsigned long int sum
;
606 if (sum
> (ULONG_MAX
- c
) / 10)
615 /* If S points to a single valid modern od format string, put
616 a description of that format in *TSPEC, make *NEXT point at the
617 character following the just-decoded format (if *NEXT is non-null),
618 and return true. If S is not valid, don't modify *NEXT or *TSPEC,
619 give a diagnostic, and return false. For example, if S were
620 "d4afL" *NEXT would be set to "afL" and *TSPEC would be
622 fmt = SIGNED_DECIMAL;
623 size = INT or LONG; (whichever integral_type_size[4] resolves to)
624 print_function = print_int; (assuming size == INT)
628 pad_width is determined later, but is at least as large as the
629 number of fields printed per row.
630 S_ORIG is solely for reporting errors. It should be the full format
634 static bool ATTRIBUTE_NONNULL ()
635 decode_one_format (char const *s_orig
, char const *s
, char const **next
,
638 enum size_spec size_spec
;
639 unsigned long int size
;
640 enum output_format fmt
;
641 void (*print_function
) (size_t, size_t, void const *, char const *,
659 size
= sizeof (char);
664 size
= sizeof (short int);
674 size
= sizeof (long int);
678 if (! simple_strtoul (s
, &p
, &size
))
680 /* The integer at P in S would overflow an unsigned long int.
681 A digit string that long is sufficiently odd looking
682 that the following diagnostic is sufficient. */
683 error (0, 0, _("invalid type string %s"), quote (s_orig
));
690 if (MAX_INTEGRAL_TYPE_SIZE
< size
691 || integral_type_size
[size
] == NO_SIZE
)
693 error (0, 0, _("invalid type string %s;\nthis system"
694 " doesn't provide a %lu-byte integral type"),
695 quote (s_orig
), size
);
703 #define ISPEC_TO_FORMAT(Spec, Min_format, Long_format, Max_format) \
704 ((Spec) == LONG_LONG ? (Max_format) \
705 : ((Spec) == LONG ? (Long_format) \
708 size_spec = integral_type_size[size];
713 fmt
= SIGNED_DECIMAL
;
714 field_width
= bytes_to_signed_dec_digits
[size
];
715 sprintf (tspec
->fmt_string
, "%%*%s",
716 ISPEC_TO_FORMAT (size_spec
, "d", "ld", PRIdMAX
));
721 sprintf (tspec
->fmt_string
, "%%*.%d%s",
722 (field_width
= bytes_to_oct_digits
[size
]),
723 ISPEC_TO_FORMAT (size_spec
, "o", "lo", PRIoMAX
));
727 fmt
= UNSIGNED_DECIMAL
;
728 field_width
= bytes_to_unsigned_dec_digits
[size
];
729 sprintf (tspec
->fmt_string
, "%%*%s",
730 ISPEC_TO_FORMAT (size_spec
, "u", "lu", PRIuMAX
));
735 sprintf (tspec
->fmt_string
, "%%*.%d%s",
736 (field_width
= bytes_to_hex_digits
[size
]),
737 ISPEC_TO_FORMAT (size_spec
, "x", "lx", PRIxMAX
));
747 print_function
= (fmt
== SIGNED_DECIMAL
753 print_function
= (fmt
== SIGNED_DECIMAL
759 print_function
= print_int
;
763 print_function
= print_long
;
767 print_function
= print_long_long
;
776 fmt
= FLOATING_POINT
;
782 size
= sizeof (float);
787 size
= sizeof (double);
792 size
= sizeof (long double);
796 if (! simple_strtoul (s
, &p
, &size
))
798 /* The integer at P in S would overflow an unsigned long int.
799 A digit string that long is sufficiently odd looking
800 that the following diagnostic is sufficient. */
801 error (0, 0, _("invalid type string %s"), quote (s_orig
));
805 size
= sizeof (double);
808 if (size
> MAX_FP_TYPE_SIZE
809 || fp_type_size
[size
] == NO_SIZE
)
812 _("invalid type string %s;\n"
813 "this system doesn't provide a %lu-byte"
814 " floating point type"),
815 quote (s_orig
), size
);
822 size_spec
= fp_type_size
[size
];
825 struct lconv
const *locale
= localeconv ();
826 size_t decimal_point_len
=
827 (locale
->decimal_point
[0] ? strlen (locale
->decimal_point
) : 1);
832 print_function
= print_float
;
833 field_width
= FLT_STRLEN_BOUND_L (decimal_point_len
);
837 print_function
= print_double
;
838 field_width
= DBL_STRLEN_BOUND_L (decimal_point_len
);
841 case FLOAT_LONG_DOUBLE
:
842 print_function
= print_long_double
;
843 field_width
= LDBL_STRLEN_BOUND_L (decimal_point_len
);
855 fmt
= NAMED_CHARACTER
;
857 print_function
= print_named_ascii
;
865 print_function
= print_ascii
;
870 error (0, 0, _("invalid character '%c' in type string %s"),
875 tspec
->size
= size_spec
;
877 tspec
->print_function
= print_function
;
879 tspec
->field_width
= field_width
;
880 tspec
->hexl_mode_trailer
= (*s
== 'z');
881 if (tspec
->hexl_mode_trailer
)
888 /* Given a list of one or more input filenames FILE_LIST, set the global
889 file pointer IN_STREAM and the global string INPUT_FILENAME to the
890 first one that can be successfully opened. Modify FILE_LIST to
891 reference the next filename in the list. A file name of "-" is
892 interpreted as standard input. If any file open fails, give an error
893 message and return false. */
896 open_next_file (void)
902 input_filename
= *file_list
;
903 if (input_filename
== nullptr)
907 if (STREQ (input_filename
, "-"))
909 input_filename
= _("standard input");
911 have_read_stdin
= true;
912 xset_binary_mode (STDIN_FILENO
, O_BINARY
);
916 in_stream
= fopen (input_filename
, (O_BINARY
? "rb" : "r"));
917 if (in_stream
== nullptr)
919 error (0, errno
, "%s", quotef (input_filename
));
924 while (in_stream
== nullptr);
926 if (limit_bytes_to_format
&& !flag_dump_strings
)
927 setvbuf (in_stream
, nullptr, _IONBF
, 0);
932 /* Test whether there have been errors on in_stream, and close it if
933 it is not standard input. Return false if there has been an error
934 on in_stream or stdout; return true otherwise. This function will
935 report more than one error only if both a read and a write error
936 have occurred. IN_ERRNO, if nonzero, is the error number
937 corresponding to the most recent action for IN_STREAM. */
940 check_and_close (int in_errno
)
944 if (in_stream
!= nullptr)
946 if (!ferror (in_stream
))
948 if (STREQ (file_list
[-1], "-"))
949 clearerr (in_stream
);
950 else if (fclose (in_stream
) != 0 && !in_errno
)
954 error (0, in_errno
, "%s", quotef (input_filename
));
963 error (0, 0, _("write error"));
970 /* Decode the modern od format string S. Append the decoded
971 representation to the global array SPEC, reallocating SPEC if
972 necessary. Return true if S is valid. */
974 static bool ATTRIBUTE_NONNULL ()
975 decode_format_string (char const *s
)
977 char const *s_orig
= s
;
983 if (n_specs_allocated
<= n_specs
)
984 spec
= X2NREALLOC (spec
, &n_specs_allocated
);
986 if (! decode_one_format (s_orig
, s
, &next
, &spec
[n_specs
]))
997 /* Given a list of one or more input filenames FILE_LIST, set the global
998 file pointer IN_STREAM to position N_SKIP in the concatenation of
999 those files. If any file operation fails or if there are fewer than
1000 N_SKIP bytes in the combined input, give an error message and return
1001 false. When possible, use seek rather than read operations to
1002 advance IN_STREAM. */
1005 skip (uintmax_t n_skip
)
1013 while (in_stream
!= nullptr) /* EOF. */
1015 struct stat file_stats
;
1017 /* First try seeking. For large offsets, this extra work is
1018 worthwhile. If the offset is below some threshold it may be
1019 more efficient to move the pointer by reading. There are two
1020 issues when trying to seek:
1021 - the file must be seekable.
1022 - before seeking to the specified position, make sure
1023 that the new position is in the current file.
1024 Try to do that by getting file's size using fstat.
1025 But that will work only for regular files. */
1027 if (fstat (fileno (in_stream
), &file_stats
) == 0)
1029 bool usable_size
= usable_st_size (&file_stats
);
1031 /* The st_size field is valid for regular files.
1032 If the number of bytes left to skip is larger than
1033 the size of the current file, we can decrement n_skip
1034 and go on to the next file. Skip this optimization also
1035 when st_size is no greater than the block size, because
1036 some kernels report nonsense small file sizes for
1037 proc-like file systems. */
1038 if (usable_size
&& ST_BLKSIZE (file_stats
) < file_stats
.st_size
)
1040 if ((uintmax_t) file_stats
.st_size
< n_skip
)
1041 n_skip
-= file_stats
.st_size
;
1044 if (fseeko (in_stream
, n_skip
, SEEK_CUR
) != 0)
1053 else if (!usable_size
&& fseeko (in_stream
, n_skip
, SEEK_CUR
) == 0)
1056 /* If it's not a regular file with nonnegative size,
1057 or if it's so small that it might be in a proc-like file system,
1058 position the file pointer by reading. */
1063 size_t n_bytes_read
, n_bytes_to_read
= BUFSIZ
;
1067 if (n_skip
< n_bytes_to_read
)
1068 n_bytes_to_read
= n_skip
;
1069 n_bytes_read
= fread (buf
, 1, n_bytes_to_read
, in_stream
);
1070 n_skip
-= n_bytes_read
;
1071 if (n_bytes_read
!= n_bytes_to_read
)
1073 if (ferror (in_stream
))
1080 if (feof (in_stream
))
1090 else /* cannot fstat() file */
1092 error (0, errno
, "%s", quotef (input_filename
));
1096 ok
&= check_and_close (in_errno
);
1098 ok
&= open_next_file ();
1102 error (EXIT_FAILURE
, 0, _("cannot skip past end of combined input"));
1108 format_address_none (MAYBE_UNUSED
uintmax_t address
,
1109 MAYBE_UNUSED
char c
)
1114 format_address_std (uintmax_t address
, char c
)
1116 char buf
[MAX_ADDRESS_LENGTH
+ 2];
1117 char *p
= buf
+ sizeof buf
;
1122 pbound
= p
- address_pad_len
;
1124 /* Use a special case of the code for each base. This is measurably
1125 faster than generic code. */
1126 switch (address_base
)
1130 *--p
= '0' + (address
& 7);
1131 while ((address
>>= 3) != 0);
1136 *--p
= '0' + (address
% 10);
1137 while ((address
/= 10) != 0);
1142 *--p
= "0123456789abcdef"[address
& 15];
1143 while ((address
>>= 4) != 0);
1154 format_address_paren (uintmax_t address
, char c
)
1157 format_address_std (address
, ')');
1163 format_address_label (uintmax_t address
, char c
)
1165 format_address_std (address
, ' ');
1166 format_address_paren (address
+ pseudo_offset
, c
);
1169 /* Write N_BYTES bytes from CURR_BLOCK to standard output once for each
1170 of the N_SPEC format specs. CURRENT_OFFSET is the byte address of
1171 CURR_BLOCK in the concatenation of input files, and it is printed
1172 (optionally) only before the output line associated with the first
1173 format spec. When duplicate blocks are being abbreviated, the output
1174 for a sequence of identical input blocks is the output for the first
1175 block followed by an asterisk alone on a line. It is valid to compare
1176 the blocks PREV_BLOCK and CURR_BLOCK only when N_BYTES == BYTES_PER_BLOCK.
1177 That condition may be false only for the last input block. */
1180 write_block (uintmax_t current_offset
, size_t n_bytes
,
1181 char const *prev_block
, char const *curr_block
)
1183 static bool first
= true;
1184 static bool prev_pair_equal
= false;
1186 #define EQUAL_BLOCKS(b1, b2) (memcmp (b1, b2, bytes_per_block) == 0)
1188 if (abbreviate_duplicate_blocks
1189 && !first
&& n_bytes
== bytes_per_block
1190 && EQUAL_BLOCKS (prev_block
, curr_block
))
1192 if (prev_pair_equal
)
1194 /* The two preceding blocks were equal, and the current
1195 block is the same as the last one, so print nothing. */
1200 prev_pair_equal
= true;
1205 prev_pair_equal
= false;
1206 for (size_t i
= 0; i
< n_specs
; i
++)
1208 int datum_width
= width_bytes
[spec
[i
].size
];
1209 int fields_per_block
= bytes_per_block
/ datum_width
;
1210 int blank_fields
= (bytes_per_block
- n_bytes
) / datum_width
;
1212 format_address (current_offset
, '\0');
1214 printf ("%*s", address_pad_len
, "");
1215 (*spec
[i
].print_function
) (fields_per_block
, blank_fields
,
1216 curr_block
, spec
[i
].fmt_string
,
1217 spec
[i
].field_width
, spec
[i
].pad_width
);
1218 if (spec
[i
].hexl_mode_trailer
)
1220 /* space-pad out to full line width, then dump the trailer */
1221 int field_width
= spec
[i
].field_width
;
1222 int pad_width
= (spec
[i
].pad_width
* blank_fields
1223 / fields_per_block
);
1224 printf ("%*s", blank_fields
* field_width
+ pad_width
, "");
1225 dump_hexl_mode_trailer (n_bytes
, curr_block
);
1233 /* Read a single byte into *C from the concatenation of the input files
1234 named in the global array FILE_LIST. On the first call to this
1235 function, the global variable IN_STREAM is expected to be an open
1236 stream associated with the input file INPUT_FILENAME. If IN_STREAM
1237 is at end-of-file, close it and update the global variables IN_STREAM
1238 and INPUT_FILENAME so they correspond to the next file in the list.
1239 Then try to read a byte from the newly opened file. Repeat if
1240 necessary until EOF is reached for the last file in FILE_LIST, then
1241 set *C to EOF and return. Subsequent calls do likewise. Return
1242 true if successful. */
1251 while (in_stream
!= nullptr) /* EOF. */
1253 *c
= fgetc (in_stream
);
1258 ok
&= check_and_close (errno
);
1260 ok
&= open_next_file ();
1266 /* Read N bytes into BLOCK from the concatenation of the input files
1267 named in the global array FILE_LIST. On the first call to this
1268 function, the global variable IN_STREAM is expected to be an open
1269 stream associated with the input file INPUT_FILENAME. If all N
1270 bytes cannot be read from IN_STREAM, close IN_STREAM and update
1271 the global variables IN_STREAM and INPUT_FILENAME. Then try to
1272 read the remaining bytes from the newly opened file. Repeat if
1273 necessary until EOF is reached for the last file in FILE_LIST.
1274 On subsequent calls, don't modify BLOCK and return true. Set
1275 *N_BYTES_IN_BUFFER to the number of bytes read. If an error occurs,
1276 it will be detected through ferror when the stream is about to be
1277 closed. If there is an error, give a message but continue reading
1278 as usual and return false. Otherwise return true. */
1281 read_block (size_t n
, char *block
, size_t *n_bytes_in_buffer
)
1285 affirm (0 < n
&& n
<= bytes_per_block
);
1287 *n_bytes_in_buffer
= 0;
1289 while (in_stream
!= nullptr) /* EOF. */
1294 n_needed
= n
- *n_bytes_in_buffer
;
1295 n_read
= fread (block
+ *n_bytes_in_buffer
, 1, n_needed
, in_stream
);
1297 *n_bytes_in_buffer
+= n_read
;
1299 if (n_read
== n_needed
)
1302 ok
&= check_and_close (errno
);
1304 ok
&= open_next_file ();
1310 /* Return the least common multiple of the sizes associated
1311 with the format specs. */
1319 for (size_t i
= 0; i
< n_specs
; i
++)
1320 l_c_m
= lcm (l_c_m
, width_bytes
[spec
[i
].size
]);
1324 /* If S is a valid traditional offset specification with an optional
1325 leading '+' return true and set *OFFSET to the offset it denotes. */
1328 parse_old_offset (char const *s
, uintmax_t *offset
)
1335 /* Skip over any leading '+'. */
1339 /* Determine the radix we'll use to interpret S. If there is a '.',
1340 it's decimal, otherwise, if the string begins with '0X'or '0x',
1341 it's hexadecimal, else octal. */
1342 if (strchr (s
, '.') != nullptr)
1346 if (s
[0] == '0' && (s
[1] == 'x' || s
[1] == 'X'))
1352 return xstrtoumax (s
, nullptr, radix
, offset
, "Bb") == LONGINT_OK
;
1355 /* Read a chunk of size BYTES_PER_BLOCK from the input files, write the
1356 formatted block to standard output, and repeat until the specified
1357 maximum number of bytes has been read or until all input has been
1358 processed. If the last block read is smaller than BYTES_PER_BLOCK
1359 and its size is not a multiple of the size associated with a format
1360 spec, extend the input block with zero bytes until its length is a
1361 multiple of all format spec sizes. Write the final block. Finally,
1362 write on a line by itself the offset of the byte after the last byte
1363 read. Accumulate return values from calls to read_block and
1364 check_and_close, and if any was false, return false.
1365 Otherwise, return true. */
1371 uintmax_t current_offset
;
1374 size_t n_bytes_read
;
1376 block
[0] = xnmalloc (2, bytes_per_block
);
1377 block
[1] = block
[0] + bytes_per_block
;
1379 current_offset
= n_bytes_to_skip
;
1381 if (limit_bytes_to_format
)
1386 if (current_offset
>= end_offset
)
1391 n_needed
= MIN (end_offset
- current_offset
,
1392 (uintmax_t) bytes_per_block
);
1393 ok
&= read_block (n_needed
, block
[idx
], &n_bytes_read
);
1394 if (n_bytes_read
< bytes_per_block
)
1396 affirm (n_bytes_read
== bytes_per_block
);
1397 write_block (current_offset
, n_bytes_read
,
1398 block
[!idx
], block
[idx
]);
1399 current_offset
+= n_bytes_read
;
1407 ok
&= read_block (bytes_per_block
, block
[idx
], &n_bytes_read
);
1408 if (n_bytes_read
< bytes_per_block
)
1410 affirm (n_bytes_read
== bytes_per_block
);
1411 write_block (current_offset
, n_bytes_read
,
1412 block
[!idx
], block
[idx
]);
1413 current_offset
+= n_bytes_read
;
1418 if (n_bytes_read
> 0)
1421 size_t bytes_to_write
;
1425 /* Ensure zero-byte padding up to the smallest multiple of l_c_m that
1426 is at least as large as n_bytes_read. */
1427 bytes_to_write
= l_c_m
* ((n_bytes_read
+ l_c_m
- 1) / l_c_m
);
1429 memset (block
[idx
] + n_bytes_read
, 0, bytes_to_write
- n_bytes_read
);
1430 write_block (current_offset
, n_bytes_read
, block
[!idx
], block
[idx
]);
1431 current_offset
+= n_bytes_read
;
1434 format_address (current_offset
, '\n');
1436 if (limit_bytes_to_format
&& current_offset
>= end_offset
)
1437 ok
&= check_and_close (0);
1444 /* STRINGS mode. Find each "string constant" in the input.
1445 A string constant is a run of at least 'string_min' ASCII
1446 graphic (or formatting) characters terminated by a null.
1447 Based on a function written by Richard Stallman for a
1448 traditional version of od. Return true if successful. */
1453 size_t bufsize
= MAX (100, string_min
);
1454 char *buf
= xmalloc (bufsize
);
1455 uintmax_t address
= n_bytes_to_skip
;
1463 /* See if the next 'string_min' chars are all printing chars. */
1466 if (limit_bytes_to_format
1467 && (end_offset
< string_min
|| end_offset
- string_min
<= address
))
1470 for (i
= 0; i
< string_min
; i
++)
1472 ok
&= read_char (&c
);
1480 /* Found a non-printing. Try again starting with next char. */
1485 /* We found a run of 'string_min' printable characters.
1486 Now see if it is terminated with a null byte. */
1487 while (!limit_bytes_to_format
|| address
< end_offset
)
1491 buf
= X2REALLOC (buf
, &bufsize
);
1493 ok
&= read_char (&c
);
1501 break; /* It is; print this string. */
1503 goto tryline
; /* It isn't; give up on this string. */
1504 buf
[i
++] = c
; /* String continues; store it all. */
1507 /* If we get here, the string is all printable and null-terminated,
1508 so print it. It is all in 'buf' and 'i' is its length. */
1510 format_address (address
- i
- 1, ' ');
1512 for (i
= 0; (c
= buf
[i
]); i
++)
1517 fputs ("\\a", stdout
);
1521 fputs ("\\b", stdout
);
1525 fputs ("\\f", stdout
);
1529 fputs ("\\n", stdout
);
1533 fputs ("\\r", stdout
);
1537 fputs ("\\t", stdout
);
1541 fputs ("\\v", stdout
);
1551 /* We reach this point only if we search through
1552 (max_bytes_to_format - string_min) bytes before reaching EOF. */
1556 ok
&= check_and_close (0);
1561 main (int argc
, char **argv
)
1566 size_t desired_width
IF_LINT ( = 0);
1567 bool modern
= false;
1568 bool width_specified
= false;
1570 size_t width_per_block
= 0;
1571 static char const multipliers
[] = "bEGKkMmPQRTYZ0";
1573 /* The old-style 'pseudo starting address' to be printed in parentheses
1574 after any true address. */
1575 uintmax_t pseudo_start
IF_LINT ( = 0);
1577 initialize_main (&argc
, &argv
);
1578 set_program_name (argv
[0]);
1579 setlocale (LC_ALL
, "");
1580 bindtextdomain (PACKAGE
, LOCALEDIR
);
1581 textdomain (PACKAGE
);
1583 atexit (close_stdout
);
1585 for (i
= 0; i
<= MAX_INTEGRAL_TYPE_SIZE
; i
++)
1586 integral_type_size
[i
] = NO_SIZE
;
1588 integral_type_size
[sizeof (char)] = CHAR
;
1589 integral_type_size
[sizeof (short int)] = SHORT
;
1590 integral_type_size
[sizeof (int)] = INT
;
1591 integral_type_size
[sizeof (long int)] = LONG
;
1592 #if HAVE_UNSIGNED_LONG_LONG_INT
1593 /* If 'long int' and 'long long int' have the same size, it's fine
1594 to overwrite the entry for 'long' with this one. */
1595 integral_type_size
[sizeof (unsigned_long_long_int
)] = LONG_LONG
;
1598 for (i
= 0; i
<= MAX_FP_TYPE_SIZE
; i
++)
1599 fp_type_size
[i
] = NO_SIZE
;
1601 fp_type_size
[sizeof (float)] = FLOAT_SINGLE
;
1602 /* The array entry for 'double' is filled in after that for 'long double'
1603 so that if they are the same size, we avoid any overhead of
1604 long double computation in libc. */
1605 fp_type_size
[sizeof (long double)] = FLOAT_LONG_DOUBLE
;
1606 fp_type_size
[sizeof (double)] = FLOAT_DOUBLE
;
1609 n_specs_allocated
= 0;
1612 format_address
= format_address_std
;
1614 address_pad_len
= 7;
1615 flag_dump_strings
= false;
1620 enum strtol_error s_err
;
1622 int c
= getopt_long (argc
, argv
, short_options
, long_options
, &oi
);
1633 format_address
= format_address_std
;
1635 address_pad_len
= 7;
1638 format_address
= format_address_std
;
1640 address_pad_len
= 7;
1643 format_address
= format_address_std
;
1645 address_pad_len
= 6;
1648 format_address
= format_address_none
;
1649 address_pad_len
= 0;
1652 error (EXIT_FAILURE
, 0,
1653 _("invalid output address radix '%c';"
1654 " it must be one character from [doxn]"),
1662 s_err
= xstrtoumax (optarg
, nullptr, 0,
1663 &n_bytes_to_skip
, multipliers
);
1664 if (s_err
!= LONGINT_OK
)
1665 xstrtol_fatal (s_err
, oi
, c
, long_options
, optarg
);
1670 limit_bytes_to_format
= true;
1672 s_err
= xstrtoumax (optarg
, nullptr, 0, &max_bytes_to_format
,
1674 if (s_err
!= LONGINT_OK
)
1675 xstrtol_fatal (s_err
, oi
, c
, long_options
, optarg
);
1680 if (optarg
== nullptr)
1684 s_err
= xstrtoumax (optarg
, nullptr, 0, &tmp
, multipliers
);
1685 if (s_err
!= LONGINT_OK
)
1686 xstrtol_fatal (s_err
, oi
, c
, long_options
, optarg
);
1688 /* The minimum string length may be no larger than SIZE_MAX,
1689 since we may allocate a buffer of this size. */
1691 error (EXIT_FAILURE
, 0, _("%s is too large"), quote (optarg
));
1695 flag_dump_strings
= true;
1700 ok
&= decode_format_string (optarg
);
1705 abbreviate_duplicate_blocks
= false;
1708 case TRADITIONAL_OPTION
:
1713 switch (XARGMATCH ("--endian", optarg
, endian_args
, endian_types
))
1716 input_swap
= ! WORDS_BIGENDIAN
;
1719 input_swap
= WORDS_BIGENDIAN
;
1724 /* The next several cases map the traditional format
1725 specification options to the corresponding modern format
1726 specs. GNU od accepts any combination of old- and
1727 new-style options. Format specification options accumulate.
1728 The obsolescent and undocumented formats are compatible
1729 with FreeBSD 4.10 od. */
1731 #define CASE_OLD_ARG(old_char,new_string) \
1733 ok &= decode_format_string (new_string); \
1736 CASE_OLD_ARG ('a', "a");
1737 CASE_OLD_ARG ('b', "o1");
1738 CASE_OLD_ARG ('c', "c");
1739 CASE_OLD_ARG ('D', "u4"); /* obsolescent and undocumented */
1740 CASE_OLD_ARG ('d', "u2");
1741 case 'F': /* obsolescent and undocumented alias */
1742 CASE_OLD_ARG ('e', "fD"); /* obsolescent and undocumented */
1743 CASE_OLD_ARG ('f', "fF");
1744 case 'X': /* obsolescent and undocumented alias */
1745 CASE_OLD_ARG ('H', "x4"); /* obsolescent and undocumented */
1746 CASE_OLD_ARG ('i', "dI");
1747 case 'I': case 'L': /* obsolescent and undocumented aliases */
1748 CASE_OLD_ARG ('l', "dL");
1749 CASE_OLD_ARG ('O', "o4"); /* obsolesent and undocumented */
1750 case 'B': /* obsolescent and undocumented alias */
1751 CASE_OLD_ARG ('o', "o2");
1752 CASE_OLD_ARG ('s', "d2");
1753 case 'h': /* obsolescent and undocumented alias */
1754 CASE_OLD_ARG ('x', "x2");
1760 width_specified
= true;
1761 if (optarg
== nullptr)
1768 s_err
= xstrtoumax (optarg
, nullptr, 10, &w_tmp
, "");
1769 if (s_err
!= LONGINT_OK
)
1770 xstrtol_fatal (s_err
, oi
, c
, long_options
, optarg
);
1771 if (SIZE_MAX
< w_tmp
)
1772 error (EXIT_FAILURE
, 0, _("%s is too large"), quote (optarg
));
1773 desired_width
= w_tmp
;
1777 case_GETOPT_HELP_CHAR
;
1779 case_GETOPT_VERSION_CHAR (PROGRAM_NAME
, AUTHORS
);
1782 usage (EXIT_FAILURE
);
1788 return EXIT_FAILURE
;
1790 if (flag_dump_strings
&& n_specs
> 0)
1791 error (EXIT_FAILURE
, 0,
1792 _("no type may be specified when dumping strings"));
1794 n_files
= argc
- optind
;
1796 /* If the --traditional option is used, there may be from
1797 0 to 3 remaining command line arguments; handle each case
1799 od [file] [[+]offset[.][b] [[+]label[.][b]]]
1800 The offset and label have the same syntax.
1802 If --traditional is not given, and if no modern options are
1803 given, and if the offset begins with + or (if there are two
1804 operands) a digit, accept only this form, as per POSIX:
1805 od [file] [[+]offset[.][b]]
1808 if (!modern
|| traditional
)
1816 if ((traditional
|| argv
[optind
][0] == '+')
1817 && parse_old_offset (argv
[optind
], &o1
))
1819 n_bytes_to_skip
= o1
;
1826 if ((traditional
|| argv
[optind
+ 1][0] == '+'
1827 || ISDIGIT (argv
[optind
+ 1][0]))
1828 && parse_old_offset (argv
[optind
+ 1], &o2
))
1830 if (traditional
&& parse_old_offset (argv
[optind
], &o1
))
1832 n_bytes_to_skip
= o1
;
1833 flag_pseudo_start
= true;
1840 n_bytes_to_skip
= o2
;
1842 argv
[optind
+ 1] = argv
[optind
];
1850 && parse_old_offset (argv
[optind
+ 1], &o1
)
1851 && parse_old_offset (argv
[optind
+ 2], &o2
))
1853 n_bytes_to_skip
= o1
;
1854 flag_pseudo_start
= true;
1856 argv
[optind
+ 2] = argv
[optind
];
1863 if (traditional
&& 1 < n_files
)
1865 error (0, 0, _("extra operand %s"), quote (argv
[optind
+ 1]));
1867 _("compatibility mode supports at most one file"));
1868 usage (EXIT_FAILURE
);
1872 if (flag_pseudo_start
)
1874 if (format_address
== format_address_none
)
1877 address_pad_len
= 7;
1878 format_address
= format_address_paren
;
1881 format_address
= format_address_label
;
1884 if (limit_bytes_to_format
)
1886 end_offset
= n_bytes_to_skip
+ max_bytes_to_format
;
1887 if (end_offset
< n_bytes_to_skip
)
1888 error (EXIT_FAILURE
, 0, _("skip-bytes + read-bytes is too large"));
1892 decode_format_string ("oS");
1896 /* Set the global pointer FILE_LIST so that it
1897 references the first file-argument on the command-line. */
1899 file_list
= (char const *const *) &argv
[optind
];
1903 /* No files were listed on the command line.
1904 Set the global pointer FILE_LIST so that it
1905 references the null-terminated list of one name: "-". */
1907 file_list
= default_file_list
;
1910 /* open the first input file */
1911 ok
= open_next_file ();
1912 if (in_stream
== nullptr)
1915 /* skip over any unwanted header bytes */
1916 ok
&= skip (n_bytes_to_skip
);
1917 if (in_stream
== nullptr)
1920 pseudo_offset
= (flag_pseudo_start
? pseudo_start
- n_bytes_to_skip
: 0);
1922 /* Compute output block length. */
1925 if (width_specified
)
1927 if (desired_width
!= 0 && desired_width
% l_c_m
== 0)
1928 bytes_per_block
= desired_width
;
1931 error (0, 0, _("warning: invalid width %lu; using %d instead"),
1932 (unsigned long int) desired_width
, l_c_m
);
1933 bytes_per_block
= l_c_m
;
1938 if (l_c_m
< DEFAULT_BYTES_PER_BLOCK
)
1939 bytes_per_block
= l_c_m
* (DEFAULT_BYTES_PER_BLOCK
/ l_c_m
);
1941 bytes_per_block
= l_c_m
;
1944 /* Compute padding necessary to align output block. */
1945 for (i
= 0; i
< n_specs
; i
++)
1947 int fields_per_block
= bytes_per_block
/ width_bytes
[spec
[i
].size
];
1948 int block_width
= (spec
[i
].field_width
+ 1) * fields_per_block
;
1949 if (width_per_block
< block_width
)
1950 width_per_block
= block_width
;
1952 for (i
= 0; i
< n_specs
; i
++)
1954 int fields_per_block
= bytes_per_block
/ width_bytes
[spec
[i
].size
];
1955 int block_width
= spec
[i
].field_width
* fields_per_block
;
1956 spec
[i
].pad_width
= width_per_block
- block_width
;
1960 printf ("lcm=%d, width_per_block=%"PRIuMAX
"\n", l_c_m
,
1961 (uintmax_t) width_per_block
);
1962 for (i
= 0; i
< n_specs
; i
++)
1964 int fields_per_block
= bytes_per_block
/ width_bytes
[spec
[i
].size
];
1965 affirm (bytes_per_block
% width_bytes
[spec
[i
].size
] == 0);
1966 affirm (1 <= spec
[i
].pad_width
/ fields_per_block
);
1967 printf ("%d: fmt=\"%s\" in_width=%d out_width=%d pad=%d\n",
1968 i
, spec
[i
].fmt_string
, width_bytes
[spec
[i
].size
],
1969 spec
[i
].field_width
, spec
[i
].pad_width
);
1973 ok
&= (flag_dump_strings
? dump_strings () : dump ());
1977 if (have_read_stdin
&& fclose (stdin
) == EOF
)
1978 error (EXIT_FAILURE
, errno
, _("standard input"));
1980 return ok
? EXIT_SUCCESS
: EXIT_FAILURE
;