Changeset 3621 in MondoRescue for branches/3.3/mindi-busybox/coreutils/od_bloaty.c

Timestamp:

Dec 20, 2016, 4:07:32 PM (7 years ago)

Author:

Bruno Cornec

Message:

New 3?3 banch for incorporation of latest busybox 1.25. Changing minor version to handle potential incompatibilities.

Location:

branches/3.3

Files:

• . (copied) (copied from branches/3.2 )
• mindi-busybox/coreutils/od_bloaty.c (modified) (38 diffs)

branches/3.3/mindi-busybox/coreutils/od_bloaty.c

@@ -21 +21 @@
 
 /* #include "libbb.h" - done in od.c */
+#include "common_bufsiz.h"
 #define assert(a) ((void)0)
 
@@ -67 +68 @@
     /* but in coreutils 6.3 it was renamed and now has */ \
     /* _mandatory_ parameter */ \
-    &str_A, &str_N, &str_j, &lst_t, &str_S, &bytes_per_block)
+    &str_A, &str_N, &str_j, &lst_t, &str_S, &G.bytes_per_block)
 
 
@@ -175 +176 @@
 };
 
-static smallint exit_code;
-
-static unsigned string_min;
-
-/* An array of specs describing how to format each input block.  */
-static size_t n_specs;
-static struct tspec *spec;
-
-/* Function that accepts an address and an optional following char,
-   and prints the address and char to stdout.  */
-static void (*format_address)(off_t, char);
-/* The difference between the old-style pseudo starting address and
-   the number of bytes to skip.  */
+struct globals {
+    smallint exit_code;
+
+    unsigned string_min;
+
+    /* An array of specs describing how to format each input block.  */
+    unsigned n_specs;
+    struct tspec *spec;
+
+    /* Function that accepts an address and an optional following char,
+       and prints the address and char to stdout.  */
+    void (*format_address)(off_t, char);
+
+    /* The difference between the old-style pseudo starting address and
+       the number of bytes to skip.  */
 #if ENABLE_LONG_OPTS
-static off_t pseudo_offset;
-#else
-enum { pseudo_offset = 0 };
-#endif
-/* When zero, MAX_BYTES_TO_FORMAT and END_OFFSET are ignored, and all
-   input is formatted.  */
-
-/* The number of input bytes formatted per output line.  It must be
-   a multiple of the least common multiple of the sizes associated with
-   the specified output types.  It should be as large as possible, but
-   no larger than 16 -- unless specified with the -w option.  */
-static unsigned bytes_per_block = 32; /* have to use unsigned, not size_t */
-
-/* A NULL-terminated list of the file-arguments from the command line.  */
-static const char *const *file_list;
-
-/* The input stream associated with the current file.  */
-static FILE *in_stream;
+    off_t pseudo_offset;
+# define G_pseudo_offset G.pseudo_offset
+#endif
+    /* When zero, MAX_BYTES_TO_FORMAT and END_OFFSET are ignored, and all
+       input is formatted.  */
+
+    /* The number of input bytes formatted per output line.  It must be
+       a multiple of the least common multiple of the sizes associated with
+       the specified output types.  It should be as large as possible, but
+       no larger than 16 -- unless specified with the -w option.  */
+    unsigned bytes_per_block; /* have to use unsigned, not size_t */
+
+    /* A NULL-terminated list of the file-arguments from the command line.  */
+    const char *const *file_list;
+
+    /* The input stream associated with the current file.  */
+    FILE *in_stream;
+
+    bool not_first;
+    bool prev_pair_equal;
+} FIX_ALIASING;
+#if !ENABLE_LONG_OPTS
+enum { G_pseudo_offset = 0 };
+#endif
+#define G (*(struct globals*)bb_common_bufsiz1)
+#define INIT_G() do { \
+    setup_common_bufsiz(); \
+    BUILD_BUG_ON(sizeof(G) > COMMON_BUFSIZE); \
+    G.bytes_per_block = 32; \
+} while (0)
+
 
 #define MAX_INTEGRAL_TYPE_SIZE sizeof(ulonglong_t)
@@ -388 +404 @@
     };
     // buf[N] pos:  01234 56789
