diff --git a/script/adler32-standalone.c b/script/adler32-standalone.c index 67260836..805b2121 100644 --- a/script/adler32-standalone.c +++ b/script/adler32-standalone.c @@ -40,17 +40,17 @@ // The order matters here. Clang also defines "__GNUC__". #if defined(__clang__) -const char* cc = "clang"; -const char* cc_version = __clang_version__; +const char* g_cc = "clang"; +const char* g_cc_version = __clang_version__; #elif defined(__GNUC__) -const char* cc = "gcc"; -const char* cc_version = __VERSION__; +const char* g_cc = "gcc"; +const char* g_cc_version = __VERSION__; #elif defined(_MSC_VER) -const char* cc = "cl"; -const char* cc_version = "???"; +const char* g_cc = "cl"; +const char* g_cc_version = "???"; #else -const char* cc = "cc"; -const char* cc_version = "???"; +const char* g_cc = "cc"; +const char* g_cc_version = "???"; #endif struct { @@ -58,7 +58,7 @@ struct { char** remaining_argv; bool no_check; -} flags = {0}; +} g_flags = {0}; const char* // parse_flags(int argc, char** argv) { @@ -83,15 +83,15 @@ parse_flags(int argc, char** argv) { } if (!strcmp(arg, "no-check")) { - flags.no_check = true; + g_flags.no_check = true; continue; } return "main: unrecognized flag argument"; } - flags.remaining_argc = argc - c; - flags.remaining_argv = argv + c; + g_flags.remaining_argc = argc - c; + g_flags.remaining_argv = argv + c; return NULL; } @@ -156,7 +156,7 @@ calculate_hash(uint8_t* x_ptr, size_t x_len) { return (s2 << 16) | s1; } -uint8_t buffer[BUFFER_SIZE] = {0}; +uint8_t g_buffer[BUFFER_SIZE] = {0}; int // main(int argc, char** argv) { @@ -178,8 +178,8 @@ main(int argc, char** argv) { int i; int num_bad = 0; for (i = 0; i < num_reps; i++) { - uint32_t actual_hash = calculate_hash(buffer, BUFFER_SIZE); - if (!flags.no_check && (actual_hash != expected_hash_of_1mib_of_zeroes)) { + uint32_t actual_hash = calculate_hash(g_buffer, BUFFER_SIZE); + if (!g_flags.no_check && (actual_hash != expected_hash_of_1mib_of_zeroes)) { num_bad++; } } @@ -198,6 +198,6 @@ main(int argc, char** argv) { int64_t denom = micros * ONE_MIBIBYTE; int64_t mib_per_s = denom ? numer / denom : 0; - printf("%8d MiB/s, %s %s\n", (int)mib_per_s, cc, cc_version); + printf("%8d MiB/s, %s %s\n", (int)mib_per_s, g_cc, g_cc_version); return 0; } diff --git a/script/bench-c-deflate-fragmentation.c b/script/bench-c-deflate-fragmentation.c index be6f7aa3..37b7c1e5 100644 --- a/script/bench-c-deflate-fragmentation.c +++ b/script/bench-c-deflate-fragmentation.c @@ -75,17 +75,17 @@ // The order matters here. Clang also defines "__GNUC__". #if defined(__clang__) -const char* cc = "clang"; -const char* cc_version = __clang_version__; +const char* g_cc = "clang"; +const char* g_cc_version = __clang_version__; #elif defined(__GNUC__) -const char* cc = "gcc"; -const char* cc_version = __VERSION__; +const char* g_cc = "gcc"; +const char* g_cc_version = __VERSION__; #elif defined(_MSC_VER) -const char* cc = "cl"; -const char* cc_version = "???"; +const char* g_cc = "cl"; +const char* g_cc_version = "???"; #else -const char* cc = "cc"; -const char* cc_version = "???"; +const char* g_cc = "cc"; +const char* g_cc_version = "???"; #endif static inline uint32_t // @@ -103,39 +103,40 @@ load_u32be(uint8_t* p) { #define MAX_DIMENSION (16384) #define MAX_IDAT_CHUNKS (1024) -uint8_t dst_buffer_array[DST_BUFFER_ARRAY_SIZE] = {0}; -size_t dst_len = 0; -uint8_t src_buffer_array[SRC_BUFFER_ARRAY_SIZE] = {0}; -size_t src_len = 0; -uint8_t idat_buffer_array[SRC_BUFFER_ARRAY_SIZE] = {0}; +uint8_t g_dst_buffer_array[DST_BUFFER_ARRAY_SIZE] = {0}; +size_t g_dst_len = 0; +uint8_t g_src_buffer_array[SRC_BUFFER_ARRAY_SIZE] = {0}; +size_t g_src_len = 0; +uint8_t g_idat_buffer_array[SRC_BUFFER_ARRAY_SIZE] = {0}; // The n'th IDAT chunk data (where n is a zero-based count) is in -// idat_buffer_array[i:j], where i = idat_splits[n+0] and j = idat_splits[n+1]. -size_t idat_splits[MAX_IDAT_CHUNKS + 1] = {0}; -uint32_t num_idat_chunks = 0; +// g_idat_buffer_array[i:j], where i = g_idat_splits[n+0] and j = +// g_idat_splits[n+1]. +size_t g_idat_splits[MAX_IDAT_CHUNKS + 1] = {0}; +uint32_t g_num_idat_chunks = 0; #define WORK_BUFFER_ARRAY_SIZE \ WUFFS_ZLIB__DECODER_WORKBUF_LEN_MAX_INCL_WORST_CASE #if WORK_BUFFER_ARRAY_SIZE > 0 -uint8_t work_buffer_array[WORK_BUFFER_ARRAY_SIZE]; +uint8_t g_work_buffer_array[WORK_BUFFER_ARRAY_SIZE]; #else // Not all C/C++ compilers support 0-length arrays. -uint8_t work_buffer_array[1]; +uint8_t g_work_buffer_array[1]; #endif -uint32_t width = 0; -uint32_t height = 0; -uint64_t bytes_per_pixel = 0; -uint64_t bytes_per_row = 0; -uint64_t bytes_per_frame = 0; +uint32_t g_width = 0; +uint32_t g_height = 0; +uint64_t g_bytes_per_pixel = 0; +uint64_t g_bytes_per_row = 0; +uint64_t g_bytes_per_frame = 0; const char* // read_stdin() { - while (src_len < SRC_BUFFER_ARRAY_SIZE) { + while (g_src_len < SRC_BUFFER_ARRAY_SIZE) { const int stdin_fd = 0; - ssize_t n = read(stdin_fd, src_buffer_array + src_len, - SRC_BUFFER_ARRAY_SIZE - src_len); + ssize_t n = read(stdin_fd, g_src_buffer_array + g_src_len, + SRC_BUFFER_ARRAY_SIZE - g_src_len); if (n > 0) { - src_len += n; + g_src_len += n; } else if (n == 0) { return NULL; } else if (errno == EINTR) { @@ -168,36 +169,36 @@ process_png_chunks(uint8_t* p, size_t n) { if (chunk_len != 13) { return "invalid PNG IDAT chunk"; } - width = load_u32be(p + 0); - height = load_u32be(p + 4); - if ((width == 0) || (height == 0)) { + g_width = load_u32be(p + 0); + g_height = load_u32be(p + 4); + if ((g_width == 0) || (g_height == 0)) { return "image dimensions are too small"; } - if ((width > MAX_DIMENSION) || (height > MAX_DIMENSION)) { + if ((g_width > MAX_DIMENSION) || (g_height > MAX_DIMENSION)) { return "image dimensions are too large"; } if (p[8] != 8) { return "unsupported PNG bit depth"; } - if (bytes_per_pixel != 0) { + if (g_bytes_per_pixel != 0) { return "duplicate PNG IHDR chunk"; } // Process the color type, as per the PNG spec table 11.1. switch (p[9]) { case 0: - bytes_per_pixel = 1; + g_bytes_per_pixel = 1; break; case 2: - bytes_per_pixel = 3; + g_bytes_per_pixel = 3; break; case 3: - bytes_per_pixel = 1; + g_bytes_per_pixel = 1; break; case 4: - bytes_per_pixel = 2; + g_bytes_per_pixel = 2; break; case 6: - bytes_per_pixel = 4; + g_bytes_per_pixel = 4; break; default: return "unsupported PNG color type"; @@ -208,13 +209,14 @@ process_png_chunks(uint8_t* p, size_t n) { break; case 0x49444154: // "IDAT" - if (num_idat_chunks == MAX_IDAT_CHUNKS - 1) { + if (g_num_idat_chunks == MAX_IDAT_CHUNKS - 1) { return "too many IDAT chunks"; } - memcpy(idat_buffer_array + idat_splits[num_idat_chunks], p, chunk_len); - idat_splits[num_idat_chunks + 1] = - idat_splits[num_idat_chunks] + chunk_len; - num_idat_chunks++; + memcpy(g_idat_buffer_array + g_idat_splits[g_num_idat_chunks], p, + chunk_len); + g_idat_splits[g_num_idat_chunks + 1] = + g_idat_splits[g_num_idat_chunks] + chunk_len; + g_num_idat_chunks++; break; } p += chunk_len; @@ -241,17 +243,17 @@ decode_once(bool frag_dst, bool frag_idat) { wuffs_base__io_buffer dst = ((wuffs_base__io_buffer){ .data = ((wuffs_base__slice_u8){ - .ptr = dst_buffer_array, - .len = bytes_per_frame, + .ptr = g_dst_buffer_array, + .len = g_bytes_per_frame, }), }); wuffs_base__io_buffer idat = ((wuffs_base__io_buffer){ .data = ((wuffs_base__slice_u8){ - .ptr = idat_buffer_array, + .ptr = g_idat_buffer_array, .len = SRC_BUFFER_ARRAY_SIZE, }), .meta = ((wuffs_base__io_buffer_meta){ - .wi = idat_splits[num_idat_chunks], + .wi = g_idat_splits[g_num_idat_chunks], .ri = 0, .pos = 0, .closed = true, @@ -260,20 +262,20 @@ decode_once(bool frag_dst, bool frag_idat) { uint32_t i = 0; // Number of dst fragments processed, if frag_dst. if (frag_dst) { - dst.data.len = bytes_per_row; + dst.data.len = g_bytes_per_row; } uint32_t j = 0; // Number of IDAT fragments processed, if frag_idat. if (frag_idat) { - idat.meta.wi = idat_splits[1]; - idat.meta.closed = (num_idat_chunks == 1); + idat.meta.wi = g_idat_splits[1]; + idat.meta.closed = (g_num_idat_chunks == 1); } while (true) { status = wuffs_zlib__decoder__transform_io(&dec, &dst, &idat, ((wuffs_base__slice_u8){ - .ptr = work_buffer_array, + .ptr = g_work_buffer_array, .len = WORK_BUFFER_ARRAY_SIZE, })); @@ -281,22 +283,22 @@ decode_once(bool frag_dst, bool frag_idat) { break; } if ((status.repr == wuffs_base__suspension__short_write) && frag_dst && - (i < height - 1)) { + (i < g_height - 1)) { i++; - dst.data.len = bytes_per_row * (i + 1); + dst.data.len = g_bytes_per_row * (i + 1); continue; } if ((status.repr == wuffs_base__suspension__short_read) && frag_idat && - (j < num_idat_chunks - 1)) { + (j < g_num_idat_chunks - 1)) { j++; - idat.meta.wi = idat_splits[j + 1]; - idat.meta.closed = (num_idat_chunks == j + 1); + idat.meta.wi = g_idat_splits[j + 1]; + idat.meta.closed = (g_num_idat_chunks == j + 1); continue; } return wuffs_base__status__message(&status); } - if (dst.meta.wi != bytes_per_frame) { + if (dst.meta.wi != g_bytes_per_frame) { return "unexpected number of bytes decoded"; } return NULL; @@ -305,11 +307,11 @@ decode_once(bool frag_dst, bool frag_idat) { const char* // decode(bool frag_dst, bool frag_idat) { int reps; - if (bytes_per_frame < 100000) { + if (g_bytes_per_frame < 100000) { reps = 1000; - } else if (bytes_per_frame < 1000000) { + } else if (g_bytes_per_frame < 1000000) { reps = 100; - } else if (bytes_per_frame < 10000000) { + } else if (g_bytes_per_frame < 10000000) { reps = 10; } else { reps = 1; @@ -339,7 +341,7 @@ decode(bool frag_dst, bool frag_idat) { printf("Benchmark%sDst%sIDAT/%s\t%8d\t%8" PRIu64 " ns/op\n", frag_dst ? "Frag" : "Full", // frag_idat ? "Frag" : "Full", // - cc, reps, nanos / reps); + g_cc, reps, nanos / reps); return NULL; } @@ -358,28 +360,28 @@ main(int argc, char** argv) { if (msg) { return fail(msg); } - if ((src_len < 8) || - strncmp((const char*)(src_buffer_array), "\x89PNG\x0D\x0A\x1A\x0A", 8)) { + if ((g_src_len < 8) || strncmp((const char*)(g_src_buffer_array), + "\x89PNG\x0D\x0A\x1A\x0A", 8)) { return fail("invalid PNG"); } - msg = process_png_chunks(src_buffer_array + 8, src_len - 8); + msg = process_png_chunks(g_src_buffer_array + 8, g_src_len - 8); if (msg) { return fail(msg); } - if (bytes_per_pixel == 0) { + if (g_bytes_per_pixel == 0) { return fail("missing PNG IHDR chunk"); } - if (num_idat_chunks == 0) { + if (g_num_idat_chunks == 0) { return fail("missing PNG IDAT chunk"); } // The +1 here is for the per-row filter byte. - bytes_per_row = (uint64_t)width * bytes_per_pixel + 1; - bytes_per_frame = (uint64_t)height * bytes_per_row; - if (bytes_per_frame > DST_BUFFER_ARRAY_SIZE) { + g_bytes_per_row = (uint64_t)g_width * g_bytes_per_pixel + 1; + g_bytes_per_frame = (uint64_t)g_height * g_bytes_per_row; + if (g_bytes_per_frame > DST_BUFFER_ARRAY_SIZE) { return fail("decompressed data is too large"); } - printf("# %s version %s\n#\n", cc, cc_version); + printf("# %s version %s\n#\n", g_cc, g_cc_version); printf( "# The output format, including the \"Benchmark\" prefixes, is " "compatible with the\n" diff --git a/script/print-json-token-debug-format.c b/script/print-json-token-debug-format.c index 1a370ba2..e140e45c 100644 --- a/script/print-json-token-debug-format.c +++ b/script/print-json-token-debug-format.c @@ -89,10 +89,10 @@ #define WORK_BUFFER_ARRAY_SIZE \ WUFFS_JSON__DECODER_WORKBUF_LEN_MAX_INCL_WORST_CASE #if WORK_BUFFER_ARRAY_SIZE > 0 -uint8_t work_buffer_array[WORK_BUFFER_ARRAY_SIZE]; +uint8_t g_work_buffer_array[WORK_BUFFER_ARRAY_SIZE]; #else // Not all C/C++ compilers support 0-length arrays. -uint8_t work_buffer_array[1]; +uint8_t g_work_buffer_array[1]; #endif #ifndef SRC_BUFFER_ARRAY_SIZE @@ -102,14 +102,14 @@ uint8_t work_buffer_array[1]; #define TOKEN_BUFFER_ARRAY_SIZE (128 * 1024) #endif -uint8_t src_buffer_array[SRC_BUFFER_ARRAY_SIZE]; -wuffs_base__token tok_buffer_array[TOKEN_BUFFER_ARRAY_SIZE]; +uint8_t g_src_buffer_array[SRC_BUFFER_ARRAY_SIZE]; +wuffs_base__token g_tok_buffer_array[TOKEN_BUFFER_ARRAY_SIZE]; -wuffs_base__io_buffer src; -wuffs_base__token_buffer tok; +wuffs_base__io_buffer g_src; +wuffs_base__token_buffer g_tok; -wuffs_json__decoder dec; -wuffs_base__status dec_status; +wuffs_json__decoder g_dec; +wuffs_base__status g_dec_status; #define TRY(error_msg) \ do { \ @@ -125,18 +125,18 @@ ignore_return_value(int ignored) {} const char* // read_src() { - if (src.meta.closed) { + if (g_src.meta.closed) { return "main: internal error: read requested on a closed source"; } - wuffs_base__io_buffer__compact(&src); - if (src.meta.wi >= src.data.len) { - return "main: src buffer is full"; + wuffs_base__io_buffer__compact(&g_src); + if (g_src.meta.wi >= g_src.data.len) { + return "main: g_src buffer is full"; } - size_t n = fread(src.data.ptr + src.meta.wi, sizeof(uint8_t), - src.data.len - src.meta.wi, stdin); - src.meta.wi += n; - src.meta.closed = feof(stdin); - if ((n == 0) && !src.meta.closed) { + size_t n = fread(g_src.data.ptr + g_src.meta.wi, sizeof(uint8_t), + g_src.data.len - g_src.meta.wi, stdin); + g_src.meta.wi += n; + g_src.meta.closed = feof(stdin); + if ((n == 0) && !g_src.meta.closed) { return "main: read error"; } return NULL; @@ -151,7 +151,7 @@ struct { bool all_tokens; bool human_readable; bool quirks; -} flags = {0}; +} g_flags = {0}; const char* // parse_flags(int argc, char** argv) { @@ -176,27 +176,27 @@ parse_flags(int argc, char** argv) { } if (!strcmp(arg, "a") || !strcmp(arg, "all-tokens")) { - flags.all_tokens = true; + g_flags.all_tokens = true; continue; } if (!strcmp(arg, "h") || !strcmp(arg, "human-readable")) { - flags.human_readable = true; + g_flags.human_readable = true; continue; } if (!strcmp(arg, "q") || !strcmp(arg, "quirks")) { - flags.quirks = true; + g_flags.quirks = true; continue; } return "main: unrecognized flag argument"; } - flags.remaining_argc = argc - c; - flags.remaining_argv = argv + c; + g_flags.remaining_argc = argc - c; + g_flags.remaining_argv = argv + c; return NULL; } -const char* vbc_names[8] = { +const char* g_vbc_names[8] = { "0:Filler..........", // "1:Structure.......", // "2:String..........", // @@ -207,7 +207,7 @@ const char* vbc_names[8] = { "7:Reserved........", // }; -const int base38_decode[38] = { +const int g_base38_decode[38] = { ' ', '0', '1', '2', '3', '4', '5', '6', '7', '8', '9', '?', // 'a', 'b', 'c', 'd', 'e', 'f', 'g', 'h', 'i', 'j', 'k', 'l', 'm', // 'n', 'o', 'p', 'q', 'r', 's', 't', 'u', 'v', 'w', 'x', 'y', 'z', // @@ -216,25 +216,25 @@ const int base38_decode[38] = { const char* // main1(int argc, char** argv) { TRY(parse_flags(argc, argv)); - if (flags.remaining_argc > 0) { + if (g_flags.remaining_argc > 0) { return "main: bad argument: use \"program < input\", not \"program input\""; } - src = wuffs_base__make_io_buffer( - wuffs_base__make_slice_u8(src_buffer_array, SRC_BUFFER_ARRAY_SIZE), + g_src = wuffs_base__make_io_buffer( + wuffs_base__make_slice_u8(g_src_buffer_array, SRC_BUFFER_ARRAY_SIZE), wuffs_base__empty_io_buffer_meta()); - tok = wuffs_base__make_token_buffer( - wuffs_base__make_slice_token(tok_buffer_array, TOKEN_BUFFER_ARRAY_SIZE), + g_tok = wuffs_base__make_token_buffer( + wuffs_base__make_slice_token(g_tok_buffer_array, TOKEN_BUFFER_ARRAY_SIZE), wuffs_base__empty_token_buffer_meta()); wuffs_base__status init_status = wuffs_json__decoder__initialize( - &dec, sizeof__wuffs_json__decoder(), WUFFS_VERSION, 0); + &g_dec, sizeof__wuffs_json__decoder(), WUFFS_VERSION, 0); if (!wuffs_base__status__is_ok(&init_status)) { return wuffs_base__status__message(&init_status); } - if (flags.quirks) { + if (g_flags.quirks) { uint32_t quirks[] = { WUFFS_JSON__QUIRK_ALLOW_BACKSLASH_A, WUFFS_JSON__QUIRK_ALLOW_BACKSLASH_CAPITAL_U, @@ -256,21 +256,21 @@ main1(int argc, char** argv) { }; uint32_t i; for (i = 0; quirks[i]; i++) { - wuffs_json__decoder__set_quirk_enabled(&dec, quirks[i], true); + wuffs_json__decoder__set_quirk_enabled(&g_dec, quirks[i], true); } } uint64_t pos = 0; while (true) { wuffs_base__status status = wuffs_json__decoder__decode_tokens( - &dec, &tok, &src, - wuffs_base__make_slice_u8(work_buffer_array, WORK_BUFFER_ARRAY_SIZE)); + &g_dec, &g_tok, &g_src, + wuffs_base__make_slice_u8(g_work_buffer_array, WORK_BUFFER_ARRAY_SIZE)); - while (tok.meta.ri < tok.meta.wi) { - wuffs_base__token* t = &tok.data.ptr[tok.meta.ri++]; + while (g_tok.meta.ri < g_tok.meta.wi) { + wuffs_base__token* t = &g_tok.data.ptr[g_tok.meta.ri++]; uint16_t len = wuffs_base__token__length(t); - if (flags.all_tokens || (wuffs_base__token__value(t) != 0)) { + if (g_flags.all_tokens || (wuffs_base__token__value(t) != 0)) { uint8_t lp = wuffs_base__token__link_prev(t) ? 1 : 0; uint8_t ln = wuffs_base__token__link_next(t) ? 1 : 0; uint32_t vmajor = wuffs_base__token__value_major(t); @@ -278,7 +278,7 @@ main1(int argc, char** argv) { uint8_t vbc = wuffs_base__token__value_base_category(t); uint32_t vbd = wuffs_base__token__value_base_detail(t); - if (flags.human_readable) { + if (g_flags.human_readable) { printf("pos=0x%08" PRIX32 " len=0x%04" PRIX16 " link=0b%d%d ", (uint32_t)(pos), len, (int)(lp), (int)(ln)); @@ -293,10 +293,10 @@ main1(int argc, char** argv) { uint32_t m3 = m; printf("vmajor=0x%06" PRIX32 ":%c%c%c%c vminor=0x%06" PRIX32 "\n", - vmajor, base38_decode[m0], base38_decode[m1], - base38_decode[m2], base38_decode[m3], vminor); + vmajor, g_base38_decode[m0], g_base38_decode[m1], + g_base38_decode[m2], g_base38_decode[m3], vminor); } else { - printf("vbc=%s. vbd=0x%06" PRIX32 "\n", vbc_names[vbc & 7], vbd); + printf("vbc=%s. vbd=0x%06" PRIX32 "\n", g_vbc_names[vbc & 7], vbd); } } else { @@ -328,7 +328,7 @@ main1(int argc, char** argv) { } else if (status.repr == wuffs_base__suspension__short_read) { TRY(read_src()); } else if (status.repr == wuffs_base__suspension__short_write) { - wuffs_base__token_buffer__compact(&tok); + wuffs_base__token_buffer__compact(&g_tok); } else { return wuffs_base__status__message(&status); }