diff options
author | Denis Vlasenko <vda.linux@googlemail.com> | 2006-10-10 23:26:05 +0000 |
---|---|---|
committer | Denis Vlasenko <vda.linux@googlemail.com> | 2006-10-10 23:26:05 +0000 |
commit | 1114de7219f8e42d6d883c476a9458f637806365 (patch) | |
tree | 7a77eafabd8476a7b41ec2c69d258c0e0fb32040 /coreutils/od_bloaty.c | |
parent | cba9ef5523f09ecc3240f9f6efcdd0440c652c91 (diff) | |
download | busybox-w32-1114de7219f8e42d6d883c476a9458f637806365.tar.gz busybox-w32-1114de7219f8e42d6d883c476a9458f637806365.tar.bz2 busybox-w32-1114de7219f8e42d6d883c476a9458f637806365.zip |
od: provide full-blown od from coreutils if CONFIG_DESKTOP
Diffstat (limited to 'coreutils/od_bloaty.c')
-rw-r--r-- | coreutils/od_bloaty.c | 1594 |
1 files changed, 1594 insertions, 0 deletions
diff --git a/coreutils/od_bloaty.c b/coreutils/od_bloaty.c new file mode 100644 index 000000000..a88ca25dc --- /dev/null +++ b/coreutils/od_bloaty.c | |||
@@ -0,0 +1,1594 @@ | |||
1 | /* od -- dump files in octal and other formats | ||
2 | Copyright (C) 92, 1995-2004 Free Software Foundation, Inc. | ||
3 | |||
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) | ||
7 | any later version. | ||
8 | |||
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. | ||
13 | |||
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. */ | ||
17 | |||
18 | /* Written by Jim Meyering. */ | ||
19 | |||
20 | /* Busyboxed by Denis Vlasenko | ||
21 | ** Based on od.c from coreutils-5.2.1 | ||
22 | ** Top bloat sources: | ||
23 | ** get_lcm 111 | ||
24 | ** print_ascii 145 | ||
25 | ** format_address_std 159 | ||
26 | ** check_and_close 160 | ||
27 | ** open_next_file 170 | ||
28 | ** write_block 368 | ||
29 | ** decode_format_string 1169 | ||
30 | ** od_main 2623 | ||
31 | ** TODO: get rid of getopt() | ||
32 | */ | ||
33 | |||
34 | #include "busybox.h" | ||
35 | #include <getopt.h> | ||
36 | |||
37 | #define assert(a) ((void)0) | ||
38 | #define ISPRINT(c) ((c)>=' ') | ||
39 | |||
40 | typedef long double longdouble_t; | ||
41 | typedef unsigned long long ulonglong_t; | ||
42 | #define xstrtoumax_sfx xstrtoul_sfx | ||
43 | #define xstrtoumax_range_sfx xstrtoul_range_sfx | ||
44 | |||
45 | /* The default number of input bytes per output line. */ | ||
46 | #define DEFAULT_BYTES_PER_BLOCK 16 | ||
47 | |||
48 | /* The number of decimal digits of precision in a float. */ | ||
49 | #ifndef FLT_DIG | ||
50 | # define FLT_DIG 7 | ||
51 | #endif | ||
52 | |||
53 | /* The number of decimal digits of precision in a double. */ | ||
54 | #ifndef DBL_DIG | ||
55 | # define DBL_DIG 15 | ||
56 | #endif | ||
57 | |||
58 | /* The number of decimal digits of precision in a long double. */ | ||
59 | #ifndef LDBL_DIG | ||
60 | # define LDBL_DIG DBL_DIG | ||
61 | #endif | ||
62 | |||
63 | enum size_spec { | ||
64 | NO_SIZE, | ||
65 | CHAR, | ||
66 | SHORT, | ||
67 | INT, | ||
68 | LONG, | ||
69 | LONG_LONG, | ||
70 | /* FIXME: add INTMAX support, too */ | ||
71 | FLOAT_SINGLE, | ||
72 | FLOAT_DOUBLE, | ||
73 | FLOAT_LONG_DOUBLE, | ||
74 | N_SIZE_SPECS | ||
75 | }; | ||
76 | |||
77 | enum output_format { | ||
78 | SIGNED_DECIMAL, | ||
79 | UNSIGNED_DECIMAL, | ||
80 | OCTAL, | ||
81 | HEXADECIMAL, | ||
82 | FLOATING_POINT, | ||
83 | NAMED_CHARACTER, | ||
84 | CHARACTER | ||
85 | }; | ||
86 | |||
87 | /* Each output format specification (from '-t spec' or from | ||
88 | old-style options) is represented by one of these structures. */ | ||
89 | struct tspec { | ||
90 | enum output_format fmt; | ||
91 | enum size_spec size; | ||
92 | void (*print_function) (size_t, const char *, const char *); | ||
93 | char *fmt_string; | ||
94 | int hexl_mode_trailer; | ||
95 | int field_width; | ||
96 | }; | ||
97 | |||
98 | /* Convert the number of 8-bit bytes of a binary representation to | ||
99 | the number of characters (digits + sign if the type is signed) | ||
100 | required to represent the same quantity in the specified base/type. | ||
101 | For example, a 32-bit (4-byte) quantity may require a field width | ||
102 | as wide as the following for these types: | ||
103 | 11 unsigned octal | ||
104 | 11 signed decimal | ||
105 | 10 unsigned decimal | ||
106 | 8 unsigned hexadecimal */ | ||
107 | |||
108 | static const unsigned char bytes_to_oct_digits[] = | ||
109 | {0, 3, 6, 8, 11, 14, 16, 19, 22, 25, 27, 30, 32, 35, 38, 41, 43}; | ||
110 | |||
111 | static const unsigned char bytes_to_signed_dec_digits[] = | ||
112 | {1, 4, 6, 8, 11, 13, 16, 18, 20, 23, 25, 28, 30, 33, 35, 37, 40}; | ||
113 | |||
114 | static const unsigned char bytes_to_unsigned_dec_digits[] = | ||
115 | {0, 3, 5, 8, 10, 13, 15, 17, 20, 22, 25, 27, 29, 32, 34, 37, 39}; | ||
116 | |||
117 | static const unsigned char bytes_to_hex_digits[] = | ||
118 | {0, 2, 4, 6, 8, 10, 12, 14, 16, 18, 20, 22, 24, 26, 28, 30, 32}; | ||
119 | |||
120 | /* Convert enum size_spec to the size of the named type. */ | ||
121 | static const signed char width_bytes[] = { | ||
122 | -1, | ||
123 | sizeof(char), | ||
124 | sizeof(short), | ||
125 | sizeof(int), | ||
126 | sizeof(long), | ||
127 | sizeof(ulonglong_t), | ||
128 | sizeof(float), | ||
129 | sizeof(double), | ||
130 | sizeof(longdouble_t) | ||
131 | }; | ||
132 | |||
133 | /* Ensure that for each member of 'enum size_spec' there is an | ||
134 | initializer in the width_bytes array. */ | ||
135 | struct dummy { | ||
136 | int assert_width_bytes_matches_size_spec_decl | ||
137 | [sizeof width_bytes / sizeof width_bytes[0] == N_SIZE_SPECS ? 1 : -1]; | ||
138 | }; | ||
139 | |||
140 | /* Names for some non-printing characters. */ | ||
141 | static const char charname[33][4] = { | ||
142 | "nul", "soh", "stx", "etx", "eot", "enq", "ack", "bel", | ||
143 | "bs", "ht", "nl", "vt", "ff", "cr", "so", "si", | ||
144 | "dle", "dc1", "dc2", "dc3", "dc4", "nak", "syn", "etb", | ||
145 | "can", "em", "sub", "esc", "fs", "gs", "rs", "us", | ||
146 | "sp" | ||
147 | }; | ||
148 | |||
149 | /* Address base (8, 10 or 16). */ | ||
150 | static int address_base; | ||
151 | |||
152 | /* The number of octal digits required to represent the largest | ||
153 | address value. */ | ||
154 | #define MAX_ADDRESS_LENGTH \ | ||
155 | ((sizeof(uintmax_t) * CHAR_BIT + CHAR_BIT - 1) / 3) | ||
156 | |||
157 | /* Width of a normal address. */ | ||
158 | static int address_pad_len; | ||
159 | |||
160 | static size_t string_min; | ||
161 | static int flag_dump_strings; | ||
162 | |||
163 | /* Non-zero if we should recognize the older non-option arguments | ||
164 | that specified at most one file and optional arguments specifying | ||
165 | offset and pseudo-start address. */ | ||
166 | static int traditional; | ||
167 | |||
168 | /* Non-zero if an old-style 'pseudo-address' was specified. */ | ||
169 | static int flag_pseudo_start; | ||
170 | |||
171 | /* The difference between the old-style pseudo starting address and | ||
172 | the number of bytes to skip. */ | ||
173 | static uintmax_t pseudo_offset; | ||
174 | |||
175 | /* Function that accepts an address and an optional following char, | ||
176 | and prints the address and char to stdout. */ | ||
177 | static void (*format_address) (uintmax_t, char); | ||
178 | |||
179 | /* The number of input bytes to skip before formatting and writing. */ | ||
180 | static uintmax_t n_bytes_to_skip; // = 0; | ||
181 | |||
182 | /* When zero, MAX_BYTES_TO_FORMAT and END_OFFSET are ignored, and all | ||
183 | input is formatted. */ | ||
184 | static int limit_bytes_to_format; // = 0; | ||
185 | |||
186 | /* The maximum number of bytes that will be formatted. */ | ||
187 | static uintmax_t max_bytes_to_format; | ||
188 | |||
189 | /* The offset of the first byte after the last byte to be formatted. */ | ||
190 | static uintmax_t end_offset; | ||
191 | |||
192 | /* When nonzero and two or more consecutive blocks are equal, format | ||
193 | only the first block and output an asterisk alone on the following | ||
194 | line to indicate that identical blocks have been elided. */ | ||
195 | static int abbreviate_duplicate_blocks = 1; | ||
196 | |||
197 | /* An array of specs describing how to format each input block. */ | ||
198 | static struct tspec *spec; | ||
199 | |||
200 | /* The number of format specs. */ | ||
201 | static size_t n_specs; | ||
202 | |||
203 | /* The number of input bytes formatted per output line. It must be | ||
204 | a multiple of the least common multiple of the sizes associated with | ||
205 | the specified output types. It should be as large as possible, but | ||
206 | no larger than 16 -- unless specified with the -w option. */ | ||
207 | static size_t bytes_per_block; | ||
208 | |||
209 | /* Human-readable representation of *file_list (for error messages). | ||
210 | It differs from *file_list only when *file_list is "-". */ | ||
211 | static char const *input_filename; | ||
212 | |||
213 | /* A NULL-terminated list of the file-arguments from the command line. */ | ||
214 | static char const *const *file_list; | ||
215 | |||
216 | /* Initializer for file_list if no file-arguments | ||
217 | were specified on the command line. */ | ||
218 | static char const *const default_file_list[] = {"-", NULL}; | ||
219 | |||
220 | /* The input stream associated with the current file. */ | ||
221 | static FILE *in_stream; | ||
222 | |||
223 | /* If nonzero, at least one of the files we read was standard input. */ | ||
224 | static int have_read_stdin; | ||
225 | |||
226 | #define MAX_INTEGRAL_TYPE_SIZE sizeof(ulonglong_t) | ||
227 | static unsigned char integral_type_size[MAX_INTEGRAL_TYPE_SIZE + 1]; | ||
228 | |||
229 | #define MAX_FP_TYPE_SIZE sizeof(longdouble_t) | ||
230 | static unsigned char fp_type_size[MAX_FP_TYPE_SIZE + 1]; | ||
231 | |||
232 | |||
233 | /* For long options that have no equivalent short option, use a | ||
234 | non-character as a pseudo short option, starting with CHAR_MAX + 1. */ | ||
235 | enum { | ||
236 | TRADITIONAL_OPTION = CHAR_MAX + 1 | ||
237 | }; | ||
238 | |||
239 | |||
240 | static unsigned | ||
241 | gcd(unsigned u, unsigned v) | ||
242 | { | ||
243 | unsigned t; | ||
244 | while (v != 0) { | ||
245 | t = u % v; | ||
246 | u = v; | ||
247 | v = t; | ||
248 | } | ||
249 | return u; | ||
250 | } | ||
251 | |||
252 | /* Compute the least common multiple of U and V. */ | ||
253 | static unsigned | ||
254 | lcm(unsigned u, unsigned v) { | ||
255 | unsigned t = gcd(u, v); | ||
256 | if (t == 0) | ||
257 | return 0; | ||
258 | return u * v / t; | ||
259 | } | ||
260 | |||
261 | static void | ||
262 | print_s_char(size_t n_bytes, const char *block, const char *fmt_string) | ||
263 | { | ||
264 | size_t i; | ||
265 | for (i = n_bytes; i > 0; i--) { | ||
266 | int tmp = (unsigned) *(unsigned char *) block; | ||
267 | if (tmp > SCHAR_MAX) | ||
268 | tmp -= SCHAR_MAX - SCHAR_MIN + 1; | ||
269 | assert(tmp <= SCHAR_MAX); | ||
270 | printf(fmt_string, tmp); | ||
271 | block += sizeof(unsigned char); | ||
272 | } | ||
273 | } | ||
274 | |||
275 | static void | ||
276 | print_char(size_t n_bytes, const char *block, const char *fmt_string) | ||
277 | { | ||
278 | size_t i; | ||
279 | for (i = n_bytes; i > 0; i--) { | ||
280 | unsigned tmp = *(unsigned char *) block; | ||
281 | printf(fmt_string, tmp); | ||
282 | block += sizeof(unsigned char); | ||
283 | } | ||
284 | } | ||
285 | |||
286 | static void | ||
287 | print_s_short(size_t n_bytes, const char *block, const char *fmt_string) | ||
288 | { | ||
289 | size_t i; | ||
290 | for (i = n_bytes / sizeof(unsigned short); i > 0; i--) { | ||
291 | int tmp = (unsigned) *(unsigned short *) block; | ||
292 | if (tmp > SHRT_MAX) | ||
293 | tmp -= SHRT_MAX - SHRT_MIN + 1; | ||
294 | assert(tmp <= SHRT_MAX); | ||
295 | printf(fmt_string, tmp); | ||
296 | block += sizeof(unsigned short); | ||
297 | } | ||
298 | } | ||
299 | |||
300 | static void | ||
301 | print_short(size_t n_bytes, const char *block, const char *fmt_string) | ||
302 | { | ||
303 | size_t i; | ||
304 | for (i = n_bytes / sizeof(unsigned short); i > 0; i--) { | ||
305 | unsigned tmp = *(unsigned short *) block; | ||
306 | printf(fmt_string, tmp); | ||
307 | block += sizeof(unsigned short); | ||
308 | } | ||
309 | } | ||
310 | |||
311 | static void | ||
312 | print_int(size_t n_bytes, const char *block, const char *fmt_string) | ||
313 | { | ||
314 | size_t i; | ||
315 | for (i = n_bytes / sizeof(unsigned); i > 0; i--) { | ||
316 | unsigned tmp = *(unsigned *) block; | ||
317 | printf(fmt_string, tmp); | ||
318 | block += sizeof(unsigned); | ||
319 | } | ||
320 | } | ||
321 | |||
322 | static void | ||
323 | print_long(size_t n_bytes, const char *block, const char *fmt_string) | ||
324 | { | ||
325 | size_t i; | ||
326 | for (i = n_bytes / sizeof(unsigned long); i > 0; i--) { | ||
327 | unsigned long tmp = *(unsigned long *) block; | ||
328 | printf(fmt_string, tmp); | ||
329 | block += sizeof(unsigned long); | ||
330 | } | ||
331 | } | ||
332 | |||
333 | static void | ||
334 | print_long_long(size_t n_bytes, const char *block, const char *fmt_string) | ||
335 | { | ||
336 | size_t i; | ||
337 | for (i = n_bytes / sizeof(ulonglong_t); i > 0; i--) { | ||
338 | ulonglong_t tmp = *(ulonglong_t *) block; | ||
339 | printf(fmt_string, tmp); | ||
340 | block += sizeof(ulonglong_t); | ||
341 | } | ||
342 | } | ||
343 | |||
344 | static void | ||
345 | print_float(size_t n_bytes, const char *block, const char *fmt_string) | ||
346 | { | ||
347 | size_t i; | ||
348 | for (i = n_bytes / sizeof(float); i > 0; i--) { | ||
349 | float tmp = *(float *) block; | ||
350 | printf(fmt_string, tmp); | ||
351 | block += sizeof(float); | ||
352 | } | ||
353 | } | ||
354 | |||
355 | static void | ||
356 | print_double(size_t n_bytes, const char *block, const char *fmt_string) | ||
357 | { | ||
358 | size_t i; | ||
359 | for (i = n_bytes / sizeof(double); i > 0; i--) { | ||
360 | double tmp = *(double *) block; | ||
361 | printf(fmt_string, tmp); | ||
362 | block += sizeof(double); | ||
363 | } | ||
364 | } | ||
365 | |||
366 | static void | ||
367 | print_long_double(size_t n_bytes, const char *block, const char *fmt_string) | ||
368 | { | ||
369 | size_t i; | ||
370 | for (i = n_bytes / sizeof(longdouble_t); i > 0; i--) { | ||
371 | longdouble_t tmp = *(longdouble_t *) block; | ||
372 | printf(fmt_string, tmp); | ||
373 | block += sizeof(longdouble_t); | ||
374 | } | ||
375 | } | ||
376 | |||
377 | static void | ||
378 | dump_hexl_mode_trailer(size_t n_bytes, const char *block) | ||
379 | { | ||
380 | size_t i; | ||
381 | fputs(" >", stdout); | ||
382 | for (i = n_bytes; i > 0; i--) { | ||
383 | unsigned c = *(unsigned char *) block; | ||
384 | unsigned c2 = (ISPRINT(c) ? c : '.'); | ||
385 | putchar(c2); | ||
386 | block += sizeof(unsigned char); | ||
387 | } | ||
388 | putchar('<'); | ||
389 | } | ||
390 | |||
391 | static void | ||
392 | print_named_ascii(size_t n_bytes, const char *block, | ||
393 | const char *unused_fmt_string ATTRIBUTE_UNUSED) | ||
394 | { | ||
395 | size_t i; | ||
396 | for (i = n_bytes; i > 0; i--) { | ||
397 | unsigned c = *(unsigned char *) block; | ||
398 | unsigned masked_c = (0x7f & c); | ||
399 | const char *s; | ||
400 | char buf[5]; | ||
401 | |||
402 | if (masked_c == 127) | ||
403 | s = "del"; | ||
404 | else if (masked_c <= 040) | ||
405 | s = charname[masked_c]; | ||
406 | else { | ||
407 | sprintf(buf, " %c", masked_c); | ||
408 | s = buf; | ||
409 | } | ||
410 | |||
411 | printf(" %3s", s); | ||
412 | block += sizeof(unsigned char); | ||
413 | } | ||
414 | } | ||
415 | |||
416 | static void | ||
417 | print_ascii(size_t n_bytes, const char *block, | ||
418 | const char *unused_fmt_string ATTRIBUTE_UNUSED) | ||
419 | { | ||
420 | size_t i; | ||
421 | for (i = n_bytes; i > 0; i--) { | ||
422 | unsigned c = *(unsigned char *) block; | ||
423 | const char *s; | ||
424 | char buf[5]; | ||
425 | |||
426 | switch (c) { | ||
427 | case '\0': | ||
428 | s = " \\0"; | ||
429 | break; | ||
430 | case '\007': | ||
431 | s = " \\a"; | ||
432 | break; | ||
433 | case '\b': | ||
434 | s = " \\b"; | ||
435 | break; | ||
436 | case '\f': | ||
437 | s = " \\f"; | ||
438 | break; | ||
439 | case '\n': | ||
440 | s = " \\n"; | ||
441 | break; | ||
442 | case '\r': | ||
443 | s = " \\r"; | ||
444 | break; | ||
445 | case '\t': | ||
446 | s = " \\t"; | ||
447 | break; | ||
448 | case '\v': | ||
449 | s = " \\v"; | ||
450 | break; | ||
451 | default: | ||
452 | sprintf(buf, (ISPRINT(c) ? " %c" : "%03o"), c); | ||
453 | s = (const char *) buf; | ||
454 | } | ||
455 | |||
456 | printf(" %3s", s); | ||
457 | block += sizeof(unsigned char); | ||
458 | } | ||
459 | } | ||
460 | |||
461 | /* If S points to a single valid modern od format string, put | ||
462 | a description of that format in *TSPEC, make *NEXT point at the | ||
463 | character following the just-decoded format (if *NEXT is non-NULL), | ||
464 | and return zero. If S is not valid, don't modify *NEXT or *TSPEC, | ||
465 | give a diagnostic, and return nonzero. For example, if S were | ||
466 | "d4afL" *NEXT would be set to "afL" and *TSPEC would be | ||
467 | { | ||
468 | fmt = SIGNED_DECIMAL; | ||
469 | size = INT or LONG; (whichever integral_type_size[4] resolves to) | ||
470 | print_function = print_int; (assuming size == INT) | ||
471 | fmt_string = "%011d%c"; | ||
472 | } | ||
473 | S_ORIG is solely for reporting errors. It should be the full format | ||
474 | string argument. | ||
475 | */ | ||
476 | |||
477 | static int | ||
478 | decode_one_format(const char *s_orig, const char *s, const char **next, | ||
479 | struct tspec *tspec) | ||
480 | { | ||
481 | enum size_spec size_spec; | ||
482 | unsigned long size; | ||
483 | enum output_format fmt; | ||
484 | const char *pre_fmt_string; | ||
485 | char *end; | ||
486 | char *fmt_string; | ||
487 | void (*print_function) (size_t, const char *, const char *); | ||
488 | unsigned c; | ||
489 | unsigned field_width = 0; | ||
490 | |||
491 | assert(tspec != NULL); | ||
492 | |||
493 | switch (*s) { | ||
494 | case 'd': | ||
495 | case 'o': | ||
496 | case 'u': | ||
497 | case 'x': | ||
498 | c = *s; | ||
499 | ++s; | ||
500 | switch (*s) { | ||
501 | case 'C': | ||
502 | ++s; | ||
503 | size = sizeof(char); | ||
504 | break; | ||
505 | case 'S': | ||
506 | ++s; | ||
507 | size = sizeof(short); | ||
508 | break; | ||
509 | case 'I': | ||
510 | ++s; | ||
511 | size = sizeof(int); | ||
512 | break; | ||
513 | case 'L': | ||
514 | ++s; | ||
515 | size = sizeof(long); | ||
516 | break; | ||
517 | default: | ||
518 | size = sizeof(int); | ||
519 | if (isdigit(s[0])) { | ||
520 | size = strtoul(s, &end, 0); | ||
521 | if (end[0] || MAX_INTEGRAL_TYPE_SIZE < size | ||
522 | || integral_type_size[size] == NO_SIZE | ||
523 | ) { | ||
524 | bb_error_msg("invalid type string '%s'; " | ||
525 | "%lu-byte integral type is not spported", s_orig, size); | ||
526 | return 1; | ||
527 | } | ||
528 | s = end; | ||
529 | } | ||
530 | break; | ||
531 | } | ||
532 | |||
533 | #define ISPEC_TO_FORMAT(Spec, Min_format, Long_format, Max_format) \ | ||
534 | ((Spec) == LONG_LONG ? (Max_format) \ | ||
535 | : ((Spec) == LONG ? (Long_format) : (Min_format))) | ||
536 | |||
537 | #define FMT_BYTES_ALLOCATED 9 | ||
538 | fmt_string = xmalloc(FMT_BYTES_ALLOCATED); | ||
539 | |||
540 | size_spec = integral_type_size[size]; | ||
541 | |||
542 | switch (c) { | ||
543 | case 'd': | ||
544 | fmt = SIGNED_DECIMAL; | ||
545 | sprintf(fmt_string, " %%%u%s", | ||
546 | (field_width = bytes_to_signed_dec_digits[size]), | ||
547 | ISPEC_TO_FORMAT(size_spec, "d", "ld", PRIdMAX)); | ||
548 | break; | ||
549 | case 'o': | ||
550 | fmt = OCTAL; | ||
551 | sprintf(fmt_string, " %%0%u%s", | ||
552 | (field_width = bytes_to_oct_digits[size]), | ||
553 | ISPEC_TO_FORMAT(size_spec, "o", "lo", PRIoMAX)); | ||
554 | break; | ||
555 | case 'u': | ||
556 | fmt = UNSIGNED_DECIMAL; | ||
557 | sprintf(fmt_string, " %%%u%s", | ||
558 | (field_width = bytes_to_unsigned_dec_digits[size]), | ||
559 | ISPEC_TO_FORMAT(size_spec, "u", "lu", PRIuMAX)); | ||
560 | break; | ||
561 | case 'x': | ||
562 | fmt = HEXADECIMAL; | ||
563 | sprintf(fmt_string, " %%0%u%s", | ||
564 | (field_width = bytes_to_hex_digits[size]), | ||
565 | ISPEC_TO_FORMAT(size_spec, "x", "lx", PRIxMAX)); | ||
566 | break; | ||
567 | default: | ||
568 | abort(); | ||
569 | } | ||
570 | |||
571 | assert(strlen(fmt_string) < FMT_BYTES_ALLOCATED); | ||
572 | |||
573 | switch (size_spec) { | ||
574 | case CHAR: | ||
575 | print_function = (fmt == SIGNED_DECIMAL | ||
576 | ? print_s_char | ||
577 | : print_char); | ||
578 | break; | ||
579 | case SHORT: | ||
580 | print_function = (fmt == SIGNED_DECIMAL | ||
581 | ? print_s_short | ||
582 | : print_short); | ||
583 | break; | ||
584 | case INT: | ||
585 | print_function = print_int; | ||
586 | break; | ||
587 | case LONG: | ||
588 | print_function = print_long; | ||
589 | break; | ||
590 | case LONG_LONG: | ||
591 | print_function = print_long_long; | ||
592 | break; | ||
593 | default: | ||
594 | abort(); | ||
595 | } | ||
596 | break; | ||
597 | |||
598 | case 'f': | ||
599 | fmt = FLOATING_POINT; | ||
600 | ++s; | ||
601 | switch (*s) { | ||
602 | case 'F': | ||
603 | ++s; | ||
604 | size = sizeof(float); | ||
605 | break; | ||
606 | case 'D': | ||
607 | ++s; | ||
608 | size = sizeof(double); | ||
609 | break; | ||
610 | case 'L': | ||
611 | ++s; | ||
612 | size = sizeof(longdouble_t); | ||
613 | break; | ||
614 | default: | ||
615 | size = sizeof(double); | ||
616 | if (isdigit(s[0])) { | ||
617 | size = strtoul(s, &end, 0); | ||
618 | if (end[0] || size > MAX_FP_TYPE_SIZE | ||
619 | || fp_type_size[size] == NO_SIZE | ||
620 | ) { | ||
621 | bb_error_msg("invalid type string '%s'; " | ||
622 | "%lu-byte floating point type is not supported", s_orig, size); | ||
623 | return 1; | ||
624 | } | ||
625 | s = end; | ||
626 | } | ||
627 | break; | ||
628 | } | ||
629 | size_spec = fp_type_size[size]; | ||
630 | |||
631 | switch (size_spec) { | ||
632 | case FLOAT_SINGLE: | ||
633 | print_function = print_float; | ||
634 | /* Don't use %#e; not all systems support it. */ | ||
635 | pre_fmt_string = " %%%d.%de"; | ||
636 | fmt_string = xmalloc(strlen(pre_fmt_string)); | ||
637 | sprintf(fmt_string, pre_fmt_string, | ||
638 | (field_width = FLT_DIG + 8), FLT_DIG); | ||
639 | break; | ||
640 | case FLOAT_DOUBLE: | ||
641 | print_function = print_double; | ||
642 | pre_fmt_string = " %%%d.%de"; | ||
643 | fmt_string = xmalloc(strlen(pre_fmt_string)); | ||
644 | sprintf(fmt_string, pre_fmt_string, | ||
645 | (field_width = DBL_DIG + 8), DBL_DIG); | ||
646 | break; | ||
647 | case FLOAT_LONG_DOUBLE: | ||
648 | print_function = print_long_double; | ||
649 | pre_fmt_string = " %%%d.%dLe"; | ||
650 | fmt_string = xmalloc(strlen(pre_fmt_string)); | ||
651 | sprintf(fmt_string, pre_fmt_string, | ||
652 | (field_width = LDBL_DIG + 8), LDBL_DIG); | ||
653 | break; | ||
654 | default: | ||
655 | abort(); | ||
656 | } | ||
657 | break; | ||
658 | |||
659 | case 'a': | ||
660 | ++s; | ||
661 | fmt = NAMED_CHARACTER; | ||
662 | size_spec = CHAR; | ||
663 | fmt_string = NULL; | ||
664 | print_function = print_named_ascii; | ||
665 | field_width = 3; | ||
666 | break; | ||
667 | case 'c': | ||
668 | ++s; | ||
669 | fmt = CHARACTER; | ||
670 | size_spec = CHAR; | ||
671 | fmt_string = NULL; | ||
672 | print_function = print_ascii; | ||
673 | field_width = 3; | ||
674 | break; | ||
675 | default: | ||
676 | bb_error_msg("invalid character '%c' in type string '%s'", *s, s_orig); | ||
677 | return 1; | ||
678 | } | ||
679 | |||
680 | tspec->size = size_spec; | ||
681 | tspec->fmt = fmt; | ||
682 | tspec->print_function = print_function; | ||
683 | tspec->fmt_string = fmt_string; | ||
684 | |||
685 | tspec->field_width = field_width; | ||
686 | tspec->hexl_mode_trailer = (*s == 'z'); | ||
687 | if (tspec->hexl_mode_trailer) | ||
688 | s++; | ||
689 | |||
690 | if (next != NULL) | ||
691 | *next = s; | ||
692 | |||
693 | return 0; | ||
694 | } | ||
695 | |||
696 | /* Given a list of one or more input filenames FILE_LIST, set the global | ||
697 | file pointer IN_STREAM and the global string INPUT_FILENAME to the | ||
698 | first one that can be successfully opened. Modify FILE_LIST to | ||
699 | reference the next filename in the list. A file name of "-" is | ||
700 | interpreted as standard input. If any file open fails, give an error | ||
701 | message and return nonzero. */ | ||
702 | |||
703 | static int | ||
704 | open_next_file(void) | ||
705 | { | ||
706 | int err = 0; | ||
707 | |||
708 | do { | ||
709 | input_filename = *file_list; | ||
710 | if (input_filename == NULL) | ||
711 | return err; | ||
712 | ++file_list; | ||
713 | |||
714 | if (input_filename[0] == '-' && !input_filename[1]) { | ||
715 | input_filename = "standard input"; | ||
716 | in_stream = stdin; | ||
717 | have_read_stdin = 1; | ||
718 | } else { | ||
719 | in_stream = fopen(input_filename, "r"); | ||
720 | if (in_stream == NULL) { | ||
721 | bb_perror_msg("%s", input_filename); | ||
722 | err = 1; | ||
723 | } | ||
724 | } | ||
725 | } while (in_stream == NULL); | ||
726 | |||
727 | if (limit_bytes_to_format && !flag_dump_strings) | ||
728 | setbuf(in_stream, NULL); | ||
729 | |||
730 | return err; | ||
731 | } | ||
732 | |||
733 | /* Test whether there have been errors on in_stream, and close it if | ||
734 | it is not standard input. Return nonzero if there has been an error | ||
735 | on in_stream or stdout; return zero otherwise. This function will | ||
736 | report more than one error only if both a read and a write error | ||
737 | have occurred. IN_ERRNO, if nonzero, is the error number | ||
738 | corresponding to the most recent action for IN_STREAM. */ | ||
739 | |||
740 | static int | ||
741 | check_and_close(int in_errno) | ||
742 | { | ||
743 | int err = 0; | ||
744 | |||
745 | if (in_stream != NULL) { | ||
746 | if (ferror(in_stream)) { | ||
747 | bb_error_msg("%s: read error", input_filename); | ||
748 | if (in_stream != stdin) | ||
749 | fclose(in_stream); | ||
750 | err = 1; | ||
751 | } else if (in_stream != stdin && fclose(in_stream) == EOF) { | ||
752 | bb_perror_msg("%s", input_filename); | ||
753 | err = 1; | ||
754 | } | ||
755 | in_stream = NULL; | ||
756 | } | ||
757 | |||
758 | if (ferror(stdout)) { | ||
759 | bb_error_msg("write error"); | ||
760 | err = 1; | ||
761 | } | ||
762 | |||
763 | return err; | ||
764 | } | ||
765 | |||
766 | /* Decode the modern od format string S. Append the decoded | ||
767 | representation to the global array SPEC, reallocating SPEC if | ||
768 | necessary. Return zero if S is valid, nonzero otherwise. */ | ||
769 | |||
770 | static int | ||
771 | decode_format_string(const char *s) | ||
772 | { | ||
773 | const char *s_orig = s; | ||
774 | assert(s != NULL); | ||
775 | |||
776 | while (*s != '\0') { | ||
777 | struct tspec tspec; | ||
778 | const char *next; | ||
779 | |||
780 | if (decode_one_format(s_orig, s, &next, &tspec)) | ||
781 | return 1; | ||
782 | |||
783 | assert(s != next); | ||
784 | s = next; | ||
785 | n_specs++; | ||
786 | spec = xrealloc(spec, n_specs * sizeof(*spec)); | ||
787 | memcpy(&spec[n_specs-1], &tspec, sizeof *spec); | ||
788 | } | ||
789 | |||
790 | return 0; | ||
791 | } | ||
792 | |||
793 | /* Given a list of one or more input filenames FILE_LIST, set the global | ||
794 | file pointer IN_STREAM to position N_SKIP in the concatenation of | ||
795 | those files. If any file operation fails or if there are fewer than | ||
796 | N_SKIP bytes in the combined input, give an error message and return | ||
797 | nonzero. When possible, use seek rather than read operations to | ||
798 | advance IN_STREAM. */ | ||
799 | |||
800 | static int | ||
801 | skip(uintmax_t n_skip) | ||
802 | { | ||
803 | int err = 0; | ||
804 | int in_errno = 0; | ||
805 | |||
806 | if (n_skip == 0) | ||
807 | return 0; | ||
808 | |||
809 | while (in_stream != NULL) { /* EOF */ | ||
810 | struct stat file_stats; | ||
811 | |||
812 | /* First try seeking. For large offsets, this extra work is | ||
813 | worthwhile. If the offset is below some threshold it may be | ||
814 | more efficient to move the pointer by reading. There are two | ||
815 | issues when trying to seek: | ||
816 | - the file must be seekable. | ||
817 | - before seeking to the specified position, make sure | ||
818 | that the new position is in the current file. | ||
819 | Try to do that by getting file's size using fstat. | ||
820 | But that will work only for regular files. */ | ||
821 | |||
822 | if (fstat(fileno(in_stream), &file_stats) == 0) { | ||
823 | /* The st_size field is valid only for regular files | ||
824 | (and for symbolic links, which cannot occur here). | ||
825 | If the number of bytes left to skip is at least | ||
826 | as large as the size of the current file, we can | ||
827 | decrement n_skip and go on to the next file. */ | ||
828 | |||
829 | if (S_ISREG(file_stats.st_mode) && 0 <= file_stats.st_size) { | ||
830 | if ((uintmax_t) file_stats.st_size <= n_skip) | ||
831 | n_skip -= file_stats.st_size; | ||
832 | else { | ||
833 | if (fseeko(in_stream, n_skip, SEEK_CUR) != 0) { | ||
834 | in_errno = errno; | ||
835 | err = 1; | ||
836 | } | ||
837 | n_skip = 0; | ||
838 | } | ||
839 | } else { | ||
840 | |||
841 | /* If it's not a regular file with nonnegative size, | ||
842 | position the file pointer by reading. */ | ||
843 | char buf[BUFSIZ]; | ||
844 | size_t n_bytes_read, n_bytes_to_read = BUFSIZ; | ||
845 | |||
846 | while (0 < n_skip) { | ||
847 | if (n_skip < n_bytes_to_read) | ||
848 | n_bytes_to_read = n_skip; | ||
849 | n_bytes_read = fread(buf, 1, n_bytes_to_read, in_stream); | ||
850 | n_skip -= n_bytes_read; | ||
851 | if (n_bytes_read != n_bytes_to_read) { | ||
852 | in_errno = errno; | ||
853 | err = 1; | ||
854 | n_skip = 0; | ||
855 | break; | ||
856 | } | ||
857 | } | ||
858 | } | ||
859 | if (n_skip == 0) | ||
860 | break; | ||
861 | } else { /* cannot fstat() file */ | ||
862 | bb_perror_msg("%s", input_filename); | ||
863 | err = 1; | ||
864 | } | ||
865 | |||
866 | err |= check_and_close(in_errno); | ||
867 | err |= open_next_file(); | ||
868 | } | ||
869 | |||
870 | if (n_skip != 0) | ||
871 | bb_error_msg_and_die("cannot skip past end of combined input"); | ||
872 | return err; | ||
873 | } | ||
874 | |||
875 | static void | ||
876 | format_address_none(uintmax_t address ATTRIBUTE_UNUSED, char c ATTRIBUTE_UNUSED) | ||
877 | { | ||
878 | } | ||
879 | |||
880 | static void | ||
881 | format_address_std(uintmax_t address, char c) | ||
882 | { | ||
883 | char buf[MAX_ADDRESS_LENGTH + 2]; | ||
884 | char *p = buf + sizeof(buf)-1; | ||
885 | char const *pbound; | ||
886 | |||
887 | *p = '\0'; | ||
888 | *--p = c; | ||
889 | pbound = p - address_pad_len; | ||
890 | |||
891 | do { | ||
892 | *--p = "0123456789abcdef"[address % address_base]; | ||
893 | address /= address_base; | ||
894 | } while (address); | ||
895 | |||
896 | while (pbound < p) | ||
897 | *--p = '0'; | ||
898 | fputs(p, stdout); | ||
899 | } | ||
900 | |||
901 | static void | ||
902 | format_address_paren(uintmax_t address, char c) | ||
903 | { | ||
904 | putchar('('); | ||
905 | format_address_std(address, ')'); | ||
906 | putchar(c); | ||
907 | } | ||
908 | |||
909 | static void | ||
910 | format_address_label(uintmax_t address, char c) | ||
911 | { | ||
912 | format_address_std(address, ' '); | ||
913 | format_address_paren(address + pseudo_offset, c); | ||
914 | } | ||
915 | |||
916 | /* Write N_BYTES bytes from CURR_BLOCK to standard output once for each | ||
917 | of the N_SPEC format specs. CURRENT_OFFSET is the byte address of | ||
918 | CURR_BLOCK in the concatenation of input files, and it is printed | ||
919 | (optionally) only before the output line associated with the first | ||
920 | format spec. When duplicate blocks are being abbreviated, the output | ||
921 | for a sequence of identical input blocks is the output for the first | ||
922 | block followed by an asterisk alone on a line. It is valid to compare | ||
923 | the blocks PREV_BLOCK and CURR_BLOCK only when N_BYTES == BYTES_PER_BLOCK. | ||
924 | That condition may be false only for the last input block -- and then | ||
925 | only when it has not been padded to length BYTES_PER_BLOCK. */ | ||
926 | |||
927 | static void | ||
928 | write_block(uintmax_t current_offset, size_t n_bytes, | ||
929 | const char *prev_block, const char *curr_block) | ||
930 | { | ||
931 | static int first = 1; | ||
932 | static int prev_pair_equal = 0; | ||
933 | |||
934 | if (abbreviate_duplicate_blocks | ||
935 | && !first | ||
936 | && n_bytes == bytes_per_block | ||
937 | && memcmp(prev_block, curr_block, bytes_per_block) == 0 | ||
938 | ) { | ||
939 | if (prev_pair_equal) { | ||
940 | /* The two preceding blocks were equal, and the current | ||
941 | block is the same as the last one, so print nothing. */ | ||
942 | } else { | ||
943 | puts("*"); | ||
944 | prev_pair_equal = 1; | ||
945 | } | ||
946 | } else { | ||
947 | size_t i; | ||
948 | |||
949 | prev_pair_equal = 0; | ||
950 | for (i = 0; i < n_specs; i++) { | ||
951 | if (i == 0) | ||
952 | format_address(current_offset, '\0'); | ||
953 | else | ||
954 | printf("%*s", address_pad_len, ""); | ||
955 | (*spec[i].print_function) (n_bytes, curr_block, spec[i].fmt_string); | ||
956 | if (spec[i].hexl_mode_trailer) { | ||
957 | /* space-pad out to full line width, then dump the trailer */ | ||
958 | int datum_width = width_bytes[spec[i].size]; | ||
959 | int blank_fields = (bytes_per_block - n_bytes) / datum_width; | ||
960 | int field_width = spec[i].field_width + 1; | ||
961 | printf("%*s", blank_fields * field_width, ""); | ||
962 | dump_hexl_mode_trailer(n_bytes, curr_block); | ||
963 | } | ||
964 | putchar('\n'); | ||
965 | } | ||
966 | } | ||
967 | first = 0; | ||
968 | } | ||
969 | |||
970 | /* Read a single byte into *C from the concatenation of the input files | ||
971 | named in the global array FILE_LIST. On the first call to this | ||
972 | function, the global variable IN_STREAM is expected to be an open | ||
973 | stream associated with the input file INPUT_FILENAME. If IN_STREAM | ||
974 | is at end-of-file, close it and update the global variables IN_STREAM | ||
975 | and INPUT_FILENAME so they correspond to the next file in the list. | ||
976 | Then try to read a byte from the newly opened file. Repeat if | ||
977 | necessary until EOF is reached for the last file in FILE_LIST, then | ||
978 | set *C to EOF and return. Subsequent calls do likewise. The return | ||
979 | value is nonzero if any errors occured, zero otherwise. */ | ||
980 | |||
981 | static int | ||
982 | read_char(int *c) | ||
983 | { | ||
984 | int err = 0; | ||
985 | |||
986 | *c = EOF; | ||
987 | |||
988 | while (in_stream != NULL) { /* EOF. */ | ||
989 | *c = fgetc(in_stream); | ||
990 | if (*c != EOF) | ||
991 | break; | ||
992 | err |= check_and_close(errno); | ||
993 | err |= open_next_file(); | ||
994 | } | ||
995 | |||
996 | return err; | ||
997 | } | ||
998 | |||
999 | /* Read N bytes into BLOCK from the concatenation of the input files | ||
1000 | named in the global array FILE_LIST. On the first call to this | ||
1001 | function, the global variable IN_STREAM is expected to be an open | ||
1002 | stream associated with the input file INPUT_FILENAME. If all N | ||
1003 | bytes cannot be read from IN_STREAM, close IN_STREAM and update | ||
1004 | the global variables IN_STREAM and INPUT_FILENAME. Then try to | ||
1005 | read the remaining bytes from the newly opened file. Repeat if | ||
1006 | necessary until EOF is reached for the last file in FILE_LIST. | ||
1007 | On subsequent calls, don't modify BLOCK and return zero. Set | ||
1008 | *N_BYTES_IN_BUFFER to the number of bytes read. If an error occurs, | ||
1009 | it will be detected through ferror when the stream is about to be | ||
1010 | closed. If there is an error, give a message but continue reading | ||
1011 | as usual and return nonzero. Otherwise return zero. */ | ||
1012 | |||
1013 | static int | ||
1014 | read_block(size_t n, char *block, size_t *n_bytes_in_buffer) | ||
1015 | { | ||
1016 | int err = 0; | ||
1017 | |||
1018 | assert(0 < n && n <= bytes_per_block); | ||
1019 | |||
1020 | *n_bytes_in_buffer = 0; | ||
1021 | |||
1022 | if (n == 0) | ||
1023 | return 0; | ||
1024 | |||
1025 | while (in_stream != NULL) { /* EOF. */ | ||
1026 | size_t n_needed; | ||
1027 | size_t n_read; | ||
1028 | |||
1029 | n_needed = n - *n_bytes_in_buffer; | ||
1030 | n_read = fread(block + *n_bytes_in_buffer, 1, n_needed, in_stream); | ||
1031 | *n_bytes_in_buffer += n_read; | ||
1032 | if (n_read == n_needed) | ||
1033 | break; | ||
1034 | err |= check_and_close(errno); | ||
1035 | err |= open_next_file(); | ||
1036 | } | ||
1037 | |||
1038 | return err; | ||
1039 | } | ||
1040 | |||
1041 | /* Return the least common multiple of the sizes associated | ||
1042 | with the format specs. */ | ||
1043 | |||
1044 | static int | ||
1045 | get_lcm(void) | ||
1046 | { | ||
1047 | size_t i; | ||
1048 | int l_c_m = 1; | ||
1049 | |||
1050 | for (i = 0; i < n_specs; i++) | ||
1051 | l_c_m = lcm(l_c_m, width_bytes[(int) spec[i].size]); | ||
1052 | return l_c_m; | ||
1053 | } | ||
1054 | |||
1055 | /* If S is a valid traditional offset specification with an optional | ||
1056 | leading '+' return nonzero and set *OFFSET to the offset it denotes. */ | ||
1057 | |||
1058 | static int | ||
1059 | parse_old_offset(const char *s, uintmax_t *offset) | ||
1060 | { | ||
1061 | static const struct suffix_mult Bb[] = { | ||
1062 | { "B", 1024 }, | ||
1063 | { "b", 512 }, | ||
1064 | { NULL, 0 } | ||
1065 | }; | ||
1066 | |||
1067 | int radix; | ||
1068 | |||
1069 | if (*s == '\0') | ||
1070 | return 0; | ||
1071 | |||
1072 | /* Skip over any leading '+'. */ | ||
1073 | if (s[0] == '+') | ||
1074 | ++s; | ||
1075 | |||
1076 | /* Determine the radix we'll use to interpret S. If there is a '.', | ||
1077 | it's decimal, otherwise, if the string begins with '0X'or '0x', | ||
1078 | it's hexadecimal, else octal. */ | ||
1079 | if (strchr(s, '.') != NULL) | ||
1080 | radix = 10; | ||
1081 | else { | ||
1082 | if (s[0] == '0' && (s[1] == 'x' || s[1] == 'X')) | ||
1083 | radix = 16; | ||
1084 | else | ||
1085 | radix = 8; | ||
1086 | } | ||
1087 | |||
1088 | *offset = xstrtoumax_sfx(s, radix, Bb); | ||
1089 | return 1; | ||
1090 | } | ||
1091 | |||
1092 | /* Read a chunk of size BYTES_PER_BLOCK from the input files, write the | ||
1093 | formatted block to standard output, and repeat until the specified | ||
1094 | maximum number of bytes has been read or until all input has been | ||
1095 | processed. If the last block read is smaller than BYTES_PER_BLOCK | ||
1096 | and its size is not a multiple of the size associated with a format | ||
1097 | spec, extend the input block with zero bytes until its length is a | ||
1098 | multiple of all format spec sizes. Write the final block. Finally, | ||
1099 | write on a line by itself the offset of the byte after the last byte | ||
1100 | read. Accumulate return values from calls to read_block and | ||
1101 | check_and_close, and if any was nonzero, return nonzero. | ||
1102 | Otherwise, return zero. */ | ||
1103 | |||
1104 | static int | ||
1105 | dump(void) | ||
1106 | { | ||
1107 | char *block[2]; | ||
1108 | uintmax_t current_offset; | ||
1109 | int idx; | ||
1110 | int err; | ||
1111 | size_t n_bytes_read; | ||
1112 | |||
1113 | block[0] = xmalloc(2*bytes_per_block); | ||
1114 | block[1] = block[0] + bytes_per_block; | ||
1115 | |||
1116 | current_offset = n_bytes_to_skip; | ||
1117 | |||
1118 | idx = 0; | ||
1119 | err = 0; | ||
1120 | if (limit_bytes_to_format) { | ||
1121 | while (1) { | ||
1122 | size_t n_needed; | ||
1123 | if (current_offset >= end_offset) { | ||
1124 | n_bytes_read = 0; | ||
1125 | break; | ||
1126 | } | ||
1127 | n_needed = MIN(end_offset - current_offset, | ||
1128 | (uintmax_t) bytes_per_block); | ||
1129 | err |= read_block(n_needed, block[idx], &n_bytes_read); | ||
1130 | if (n_bytes_read < bytes_per_block) | ||
1131 | break; | ||
1132 | assert(n_bytes_read == bytes_per_block); | ||
1133 | write_block(current_offset, n_bytes_read, | ||
1134 | block[!idx], block[idx]); | ||
1135 | current_offset += n_bytes_read; | ||
1136 | idx = !idx; | ||
1137 | } | ||
1138 | } else { | ||
1139 | while (1) { | ||
1140 | err |= read_block(bytes_per_block, block[idx], &n_bytes_read); | ||
1141 | if (n_bytes_read < bytes_per_block) | ||
1142 | break; | ||
1143 | assert(n_bytes_read == bytes_per_block); | ||
1144 | write_block(current_offset, n_bytes_read, | ||
1145 | block[!idx], block[idx]); | ||
1146 | current_offset += n_bytes_read; | ||
1147 | idx = !idx; | ||
1148 | } | ||
1149 | } | ||
1150 | |||
1151 | if (n_bytes_read > 0) { | ||
1152 | int l_c_m; | ||
1153 | size_t bytes_to_write; | ||
1154 | |||
1155 | l_c_m = get_lcm(); | ||
1156 | |||
1157 | /* Make bytes_to_write the smallest multiple of l_c_m that | ||
1158 | is at least as large as n_bytes_read. */ | ||
1159 | bytes_to_write = l_c_m * ((n_bytes_read + l_c_m - 1) / l_c_m); | ||
1160 | |||
1161 | memset(block[idx] + n_bytes_read, 0, bytes_to_write - n_bytes_read); | ||
1162 | write_block(current_offset, bytes_to_write, | ||
1163 | block[!idx], block[idx]); | ||
1164 | current_offset += n_bytes_read; | ||
1165 | } | ||
1166 | |||
1167 | format_address(current_offset, '\n'); | ||
1168 | |||
1169 | if (limit_bytes_to_format && current_offset >= end_offset) | ||
1170 | err |= check_and_close(0); | ||
1171 | |||
1172 | free(block[0]); | ||
1173 | |||
1174 | return err; | ||
1175 | } | ||
1176 | |||
1177 | /* STRINGS mode. Find each "string constant" in the input. | ||
1178 | A string constant is a run of at least 'string_min' ASCII | ||
1179 | graphic (or formatting) characters terminated by a null. | ||
1180 | Based on a function written by Richard Stallman for a | ||
1181 | traditional version of od. Return nonzero if an error | ||
1182 | occurs. Otherwise, return zero. */ | ||
1183 | |||
1184 | static int | ||
1185 | dump_strings(void) | ||
1186 | { | ||
1187 | size_t bufsize = MAX(100, string_min); | ||
1188 | char *buf = xmalloc(bufsize); | ||
1189 | uintmax_t address = n_bytes_to_skip; | ||
1190 | int err; | ||
1191 | |||
1192 | err = 0; | ||
1193 | while (1) { | ||
1194 | size_t i; | ||
1195 | int c; | ||
1196 | |||
1197 | /* See if the next 'string_min' chars are all printing chars. */ | ||
1198 | tryline: | ||
1199 | |||
1200 | if (limit_bytes_to_format | ||
1201 | && (end_offset < string_min || end_offset - string_min <= address) | ||
1202 | ) { | ||
1203 | break; | ||
1204 | } | ||
1205 | |||
1206 | for (i = 0; i < string_min; i++) { | ||
1207 | err |= read_char(&c); | ||
1208 | address++; | ||
1209 | if (c < 0) { | ||
1210 | free(buf); | ||
1211 | return err; | ||
1212 | } | ||
1213 | if (!ISPRINT(c)) | ||
1214 | /* Found a non-printing. Try again starting with next char. */ | ||
1215 | goto tryline; | ||
1216 | buf[i] = c; | ||
1217 | } | ||
1218 | |||
1219 | /* We found a run of 'string_min' printable characters. | ||
1220 | Now see if it is terminated with a null byte. */ | ||
1221 | while (!limit_bytes_to_format || address < end_offset) { | ||
1222 | if (i == bufsize) { | ||
1223 | bufsize *= 2; | ||
1224 | buf = xrealloc(buf, bufsize * sizeof(*buf)); | ||
1225 | } | ||
1226 | err |= read_char(&c); | ||
1227 | address++; | ||
1228 | if (c < 0) { | ||
1229 | free(buf); | ||
1230 | return err; | ||
1231 | } | ||
1232 | if (c == '\0') | ||
1233 | break; /* It is; print this string. */ | ||
1234 | if (!ISPRINT(c)) | ||
1235 | goto tryline; /* It isn't; give up on this string. */ | ||
1236 | buf[i++] = c; /* String continues; store it all. */ | ||
1237 | } | ||
1238 | |||
1239 | /* If we get here, the string is all printable and null-terminated, | ||
1240 | so print it. It is all in 'buf' and 'i' is its length. */ | ||
1241 | buf[i] = 0; | ||
1242 | format_address(address - i - 1, ' '); | ||
1243 | |||
1244 | for (i = 0; (c = buf[i]); i++) { | ||
1245 | switch (c) { | ||
1246 | case '\007': | ||
1247 | fputs("\\a", stdout); | ||
1248 | break; | ||
1249 | |||
1250 | case '\b': | ||
1251 | fputs("\\b", stdout); | ||
1252 | break; | ||
1253 | |||
1254 | case '\f': | ||
1255 | fputs("\\f", stdout); | ||
1256 | break; | ||
1257 | |||
1258 | case '\n': | ||
1259 | fputs("\\n", stdout); | ||
1260 | break; | ||
1261 | |||
1262 | case '\r': | ||
1263 | fputs("\\r", stdout); | ||
1264 | break; | ||
1265 | |||
1266 | case '\t': | ||
1267 | fputs("\\t", stdout); | ||
1268 | break; | ||
1269 | |||
1270 | case '\v': | ||
1271 | fputs("\\v", stdout); | ||
1272 | break; | ||
1273 | |||
1274 | default: | ||
1275 | putc(c, stdout); | ||
1276 | } | ||
1277 | } | ||
1278 | putchar('\n'); | ||
1279 | } | ||
1280 | |||
1281 | /* We reach this point only if we search through | ||
1282 | (max_bytes_to_format - string_min) bytes before reaching EOF. */ | ||
1283 | |||
1284 | free(buf); | ||
1285 | |||
1286 | err |= check_and_close(0); | ||
1287 | return err; | ||
1288 | } | ||
1289 | |||
1290 | int | ||
1291 | od_main(int argc, char **argv) | ||
1292 | { | ||
1293 | static const struct suffix_mult bkm[] = { | ||
1294 | { "b", 512 }, | ||
1295 | { "k", 1024 }, | ||
1296 | { "m", 1024*1024 }, | ||
1297 | { NULL, 0 } | ||
1298 | }; | ||
1299 | static const struct option long_options[] = { | ||
1300 | { "skip-bytes", required_argument, NULL, 'j' }, | ||
1301 | { "address-radix", required_argument, NULL, 'A' }, | ||
1302 | { "read-bytes", required_argument, NULL, 'N' }, | ||
1303 | { "format", required_argument, NULL, 't' }, | ||
1304 | { "output-duplicates", no_argument, NULL, 'v' }, | ||
1305 | { "strings", optional_argument, NULL, 's' }, | ||
1306 | { "traditional", no_argument, NULL, TRADITIONAL_OPTION }, | ||
1307 | { "width", optional_argument, NULL, 'w' }, | ||
1308 | { NULL, 0, NULL, 0 } | ||
1309 | }; | ||
1310 | |||
1311 | int c; | ||
1312 | int n_files; | ||
1313 | int l_c_m; | ||
1314 | size_t desired_width = 0; // only for gcc | ||
1315 | int width_specified = 0; | ||
1316 | int n_failed_decodes = 0; | ||
1317 | int err; | ||
1318 | |||
1319 | /* The old-style 'pseudo starting address' to be printed in parentheses | ||
1320 | after any true address. */ | ||
1321 | uintmax_t pseudo_start = 0; // only for gcc | ||
1322 | |||
1323 | err = 0; | ||
1324 | |||
1325 | integral_type_size[sizeof(char)] = CHAR; | ||
1326 | integral_type_size[sizeof(short)] = SHORT; | ||
1327 | integral_type_size[sizeof(int)] = INT; | ||
1328 | integral_type_size[sizeof(long)] = LONG; | ||
1329 | /* If 'long' and 'long long' have the same size, it's fine | ||
1330 | to overwrite the entry for 'long' with this one. */ | ||
1331 | integral_type_size[sizeof(ulonglong_t)] = LONG_LONG; | ||
1332 | |||
1333 | fp_type_size[sizeof(float)] = FLOAT_SINGLE; | ||
1334 | /* The array entry for 'double' is filled in after that for longdouble_t | ||
1335 | so that if 'long double' is the same type or if long double isn't | ||
1336 | supported FLOAT_LONG_DOUBLE will never be used. */ | ||
1337 | fp_type_size[sizeof(longdouble_t)] = FLOAT_LONG_DOUBLE; | ||
1338 | fp_type_size[sizeof(double)] = FLOAT_DOUBLE; | ||
1339 | |||
1340 | spec = NULL; | ||
1341 | |||
1342 | format_address = format_address_std; | ||
1343 | address_base = 8; | ||
1344 | address_pad_len = 7; | ||
1345 | flag_dump_strings = 0; | ||
1346 | |||
1347 | while ((c = getopt_long(argc, argv, "A:N:abcdfhij:lot:vxs:w:", long_options, NULL)) != -1) { | ||
1348 | switch (c) { | ||
1349 | case 0: | ||
1350 | break; | ||
1351 | case 'A': | ||
1352 | switch (optarg[0]) { | ||
1353 | case 'd': | ||
1354 | format_address = format_address_std; | ||
1355 | address_base = 10; | ||
1356 | address_pad_len = 7; | ||
1357 | break; | ||
1358 | case 'o': | ||
1359 | format_address = format_address_std; | ||
1360 | address_base = 8; | ||
1361 | address_pad_len = 7; | ||
1362 | break; | ||
1363 | case 'x': | ||
1364 | format_address = format_address_std; | ||
1365 | address_base = 16; | ||
1366 | address_pad_len = 6; | ||
1367 | break; | ||
1368 | case 'n': | ||
1369 | format_address = format_address_none; | ||
1370 | address_pad_len = 0; | ||
1371 | break; | ||
1372 | default: | ||
1373 | bb_error_msg_and_die("bad output address radix '%c' " | ||
1374 | "(must be [doxn])", optarg[0]); | ||
1375 | break; | ||
1376 | } | ||
1377 | break; | ||
1378 | |||
1379 | case 'j': | ||
1380 | n_bytes_to_skip = xstrtoumax_sfx(optarg, 0, bkm); | ||
1381 | break; | ||
1382 | case 'N': | ||
1383 | limit_bytes_to_format = 1; | ||
1384 | |||
1385 | max_bytes_to_format = xstrtoumax_sfx(optarg, 0, bkm); | ||
1386 | break; | ||
1387 | case 's': | ||
1388 | if (optarg == NULL) | ||
1389 | string_min = 3; | ||
1390 | else { | ||
1391 | string_min = xstrtoumax_range_sfx(optarg, 0, 0, SIZE_MAX, bkm); | ||
1392 | } | ||
1393 | flag_dump_strings = 1; | ||
1394 | break; | ||
1395 | case 't': | ||
1396 | if (decode_format_string(optarg)) | ||
1397 | ++n_failed_decodes; | ||
1398 | break; | ||
1399 | case 'v': | ||
1400 | abbreviate_duplicate_blocks = 0; | ||
1401 | break; | ||
1402 | case TRADITIONAL_OPTION: | ||
1403 | traditional = 1; | ||
1404 | break; | ||
1405 | |||
1406 | /* The next several cases map the traditional format | ||
1407 | specification options to the corresponding modern format | ||
1408 | specs. GNU od accepts any combination of old- and | ||
1409 | new-style options. Format specification options accumulate. */ | ||
1410 | |||
1411 | #define CASE_OLD_ARG(old_char,new_string) \ | ||
1412 | case old_char: \ | ||
1413 | if (decode_format_string(new_string)) \ | ||
1414 | ++n_failed_decodes; \ | ||
1415 | break | ||
1416 | |||
1417 | CASE_OLD_ARG('a', "a"); | ||
1418 | CASE_OLD_ARG('b', "oC"); | ||
1419 | CASE_OLD_ARG('c', "c"); | ||
1420 | CASE_OLD_ARG('d', "u2"); | ||
1421 | CASE_OLD_ARG('f', "fF"); | ||
1422 | CASE_OLD_ARG('h', "x2"); | ||
1423 | CASE_OLD_ARG('i', "d2"); | ||
1424 | CASE_OLD_ARG('l', "d4"); | ||
1425 | CASE_OLD_ARG('o', "o2"); | ||
1426 | CASE_OLD_ARG('x', "x2"); | ||
1427 | |||
1428 | /* FIXME: POSIX 1003.1-2001 with XSI requires this: | ||
1429 | CASE_OLD_ARG('s', "d2"); | ||
1430 | for the traditional syntax, but this conflicts with case | ||
1431 | 's' above. */ | ||
1432 | |||
1433 | #undef CASE_OLD_ARG | ||
1434 | |||
1435 | case 'w': | ||
1436 | width_specified = 1; | ||
1437 | desired_width = 32; | ||
1438 | if (optarg) | ||
1439 | desired_width = xatoul_range(optarg, 0, SIZE_MAX); | ||
1440 | break; | ||
1441 | default: | ||
1442 | bb_show_usage(); | ||
1443 | break; | ||
1444 | } | ||
1445 | } | ||
1446 | |||
1447 | if (n_failed_decodes > 0) | ||
1448 | exit(EXIT_FAILURE); | ||
1449 | |||
1450 | if (flag_dump_strings && n_specs > 0) | ||
1451 | bb_error_msg_and_die("no type may be specified when dumping strings"); | ||
1452 | |||
1453 | n_files = argc - optind; | ||
1454 | |||
1455 | /* If the --traditional option is used, there may be from | ||
1456 | 0 to 3 remaining command line arguments; handle each case | ||
1457 | separately. | ||
1458 | od [file] [[+]offset[.][b] [[+]label[.][b]]] | ||
1459 | The offset and pseudo_start have the same syntax. | ||
1460 | |||
1461 | FIXME: POSIX 1003.1-2001 with XSI requires support for the | ||
1462 | traditional syntax even if --traditional is not given. */ | ||
1463 | |||
1464 | if (traditional) { | ||
1465 | uintmax_t offset; | ||
1466 | |||
1467 | if (n_files == 1) { | ||
1468 | if (parse_old_offset(argv[optind], &offset)) { | ||
1469 | n_bytes_to_skip = offset; | ||
1470 | --n_files; | ||
1471 | ++argv; | ||
1472 | } | ||
1473 | } else if (n_files == 2) { | ||
1474 | uintmax_t o1, o2; | ||
1475 | |||
1476 | if (parse_old_offset(argv[optind], &o1) | ||
1477 | && parse_old_offset(argv[optind + 1], &o2) | ||
1478 | ) { | ||
1479 | n_bytes_to_skip = o1; | ||
1480 | flag_pseudo_start = 1; | ||
1481 | pseudo_start = o2; | ||
1482 | argv += 2; | ||
1483 | n_files -= 2; | ||
1484 | } else if (parse_old_offset(argv[optind + 1], &o2)) { | ||
1485 | n_bytes_to_skip = o2; | ||
1486 | --n_files; | ||
1487 | argv[optind + 1] = argv[optind]; | ||
1488 | ++argv; | ||
1489 | } else { | ||
1490 | bb_error_msg_and_die("invalid second operand " | ||
1491 | "in compatibility mode '%s'", argv[optind + 1]); | ||
1492 | } | ||
1493 | } else if (n_files == 3) { | ||
1494 | uintmax_t o1, o2; | ||
1495 | if (parse_old_offset(argv[optind + 1], &o1) | ||
1496 | && parse_old_offset(argv[optind + 2], &o2) | ||
1497 | ) { | ||
1498 | n_bytes_to_skip = o1; | ||
1499 | flag_pseudo_start = 1; | ||
1500 | pseudo_start = o2; | ||
1501 | argv[optind + 2] = argv[optind]; | ||
1502 | argv += 2; | ||
1503 | n_files -= 2; | ||
1504 | } else { | ||
1505 | bb_error_msg_and_die("in compatibility mode " | ||
1506 | "the last two arguments must be offsets"); | ||
1507 | } | ||
1508 | } else if (n_files > 3) { | ||
1509 | bb_error_msg_and_die("compatibility mode supports " | ||
1510 | "at most three arguments"); | ||
1511 | } | ||
1512 | |||
1513 | if (flag_pseudo_start) { | ||
1514 | if (format_address == format_address_none) { | ||
1515 | address_base = 8; | ||
1516 | address_pad_len = 7; | ||
1517 | format_address = format_address_paren; | ||
1518 | } else | ||
1519 | format_address = format_address_label; | ||
1520 | } | ||
1521 | } | ||
1522 | |||
1523 | if (limit_bytes_to_format) { | ||
1524 | end_offset = n_bytes_to_skip + max_bytes_to_format; | ||
1525 | if (end_offset < n_bytes_to_skip) | ||
1526 | bb_error_msg_and_die("skip-bytes + read-bytes is too large"); | ||
1527 | } | ||
1528 | |||
1529 | if (n_specs == 0) { | ||
1530 | if (decode_format_string("o2")) { | ||
1531 | /* This happens on Cray systems that don't have a 2-byte | ||
1532 | integral type. */ | ||
1533 | exit(EXIT_FAILURE); | ||
1534 | } | ||
1535 | n_specs = 1; | ||
1536 | } | ||
1537 | |||
1538 | if (n_files > 0) { | ||
1539 | /* Set the global pointer FILE_LIST so that it | ||
1540 | references the first file-argument on the command-line. */ | ||
1541 | file_list = (char const *const *) &argv[optind]; | ||
1542 | } else { | ||
1543 | /* No files were listed on the command line. | ||
1544 | Set the global pointer FILE_LIST so that it | ||
1545 | references the null-terminated list of one name: "-". */ | ||
1546 | file_list = default_file_list; | ||
1547 | } | ||
1548 | |||
1549 | /* open the first input file */ | ||
1550 | err |= open_next_file(); | ||
1551 | if (in_stream == NULL) | ||
1552 | goto cleanup; | ||
1553 | |||
1554 | /* skip over any unwanted header bytes */ | ||
1555 | err |= skip(n_bytes_to_skip); | ||
1556 | if (in_stream == NULL) | ||
1557 | goto cleanup; | ||
1558 | |||
1559 | pseudo_offset = (flag_pseudo_start ? pseudo_start - n_bytes_to_skip : 0); | ||
1560 | |||
1561 | /* Compute output block length. */ | ||
1562 | l_c_m = get_lcm(); | ||
1563 | |||
1564 | if (width_specified) { | ||
1565 | if (desired_width != 0 && desired_width % l_c_m == 0) | ||
1566 | bytes_per_block = desired_width; | ||
1567 | else { | ||
1568 | bb_error_msg("warning: invalid width %lu; using %d instead", | ||
1569 | (unsigned long) desired_width, l_c_m); | ||
1570 | bytes_per_block = l_c_m; | ||
1571 | } | ||
1572 | } else { | ||
1573 | if (l_c_m < DEFAULT_BYTES_PER_BLOCK) | ||
1574 | bytes_per_block = l_c_m * (DEFAULT_BYTES_PER_BLOCK / l_c_m); | ||
1575 | else | ||
1576 | bytes_per_block = l_c_m; | ||
1577 | } | ||
1578 | |||
1579 | #ifdef DEBUG | ||
1580 | for (i = 0; i < n_specs; i++) { | ||
1581 | printf("%d: fmt=\"%s\" width=%d\n", | ||
1582 | i, spec[i].fmt_string, width_bytes[spec[i].size]); | ||
1583 | } | ||
1584 | #endif | ||
1585 | |||
1586 | err |= (flag_dump_strings ? dump_strings() : dump()); | ||
1587 | |||
1588 | cleanup: | ||
1589 | |||
1590 | if (have_read_stdin && fclose(stdin) == EOF) | ||
1591 | bb_perror_msg_and_die("standard input"); | ||
1592 | |||
1593 | exit(err == 0 ? EXIT_SUCCESS : EXIT_FAILURE); | ||
1594 | } | ||