-    char buf[12] = "   x\0 0xx\0";
-    // actually "   x\0 xxx\0", but want to share string with print_ascii.
+    char buf[12] = "   x\0 xxx\0";
     // [12] because we take three 32bit stack slots anyway, and
     // gcc is too dumb to initialize with constant stores,
     // it copies initializer from rodata. Oh well.
+    // https://gcc.gnu.org/bugzilla/show_bug.cgi?id=65410
 
     while (n_bytes--) {
@@ -420 +436 @@
 {
     // buf[N] pos:  01234 56789
-    char buf[12] = "   x\0 0xx\0";
+    char buf[12] = "   x\0 xxx\0";
 
     while (n_bytes--) {
@@ -456 +472 @@
             s = "  \\v";
             break;
-        case '\x7f':
-            s = " 177";
-            break;
-        default: /* c is never larger than 040 */
-            buf[7] = (c >> 3) + '0';
+        default:
+            buf[6] = (c >> 6 & 3) + '0';
+            buf[7] = (c >> 3 & 7) + '0';
             buf[8] = (c & 7) + '0';
             s = buf + 5;
@@ -479 +493 @@
 {
     while (1) {
-        if (!*file_list)
+        if (!*G.file_list)
             return;
-        in_stream = fopen_or_warn_stdin(*file_list++);
-        if (in_stream) {
-            break;
-        }
-        exit_code = 1;
+        G.in_stream = fopen_or_warn_stdin(*G.file_list++);
+        if (G.in_stream) {
+            break;
+        }
+        G.exit_code = 1;
     }
 
     if ((option_mask32 & (OPT_N|OPT_S)) == OPT_N)
-        setbuf(in_stream, NULL);
+        setbuf(G.in_stream, NULL);
 }
 
@@ -502 +516 @@
 check_and_close(void)
 {
-    if (in_stream) {
-        if (ferror(in_stream))  {
-            bb_error_msg("%s: read error", (in_stream == stdin)
+    if (G.in_stream) {
+        if (ferror(G.in_stream))    {
+            bb_error_msg("%s: read error", (G.in_stream == stdin)
                     ? bb_msg_standard_input
-                    : file_list[-1]
+                    : G.file_list[-1]
             );
-            exit_code = 1;
-        }
-        fclose_if_not_stdin(in_stream);
-        in_stream = NULL;
+            G.exit_code = 1;
+        }
+        fclose_if_not_stdin(G.in_stream);
+        G.in_stream = NULL;
     }
 
@@ -747 +761 @@
         assert(s != next);
         s = next;
-        spec = xrealloc_vector(spec, 4, n_specs);
-        memcpy(&spec[n_specs], &tspec, sizeof(spec[0]));
-        n_specs++;
+        G.spec = xrealloc_vector(G.spec, 4, G.n_specs);
+        memcpy(&G.spec[G.n_specs], &tspec, sizeof(G.spec[0]));
+        G.n_specs++;
     }
 }
@@ -766 +780 @@
         return;
 
-    while (in_stream) { /* !EOF */
+    while (G.in_stream) { /* !EOF */
         struct stat file_stats;
 
@@ -784 +798 @@
                as large as the size of the current file, we can
                decrement n_skip and go on to the next file.  */
-        if (fstat(fileno(in_stream), &file_stats) == 0
+        if (fstat(fileno(G.in_stream), &file_stats) == 0
          && S_ISREG(file_stats.st_mode) && file_stats.st_size > 0
         ) {
@@ -791 +805 @@
                 /* take "check & close / open_next" route */
             } else {
-                if (fseeko(in_stream, n_skip, SEEK_CUR) != 0)
-                    exit_code = 1;
+                if (fseeko(G.in_stream, n_skip, SEEK_CUR) != 0)
+                    G.exit_code = 1;
                 return;
             }
@@ -805 +819 @@
                 if (n_skip < n_bytes_to_read)
                     n_bytes_to_read = n_skip;
-                n_bytes_read = fread(buf, 1, n_bytes_to_read, in_stream);
+                n_bytes_read = fread(buf, 1, n_bytes_to_read, G.in_stream);
                 n_skip -= n_bytes_read;
                 if (n_bytes_read != n_bytes_to_read)
@@ -858 +872 @@
 {
     format_address_std(address, ' ');
-    format_address_paren(address + pseudo_offset, c);
+    format_address_paren(address + G_pseudo_offset, c);
 }
 #endif
@@ -889 +903 @@
         const char *prev_block, const char *curr_block)
 {
-    static char first = 1;
-    static char prev_pair_equal = 0;
-    size_t i;
+    unsigned i;
 
     if (!(option_mask32 & OPT_v)
-     && !first
-     && n_bytes == bytes_per_block
-     && memcmp(prev_block, curr_block, bytes_per_block) == 0
+     && G.not_first
+     && n_bytes == G.bytes_per_block
+     && memcmp(prev_block, curr_block, G.bytes_per_block) == 0
     ) {
-        if (prev_pair_equal) {
+        if (G.prev_pair_equal) {
             /* The two preceding blocks were equal, and the current
                block is the same as the last one, so print nothing.  */
         } else {
             puts("*");
-            prev_pair_equal = 1;
+            G.prev_pair_equal = 1;
         }
     } else {
-        first = 0;
-        prev_pair_equal = 0;
-        for (i = 0; i < n_specs; i++) {
+        G.not_first = 1;
+        G.prev_pair_equal = 0;
+        for (i = 0; i < G.n_specs; i++) {
             if (i == 0)
-                format_address(current_offset, '\0');
+                G.format_address(current_offset, '\0');
             else
                 printf("%*s", address_pad_len_char - '0', "");
-            (*spec[i].print_function) (n_bytes, curr_block, spec[i].fmt_string);
-            if (spec[i].hexl_mode_trailer) {
+            (*G.spec[i].print_function) (n_bytes, curr_block, G.spec[i].fmt_string);
+            if (G.spec[i].hexl_mode_trailer) {
                 /* space-pad out to full line width, then dump the trailer */
-                unsigned datum_width = width_bytes[spec[i].size];
-                unsigned blank_fields = (bytes_per_block - n_bytes) / datum_width;
-                unsigned field_width = spec[i].field_width + 1;
+                unsigned datum_width = width_bytes[G.spec[i].size];
+                unsigned blank_fields = (G.bytes_per_block - n_bytes) / datum_width;
+                unsigned field_width = G.spec[i].field_width + 1;
                 printf("%*s", blank_fields * field_width, "");
                 dump_hexl_mode_trailer(n_bytes, curr_block);
@@ -930 +942 @@
 read_block(size_t n, char *block, size_t *n_bytes_in_buffer)
 {
-    assert(0 < n && n <= bytes_per_block);
+    assert(0 < n && n <= G.bytes_per_block);
 
     *n_bytes_in_buffer = 0;
@@ -937 +949 @@
         return;
 
-    while (in_stream != NULL) { /* EOF.  */
+    while (G.in_stream != NULL) { /* EOF.  */
         size_t n_needed;
         size_t n_read;
 
         n_needed = n - *n_bytes_in_buffer;
-        n_read = fread(block + *n_bytes_in_buffer, 1, n_needed, in_stream);
+        n_read = fread(block + *n_bytes_in_buffer, 1, n_needed, G.in_stream);
         *n_bytes_in_buffer += n_read;
         if (n_read == n_needed)
@@ -961 +973 @@
     int l_c_m = 1;
 
-    for (i = 0; i < n_specs; i++)
-        l_c_m = lcm(l_c_m, width_bytes[(int) spec[i].size]);
+    for (i = 0; i < G.n_specs; i++)
+        l_c_m = lcm(l_c_m, width_bytes[(int) G.spec[i].size]);
     return l_c_m;
 }
@@ -983 +995 @@
     size_t n_bytes_read;
 
-    block[0] = xmalloc(2 * bytes_per_block);
-    block[1] = block[0] + bytes_per_block;
+    block[0] = xmalloc(2 * G.bytes_per_block);
+    block[1] = block[0] + G.bytes_per_block;
 
     idx = 0;
@@ -994 +1006 @@
                 break;
             }
-            n_needed = MIN(end_offset - current_offset, (off_t) bytes_per_block);
+            n_needed = MIN(end_offset - current_offset, (off_t) G.bytes_per_block);
             read_block(n_needed, block[idx], &n_bytes_read);
-            if (n_bytes_read < bytes_per_block)
+            if (n_bytes_read < G.bytes_per_block)
                 break;
-            assert(n_bytes_read == bytes_per_block);
+            assert(n_bytes_read == G.bytes_per_block);
             write_block(current_offset, n_bytes_read, block[idx ^ 1], block[idx]);
             current_offset += n_bytes_read;
@@ -1005 +1017 @@
     } else {
         while (1) {
-            read_block(bytes_per_block, block[idx], &n_bytes_read);
-            if (n_bytes_read < bytes_per_block)
+            read_block(G.bytes_per_block, block[idx], &n_bytes_read);
+            if (n_bytes_read < G.bytes_per_block)
                 break;
-            assert(n_bytes_read == bytes_per_block);
+            assert(n_bytes_read == G.bytes_per_block);
             write_block(current_offset, n_bytes_read, block[idx ^ 1], block[idx]);
             current_offset += n_bytes_read;
@@ -1031 +1043 @@
     }
 
-    format_address(current_offset, '\n');
+    G.format_address(current_offset, '\n');
 
     if ((option_mask32 & OPT_N) && current_offset >= end_offset)
@@ -1062 +1074 @@
 dump_strings(off_t address, off_t end_offset)
 {
-    unsigned bufsize = MAX(100, string_min);
+    unsigned bufsize = MAX(100, G.string_min);
     unsigned char *buf = xmalloc(bufsize);
 
@@ -1069 +1081 @@
         int c;
 
-        /* See if the next 'string_min' chars are all printing chars.  */
+        /* See if the next 'G.string_min' chars are all printing chars.  */
  tryline:
-        if ((option_mask32 & OPT_N) && (end_offset - string_min <= address))
+        if ((option_mask32 & OPT_N) && (end_offset - G.string_min <= address))
             break;
         i = 0;
@@ -1080 +1092 @@
             }
 
-            while (in_stream) { /* !EOF */
-                c = fgetc(in_stream);
+            while (G.in_stream) { /* !EOF */
+                c = fgetc(G.in_stream);
                 if (c != EOF)
                     goto got_char;
@@ -1098 +1110 @@
         }
 
-        if (i < string_min)     /* Too short! */
+        if (i < G.string_min)       /* Too short! */
             goto tryline;
 
         /* If we get here, the string is all printable and NUL-terminated */
         buf[i] = 0;
-        format_address(address - i - 1, ' ');
+        G.format_address(address - i - 1, ' ');
 
         for (i = 0; (c = buf[i]); i++) {
@@ -1121 +1133 @@
 
     /* We reach this point only if we search through
-       (max_bytes_to_format - string_min) bytes before reaching EOF.  */
+       (max_bytes_to_format - G.string_min) bytes before reaching EOF.  */
     check_and_close();
  ret:
@@ -1167 +1179 @@
 int od_main(int argc UNUSED_PARAM, char **argv)
 {
-    static const struct suffix_mult bkm[] = {
-        { "b", 512 },
-        { "k", 1024 },
-        { "m", 1024*1024 },
-        { "", 0 }
-    };
 #if ENABLE_LONG_OPTS
     static const char od_longopts[] ALIGN1 =
@@ -1199 +1205 @@
     off_t max_bytes_to_format = 0;
 
-    spec = NULL;
-    format_address = format_address_std;
+    INIT_G();
+
+    /*G.spec = NULL; - already is */
+    G.format_address = format_address_std;
     address_base_char = 'o';
     address_pad_len_char = '7';
@@ -1226 +1234 @@
                 "'%c' (must be [doxn])", str_A[0]);
         pos = p - doxn;
-        if (pos == 3) format_address = format_address_none;
+        if (pos == 3) G.format_address = format_address_none;
         address_base_char = doxn_address_base_char[pos];
         address_pad_len_char = doxn_address_pad_len_char[pos];
     }
     if (opt & OPT_N) {
-        max_bytes_to_format = xstrtooff_sfx(str_N, 0, bkm);
+        max_bytes_to_format = xstrtooff_sfx(str_N, 0, bkm_suffixes);
     }
     if (opt & OPT_a) decode_format_string("a");
@@ -1240 +1248 @@
     if (opt & OPT_h) decode_format_string("x2");
     if (opt & OPT_i) decode_format_string("d2");
-    if (opt & OPT_j) n_bytes_to_skip = xstrtooff_sfx(str_j, 0, bkm);
+    if (opt & OPT_j) n_bytes_to_skip = xstrtooff_sfx(str_j, 0, bkm_suffixes);
     if (opt & OPT_l) decode_format_string("d4");
     if (opt & OPT_o) decode_format_string("o2");
@@ -1249 +1257 @@
     if (opt & OPT_s) decode_format_string("d2");
     if (opt & OPT_S) {
-        string_min = xstrtou_sfx(str_S, 0, bkm);
+        G.string_min = xstrtou_sfx(str_S, 0, bkm_suffixes);
     }
 
     // Bloat:
-    //if ((option_mask32 & OPT_S) && n_specs > 0)
+    //if ((option_mask32 & OPT_S) && G.n_specs > 0)
     //  bb_error_msg_and_die("no type may be specified when dumping strings");
 
@@ -1309 +1317 @@
 
             if (pseudo_start >= 0) {
-                if (format_address == format_address_none) {
+                if (G.format_address == format_address_none) {
                     address_base_char = 'o';
                     address_pad_len_char = '7';
-                    format_address = format_address_paren;
+                    G.format_address = format_address_paren;
                 } else {
-                    format_address = format_address_label;
+                    G.format_address = format_address_label;
                 }
-                pseudo_offset = pseudo_start - n_bytes_to_skip;
+                G_pseudo_offset = pseudo_start - n_bytes_to_skip;
             }
         }
@@ -1329 +1337 @@
     }
 
-    if (n_specs == 0) {
+    if (G.n_specs == 0) {
         decode_format_string("o2");
-        /*n_specs = 1; - done by decode_format_string */
+        /*G.n_specs = 1; - done by decode_format_string */
     }
 
@@ -1337 +1345 @@
        set the global pointer FILE_LIST so that it
        references the null-terminated list of one name: "-".  */
-    file_list = bb_argv_dash;
+    G.file_list = bb_argv_dash;
     if (argv[0]) {
         /* Set the global pointer FILE_LIST so that it
            references the first file-argument on the command-line.  */
-        file_list = (char const *const *) argv;
+        G.file_list = (char const *const *) argv;
     }
 
@@ -1348 +1356 @@
     /* Skip over any unwanted header bytes */
     skip(n_bytes_to_skip);
-    if (!in_stream)
+    if (!G.in_stream)
         return EXIT_FAILURE;
 
@@ -1355 +1363 @@
 
     if (opt & OPT_w) { /* -w: width */
-        if (!bytes_per_block || bytes_per_block % l_c_m != 0) {
+        if (!G.bytes_per_block || G.bytes_per_block % l_c_m != 0) {
             bb_error_msg("warning: invalid width %u; using %d instead",
-                    (unsigned)bytes_per_block, l_c_m);
-            bytes_per_block = l_c_m;
+                    (unsigned)G.bytes_per_block, l_c_m);
+            G.bytes_per_block = l_c_m;
         }
     } else {
-        bytes_per_block = l_c_m;
+        G.bytes_per_block = l_c_m;
         if (l_c_m < DEFAULT_BYTES_PER_BLOCK)
-            bytes_per_block *= DEFAULT_BYTES_PER_BLOCK / l_c_m;
+            G.bytes_per_block *= DEFAULT_BYTES_PER_BLOCK / l_c_m;
     }
 
 #ifdef DEBUG
-    for (i = 0; i < n_specs; i++) {
+    for (i = 0; i < G.n_specs; i++) {
         printf("%d: fmt=\"%s\" width=%d\n",
             i, spec[i].fmt_string, width_bytes[spec[i].size]);
@@ -1381 +1389 @@
         bb_perror_msg_and_die(bb_msg_standard_input);
 
-    return exit_code;
-}
+    return G.exit_code;
+}