aboutsummaryrefslogtreecommitdiff
path: root/coreutils/od_bloaty.c
diff options
context:
space:
mode:
authorDenis Vlasenko <vda.linux@googlemail.com>2006-10-10 23:26:05 +0000
committerDenis Vlasenko <vda.linux@googlemail.com>2006-10-10 23:26:05 +0000
commit1114de7219f8e42d6d883c476a9458f637806365 (patch)
tree7a77eafabd8476a7b41ec2c69d258c0e0fb32040 /coreutils/od_bloaty.c
parentcba9ef5523f09ecc3240f9f6efcdd0440c652c91 (diff)
downloadbusybox-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.c1594
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
40typedef long double longdouble_t;
41typedef 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
63enum 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
77enum 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. */
89struct 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
108static 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
111static 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
114static 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
117static 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. */
121static 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. */
135struct 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. */
141static 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). */
150static 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. */
158static int address_pad_len;
159
160static size_t string_min;
161static 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. */
166static int traditional;
167
168/* Non-zero if an old-style 'pseudo-address' was specified. */
169static int flag_pseudo_start;
170
171/* The difference between the old-style pseudo starting address and
172 the number of bytes to skip. */
173static 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. */
177static void (*format_address) (uintmax_t, char);
178
179/* The number of input bytes to skip before formatting and writing. */
180static 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. */
184static int limit_bytes_to_format; // = 0;
185
186/* The maximum number of bytes that will be formatted. */
187static uintmax_t max_bytes_to_format;
188
189/* The offset of the first byte after the last byte to be formatted. */
190static 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. */
195static int abbreviate_duplicate_blocks = 1;
196
197/* An array of specs describing how to format each input block. */
198static struct tspec *spec;
199
200/* The number of format specs. */
201static 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. */
207static 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 "-". */
211static char const *input_filename;
212
213/* A NULL-terminated list of the file-arguments from the command line. */
214static char const *const *file_list;
215
216/* Initializer for file_list if no file-arguments
217 were specified on the command line. */
218static char const *const default_file_list[] = {"-", NULL};
219
220/* The input stream associated with the current file. */
221static FILE *in_stream;
222
223/* If nonzero, at least one of the files we read was standard input. */
224static int have_read_stdin;
225
226#define MAX_INTEGRAL_TYPE_SIZE sizeof(ulonglong_t)
227static unsigned char integral_type_size[MAX_INTEGRAL_TYPE_SIZE + 1];
228
229#define MAX_FP_TYPE_SIZE sizeof(longdouble_t)
230static 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. */
235enum {
236 TRADITIONAL_OPTION = CHAR_MAX + 1
237};
238
239
240static unsigned
241gcd(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. */
253static unsigned
254lcm(unsigned u, unsigned v) {
255 unsigned t = gcd(u, v);
256 if (t == 0)
257 return 0;
258 return u * v / t;
259}
260
261static void
262print_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
275static void
276print_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
286static void
287print_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
300static void
301print_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
311static void
312print_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
322static void
323print_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
333static void
334print_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
344static void
345print_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
355static void
356print_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
366static void
367print_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
377static void
378dump_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
391static void
392print_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
416static void
417print_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
477static int
478decode_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
703static int
704open_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
740static int
741check_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
770static int
771decode_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
800static int
801skip(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
875static void
876format_address_none(uintmax_t address ATTRIBUTE_UNUSED, char c ATTRIBUTE_UNUSED)
877{
878}
879
880static void
881format_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
901static void
902format_address_paren(uintmax_t address, char c)
903{
904 putchar('(');
905 format_address_std(address, ')');
906 putchar(c);
907}
908
909static void
910format_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
927static void
928write_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
981static int
982read_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
1013static int
1014read_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
1044static int
1045get_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
1058static int
1059parse_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
1104static int
1105dump(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
1184static int
1185dump_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
1290int
1291od_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
1588cleanup:
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}
generated by cgit v1.2.3-55-g6feb (git 2.39.1) at 2025-03-18 05:29:15 +0000