mirror of
https://github.com/ddidderr/wuffs.git
synced 2026-11-18 00:32:11 +01:00
Have script/*.c global var names start with g_
This commit is contained in:
1 parent
f909c69deb
commit
c0bd9df978
3 files changed
+130
-128
No files matched your search
+16
-16
@@ -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;
|
||||
}
|
||||
@@ -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"
|
||||
|
||||
@@ -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);
|
||||
}
|
||||
|
||||
Reference in new issue
Block a user