From f3146c2ea9c816a536b9496cd71f073c6edd8dd8 Mon Sep 17 00:00:00 2001 From: Nigel Tao Date: Thu, 26 Mar 2020 08:47:42 +1100 Subject: [PATCH] Add base.token_decoder.workbuf_len --- example/jsonfindptrs/jsonfindptrs.cc | 14 +++- example/jsonptr/jsonptr.cc | 15 +++- fuzz/c/std/json_fuzzer.c | 19 +++++- fuzz/c/std/zlib_fuzzer.c | 5 +- lang/builtin/builtin.go | 3 +- release/c/wuffs-unsupported-snapshot.c | 95 +++++++++++++++++++++++--- script/print-json-token-debug-format.c | 16 ++++- std/json/common_consts.wuffs | 2 + std/json/decode_json.wuffs | 8 ++- test/c/std/json.c | 64 +++++++++-------- test/c/testlib/testlib.c | 4 +- 11 files changed, 193 insertions(+), 52 deletions(-) diff --git a/example/jsonfindptrs/jsonfindptrs.cc b/example/jsonfindptrs/jsonfindptrs.cc index a21a2ce9..73ed7ad2 100644 --- a/example/jsonfindptrs/jsonfindptrs.cc +++ b/example/jsonfindptrs/jsonfindptrs.cc @@ -233,6 +233,9 @@ parse_flags(int argc, char** argv) { // ---- +#define WORK_BUFFER_ARRAY_SIZE \ + WUFFS_JSON__DECODER_WORKBUF_LEN_MAX_INCL_WORST_CASE + #ifndef SRC_BUFFER_ARRAY_SIZE #define SRC_BUFFER_ARRAY_SIZE (4 * 1024) #endif @@ -305,7 +308,10 @@ class TokenStream { return Result(m_status.message()); } - m_status = m_dec.decode_tokens(&m_tok, &m_src); + m_status = + m_dec.decode_tokens(&m_tok, &m_src, + wuffs_base__make_slice_u8( + m_work_buffer_array, WORK_BUFFER_ARRAY_SIZE)); } wuffs_base__token t = m_tok.data.ptr[m_tok.meta.ri]; @@ -355,6 +361,12 @@ class TokenStream { wuffs_base__token m_tok_array[TOKEN_BUFFER_ARRAY_SIZE]; uint8_t m_src_array[SRC_BUFFER_ARRAY_SIZE]; +#if WORK_BUFFER_ARRAY_SIZE > 0 + uint8_t m_work_buffer_array[WORK_BUFFER_ARRAY_SIZE]; +#else + // Not all C/C++ compilers support 0-length arrays. + uint8_t m_work_buffer_array[1]; +#endif wuffs_json__decoder m_dec; }; diff --git a/example/jsonptr/jsonptr.cc b/example/jsonptr/jsonptr.cc index a8209615..e9ba1512 100644 --- a/example/jsonptr/jsonptr.cc +++ b/example/jsonptr/jsonptr.cc @@ -232,6 +232,17 @@ static const char* usage = // ---- +// Wuffs allows either statically or dynamically allocated work buffers. This +// program exercises static allocation. +#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]; +#else +// Not all C/C++ compilers support 0-length arrays. +uint8_t work_buffer_array[1]; +#endif + bool sandboxed = false; int input_file_descriptor = 0; // A 0 default means stdin. @@ -1013,7 +1024,9 @@ main1(int argc, char** argv) { TRY(initialize_globals(argc, argv)); while (true) { - wuffs_base__status status = dec.decode_tokens(&tok, &src); + wuffs_base__status status = dec.decode_tokens( + &tok, &src, + wuffs_base__make_slice_u8(work_buffer_array, WORK_BUFFER_ARRAY_SIZE)); while (tok.meta.ri < tok.meta.wi) { wuffs_base__token t = tok.data.ptr[tok.meta.ri++]; diff --git a/fuzz/c/std/json_fuzzer.c b/fuzz/c/std/json_fuzzer.c index ae377be8..a5bb0be2 100644 --- a/fuzz/c/std/json_fuzzer.c +++ b/fuzz/c/std/json_fuzzer.c @@ -62,6 +62,17 @@ It should print "PASS", amongst other information, and exit(0). #define TOK_BUFFER_ARRAY_SIZE 4096 #define STACK_SIZE (WUFFS_JSON__DECODER_DEPTH_MAX_INCL + 1) +// Wuffs allows either statically or dynamically allocated work buffers. This +// program exercises static allocation. +#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]; +#else +// Not all C/C++ compilers support 0-length arrays. +uint8_t work_buffer_array[1]; +#endif + // Each stack element is 1 byte. The low 7 bits denote the container: // - 0x01 means no container: we are at the top level. // - 0x02 means a [] list. @@ -297,7 +308,9 @@ fuzz_complex(wuffs_base__io_buffer* full_src, uint32_t hash_24_bits) { size_t old_src_ri = src.meta.ri; size_t ti = old_src_ri; - status = wuffs_json__decoder__decode_tokens(&dec, &tok, &src); + status = wuffs_json__decoder__decode_tokens( + &dec, &tok, &src, + wuffs_base__make_slice_u8(work_buffer_array, WORK_BUFFER_ARRAY_SIZE)); if ((tok.data.len < tok.meta.wi) || // (tok.meta.wi < tok.meta.ri) || // (tok.meta.ri != old_tok_ri)) { @@ -386,7 +399,9 @@ fuzz_simple(wuffs_base__io_buffer* full_src) { }); while (true) { - status = wuffs_json__decoder__decode_tokens(&dec, &tok, full_src); + status = wuffs_json__decoder__decode_tokens( + &dec, &tok, full_src, + wuffs_base__make_slice_u8(work_buffer_array, WORK_BUFFER_ARRAY_SIZE)); if (status.repr == NULL) { break; diff --git a/fuzz/c/std/zlib_fuzzer.c b/fuzz/c/std/zlib_fuzzer.c index 4835c6e4..cf7eb66d 100644 --- a/fuzz/c/std/zlib_fuzzer.c +++ b/fuzz/c/std/zlib_fuzzer.c @@ -101,10 +101,7 @@ fuzz(wuffs_base__io_buffer* src, uint32_t hash) { dst.meta.wi = 0; status = wuffs_zlib__decoder__transform_io(&dec, &dst, src, - ((wuffs_base__slice_u8){ - .ptr = work_buffer_array, - .len = WORK_BUFFER_ARRAY_SIZE, - })); + wuffs_base__make_slice_u8(work_buffer_array, WORK_BUFFER_ARRAY_SIZE)); if (status.repr != wuffs_base__suspension__short_write) { break; } diff --git a/lang/builtin/builtin.go b/lang/builtin/builtin.go index af5503bb..06ca6e89 100644 --- a/lang/builtin/builtin.go +++ b/lang/builtin/builtin.go @@ -422,7 +422,8 @@ var InterfaceFuncs = []string{ // ---- token_decoder - "token_decoder.decode_tokens?(dst: token_writer, src: io_reader)", + "token_decoder.decode_tokens?(dst: token_writer, src: io_reader, workbuf: slice u8)", + "token_decoder.workbuf_len() range_ii_u64", } // The "T1" and "T2" types here are placeholders for generic "slice T" or diff --git a/release/c/wuffs-unsupported-snapshot.c b/release/c/wuffs-unsupported-snapshot.c index 9598c164..ca1e98e4 100644 --- a/release/c/wuffs-unsupported-snapshot.c +++ b/release/c/wuffs-unsupported-snapshot.c @@ -4039,7 +4039,9 @@ extern const char* wuffs_base__token_decoder__vtable_name; typedef struct { wuffs_base__status (*decode_tokens)(void* self, wuffs_base__token_buffer* a_dst, - wuffs_base__io_buffer* a_src); + wuffs_base__io_buffer* a_src, + wuffs_base__slice_u8 a_workbuf); + wuffs_base__range_ii_u64 (*workbuf_len)(const void* self); } wuffs_base__token_decoder__func_ptrs; typedef struct wuffs_base__token_decoder__struct wuffs_base__token_decoder; @@ -4047,7 +4049,11 @@ typedef struct wuffs_base__token_decoder__struct wuffs_base__token_decoder; WUFFS_BASE__MAYBE_STATIC wuffs_base__status // wuffs_base__token_decoder__decode_tokens(wuffs_base__token_decoder* self, wuffs_base__token_buffer* a_dst, - wuffs_base__io_buffer* a_src); + wuffs_base__io_buffer* a_src, + wuffs_base__slice_u8 a_workbuf); + +WUFFS_BASE__MAYBE_STATIC wuffs_base__range_ii_u64 // +wuffs_base__token_decoder__workbuf_len(const wuffs_base__token_decoder* self); #if defined(__cplusplus) || defined(WUFFS_IMPLEMENTATION) @@ -4061,8 +4067,16 @@ struct wuffs_base__token_decoder__struct { #ifdef __cplusplus inline wuffs_base__status // - decode_tokens(wuffs_base__token_buffer* a_dst, wuffs_base__io_buffer* a_src) { - return wuffs_base__token_decoder__decode_tokens(this, a_dst, a_src); + decode_tokens(wuffs_base__token_buffer* a_dst, + wuffs_base__io_buffer* a_src, + wuffs_base__slice_u8 a_workbuf) { + return wuffs_base__token_decoder__decode_tokens(this, a_dst, a_src, + a_workbuf); + } + + inline wuffs_base__range_ii_u64 // + workbuf_len() const { + return wuffs_base__token_decoder__workbuf_len(this); } #endif // __cplusplus @@ -5908,6 +5922,8 @@ extern const char* wuffs_json__error__unsupported_recursion_depth; // ---------------- Public Consts +#define WUFFS_JSON__DECODER_WORKBUF_LEN_MAX_INCL_WORST_CASE 0 + #define WUFFS_JSON__DECODER_DEPTH_MAX_INCL 1024 #define WUFFS_JSON__DECODER_DST_TOKEN_BUFFER_LENGTH_MIN_INCL 1 @@ -5982,10 +5998,14 @@ wuffs_json__decoder__set_quirk_enabled(wuffs_json__decoder* self, uint32_t a_quirk, bool a_enabled); +WUFFS_BASE__MAYBE_STATIC wuffs_base__range_ii_u64 // +wuffs_json__decoder__workbuf_len(const wuffs_json__decoder* self); + WUFFS_BASE__MAYBE_STATIC wuffs_base__status // wuffs_json__decoder__decode_tokens(wuffs_json__decoder* self, wuffs_base__token_buffer* a_dst, - wuffs_base__io_buffer* a_src); + wuffs_base__io_buffer* a_src, + wuffs_base__slice_u8 a_workbuf); // ---------------- Struct Definitions @@ -6095,9 +6115,16 @@ struct wuffs_json__decoder__struct { return wuffs_json__decoder__set_quirk_enabled(this, a_quirk, a_enabled); } + inline wuffs_base__range_ii_u64 // + workbuf_len() const { + return wuffs_json__decoder__workbuf_len(this); + } + inline wuffs_base__status // - decode_tokens(wuffs_base__token_buffer* a_dst, wuffs_base__io_buffer* a_src) { - return wuffs_json__decoder__decode_tokens(this, a_dst, a_src); + decode_tokens(wuffs_base__token_buffer* a_dst, + wuffs_base__io_buffer* a_src, + wuffs_base__slice_u8 a_workbuf) { + return wuffs_json__decoder__decode_tokens(this, a_dst, a_src, a_workbuf); } #endif // __cplusplus @@ -7620,7 +7647,8 @@ const char* wuffs_base__token_decoder__vtable_name = WUFFS_BASE__MAYBE_STATIC wuffs_base__status // wuffs_base__token_decoder__decode_tokens(wuffs_base__token_decoder* self, wuffs_base__token_buffer* a_dst, - wuffs_base__io_buffer* a_src) { + wuffs_base__io_buffer* a_src, + wuffs_base__slice_u8 a_workbuf) { if (!self) { return wuffs_base__make_status(wuffs_base__error__bad_receiver); } @@ -7637,7 +7665,7 @@ wuffs_base__token_decoder__decode_tokens(wuffs_base__token_decoder* self, if (v->vtable_name == wuffs_base__token_decoder__vtable_name) { const wuffs_base__token_decoder__func_ptrs* func_ptrs = (const wuffs_base__token_decoder__func_ptrs*)(v->function_pointers); - return (*func_ptrs->decode_tokens)(self, a_dst, a_src); + return (*func_ptrs->decode_tokens)(self, a_dst, a_src, a_workbuf); } else if (v->vtable_name == NULL) { break; } @@ -7647,6 +7675,32 @@ wuffs_base__token_decoder__decode_tokens(wuffs_base__token_decoder* self, return wuffs_base__make_status(wuffs_base__error__bad_vtable); } +WUFFS_BASE__MAYBE_STATIC wuffs_base__range_ii_u64 // +wuffs_base__token_decoder__workbuf_len(const wuffs_base__token_decoder* self) { + if (!self) { + return wuffs_base__utility__empty_range_ii_u64(); + } + if ((self->private_impl.magic != WUFFS_BASE__MAGIC) && + (self->private_impl.magic != WUFFS_BASE__DISABLED)) { + return wuffs_base__utility__empty_range_ii_u64(); + } + + const wuffs_base__vtable* v = &self->private_impl.first_vtable; + int i; + for (i = 0; i < 63; i++) { + if (v->vtable_name == wuffs_base__token_decoder__vtable_name) { + const wuffs_base__token_decoder__func_ptrs* func_ptrs = + (const wuffs_base__token_decoder__func_ptrs*)(v->function_pointers); + return (*func_ptrs->workbuf_len)(self); + } else if (v->vtable_name == NULL) { + break; + } + v++; + } + + return wuffs_base__utility__empty_range_ii_u64(); +} + // ---------------- Images const uint32_t wuffs_base__pixel_format__bits_per_channel[16] = { @@ -20356,8 +20410,11 @@ const wuffs_base__token_decoder__func_ptrs wuffs_json__decoder__func_ptrs_for__wuffs_base__token_decoder = { (wuffs_base__status(*)(void*, wuffs_base__token_buffer*, - wuffs_base__io_buffer*))( + wuffs_base__io_buffer*, + wuffs_base__slice_u8))( &wuffs_json__decoder__decode_tokens), + (wuffs_base__range_ii_u64(*)(const void*))( + &wuffs_json__decoder__workbuf_len), }; // ---------------- Initializer Implementations @@ -20468,12 +20525,28 @@ wuffs_json__decoder__set_quirk_enabled(wuffs_json__decoder* self, return wuffs_base__make_empty_struct(); } +// -------- func json.decoder.workbuf_len + +WUFFS_BASE__MAYBE_STATIC wuffs_base__range_ii_u64 // +wuffs_json__decoder__workbuf_len(const wuffs_json__decoder* self) { + if (!self) { + return wuffs_base__utility__empty_range_ii_u64(); + } + if ((self->private_impl.magic != WUFFS_BASE__MAGIC) && + (self->private_impl.magic != WUFFS_BASE__DISABLED)) { + return wuffs_base__utility__empty_range_ii_u64(); + } + + return wuffs_base__utility__empty_range_ii_u64(); +} + // -------- func json.decoder.decode_tokens WUFFS_BASE__MAYBE_STATIC wuffs_base__status // wuffs_json__decoder__decode_tokens(wuffs_json__decoder* self, wuffs_base__token_buffer* a_dst, - wuffs_base__io_buffer* a_src) { + wuffs_base__io_buffer* a_src, + wuffs_base__slice_u8 a_workbuf) { if (!self) { return wuffs_base__make_status(wuffs_base__error__bad_receiver); } diff --git a/script/print-json-token-debug-format.c b/script/print-json-token-debug-format.c index ede793cf..1a370ba2 100644 --- a/script/print-json-token-debug-format.c +++ b/script/print-json-token-debug-format.c @@ -84,6 +84,17 @@ // program to generate a stand-alone C++ file. #include "../release/c/wuffs-unsupported-snapshot.c" +// Wuffs allows either statically or dynamically allocated work buffers. This +// program exercises static allocation. +#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]; +#else +// Not all C/C++ compilers support 0-length arrays. +uint8_t work_buffer_array[1]; +#endif + #ifndef SRC_BUFFER_ARRAY_SIZE #define SRC_BUFFER_ARRAY_SIZE (64 * 1024 * 1024) #endif @@ -251,8 +262,9 @@ main1(int argc, char** argv) { uint64_t pos = 0; while (true) { - wuffs_base__status status = - wuffs_json__decoder__decode_tokens(&dec, &tok, &src); + wuffs_base__status status = wuffs_json__decoder__decode_tokens( + &dec, &tok, &src, + wuffs_base__make_slice_u8(work_buffer_array, WORK_BUFFER_ARRAY_SIZE)); while (tok.meta.ri < tok.meta.wi) { wuffs_base__token* t = &tok.data.ptr[tok.meta.ri++]; diff --git a/std/json/common_consts.wuffs b/std/json/common_consts.wuffs index f92383de..10c7efe6 100644 --- a/std/json/common_consts.wuffs +++ b/std/json/common_consts.wuffs @@ -21,6 +21,8 @@ pub status "#unsupported recursion depth" pri status "#internal error: inconsistent I/O" +pub const decoder_workbuf_len_max_incl_worst_case base.u64 = 0 + // decoder_depth_max_incl is the maximum supported recursion depth: how deeply // nested [] arrays and {} objects can be. // diff --git a/std/json/decode_json.wuffs b/std/json/decode_json.wuffs index c3db53c4..ddae591c 100644 --- a/std/json/decode_json.wuffs +++ b/std/json/decode_json.wuffs @@ -32,6 +32,8 @@ pub struct decoder? implements base.token_decoder( allow_leading_ubom : base.bool, end_of_data : base.bool, + + util : base.utility, )( // stack is conceptually an array of bits, implemented as an array of u32. // The N'th bit being 0 or 1 means that we're in an array or object, where @@ -100,7 +102,11 @@ pub func decoder.set_quirk_enabled!(quirk: base.u32, enabled: base.bool) { } } -pub func decoder.decode_tokens?(dst: base.token_writer, src: base.io_reader) { +pub func decoder.workbuf_len() base.range_ii_u64 { + return this.util.empty_range_ii_u64() +} + +pub func decoder.decode_tokens?(dst: base.token_writer, src: base.io_reader, workbuf: slice base.u8) { var vminor : base.u32[..= 0xFF_FFFF] var number_length : base.u32[..= 0x3FF] var number_status : base.u32[..= 0x3] diff --git a/test/c/std/json.c b/test/c/std/json.c index 7ec55259..f54a1ed1 100644 --- a/test/c/std/json.c +++ b/test/c/std/json.c @@ -870,8 +870,8 @@ wuffs_json_decode(wuffs_base__token_buffer* tok, make_limited_token_writer(*tok, wlimit); wuffs_base__io_buffer limited_src = make_limited_reader(*src, rlimit); - wuffs_base__status status = - wuffs_json__decoder__decode_tokens(&dec, &limited_tok, &limited_src); + wuffs_base__status status = wuffs_json__decoder__decode_tokens( + &dec, &limited_tok, &limited_src, global_work_slice); tok->meta.wi += limited_tok.meta.wi; src->meta.ri += limited_src.meta.ri; @@ -905,14 +905,15 @@ test_wuffs_json_decode_end_of_data() { wuffs_base__make_token_buffer_writer(global_have_token_slice); wuffs_base__io_buffer src = wuffs_base__make_io_buffer_reader( wuffs_base__make_slice_u8(src_ptr, src_len), true); - CHECK_STATUS("decode_tokens", - wuffs_json__decoder__decode_tokens(&dec, &tok, &src)); + CHECK_STATUS("decode_tokens", wuffs_json__decoder__decode_tokens( + &dec, &tok, &src, global_work_slice)); if (src.meta.ri != 3) { RETURN_FAIL("src.meta.ri: have %zu, want 3", src.meta.ri); } const char* have = - wuffs_json__decoder__decode_tokens(&dec, &tok, &src).repr; + wuffs_json__decoder__decode_tokens(&dec, &tok, &src, global_work_slice) + .repr; if (have != wuffs_base__note__end_of_data) { RETURN_FAIL("decode_tokens: have \"%s\", want \"%s\"", have, wuffs_base__note__end_of_data); @@ -1016,8 +1017,9 @@ test_wuffs_json_decode_long_numbers() { wuffs_base__make_token_buffer_writer(global_have_token_slice); wuffs_base__io_buffer src = wuffs_base__make_io_buffer_reader(src_data, closed != 0); - const char* have = - wuffs_json__decoder__decode_tokens(&dec, &tok, &src).repr; + const char* have = wuffs_json__decoder__decode_tokens(&dec, &tok, &src, + global_work_slice) + .repr; size_t total_length = 0; while (tok.meta.ri < tok.meta.wi) { @@ -1161,7 +1163,8 @@ test_wuffs_json_decode_prior_valid_utf_8() { wuffs_base__make_token_buffer_writer(global_have_token_slice); wuffs_base__io_buffer src = wuffs_base__make_io_buffer_reader(src_data, closed != 0); - wuffs_json__decoder__decode_tokens(&dec, &tok, &src); + wuffs_json__decoder__decode_tokens(&dec, &tok, &src, + global_work_slice); size_t have = 0; while (tok.meta.ri < tok.meta.wi) { @@ -1257,8 +1260,9 @@ test_wuffs_json_decode_quirk_allow_backslash_etc() { strlen(test_cases[tc].str)), true); - const char* have_status_repr = - wuffs_json__decoder__decode_tokens(&dec, &tok, &src).repr; + const char* have_status_repr = wuffs_json__decoder__decode_tokens( + &dec, &tok, &src, global_work_slice) + .repr; const char* want_status_repr = q ? NULL : wuffs_json__error__bad_backslash_escape; if (have_status_repr != want_status_repr) { @@ -1331,7 +1335,8 @@ test_wuffs_json_decode_quirk_allow_backslash_x() { wuffs_base__io_buffer src = wuffs_base__make_io_buffer_reader(src_slice, true); const char* have_status_repr = - wuffs_json__decoder__decode_tokens(&dec, &tok, &src).repr; + wuffs_json__decoder__decode_tokens(&dec, &tok, &src, global_work_slice) + .repr; if (have_status_repr != test_cases[tc].want_status_repr) { RETURN_FAIL("tc=%d: decode_tokens: have \"%s\", want \"%s\"", tc, have_status_repr, test_cases[tc].want_status_repr); @@ -1404,8 +1409,9 @@ test_wuffs_json_decode_quirk_allow_extra_comma() { wuffs_base__make_slice_u8((void*)(test_cases[tc].str), strlen(test_cases[tc].str)), true); - const char* have = - wuffs_json__decoder__decode_tokens(&dec, &tok, &src).repr; + const char* have = wuffs_json__decoder__decode_tokens(&dec, &tok, &src, + global_work_slice) + .repr; const char* want = (test_cases[tc].want[q] != '-') ? NULL : wuffs_json__error__bad_input; if (have != want) { @@ -1480,8 +1486,9 @@ test_wuffs_json_decode_quirk_allow_inf_nan_numbers() { wuffs_base__make_slice_u8((void*)(test_cases[tc].str), strlen(test_cases[tc].str)), true); - const char* have = - wuffs_json__decoder__decode_tokens(&dec, &tok, &src).repr; + const char* have = wuffs_json__decoder__decode_tokens(&dec, &tok, &src, + global_work_slice) + .repr; const char* want = (test_cases[tc].want[q] != '-') ? NULL : wuffs_json__error__bad_input; if (have != want) { @@ -1552,8 +1559,9 @@ test_wuffs_json_decode_quirk_allow_comment_etc() { wuffs_base__make_slice_u8((void*)(test_cases[tc].str), strlen(test_cases[tc].str)), true); - const char* have = - wuffs_json__decoder__decode_tokens(&dec, &tok, &src).repr; + const char* have = wuffs_json__decoder__decode_tokens(&dec, &tok, &src, + global_work_slice) + .repr; const char* want = (test_cases[tc].want[q] != '-') ? NULL : wuffs_json__error__bad_input; if (have != want) { @@ -1630,8 +1638,9 @@ test_wuffs_json_decode_quirk_allow_leading_etc() { wuffs_base__make_slice_u8((void*)(test_cases[tc].str), strlen(test_cases[tc].str)), true); - const char* have = - wuffs_json__decoder__decode_tokens(&dec, &tok, &src).repr; + const char* have = wuffs_json__decoder__decode_tokens(&dec, &tok, &src, + global_work_slice) + .repr; const char* want = (test_cases[tc].want[q] != '-') ? NULL : wuffs_json__error__bad_input; if (have != want) { @@ -1708,8 +1717,9 @@ test_wuffs_json_decode_quirk_allow_trailing_etc() { wuffs_base__make_slice_u8((void*)(test_cases[tc].str), strlen(test_cases[tc].str)), true); - const char* have = - wuffs_json__decoder__decode_tokens(&dec, &tok, &src).repr; + const char* have = wuffs_json__decoder__decode_tokens(&dec, &tok, &src, + global_work_slice) + .repr; const char* want = (test_cases[tc].want[q] != '-') ? NULL : wuffs_json__error__bad_input; if (have != want) { @@ -1807,8 +1817,8 @@ test_wuffs_json_decode_quirk_replace_invalid_unicode() { wuffs_base__make_slice_u8((void*)(test_cases[tc].str), strlen(test_cases[tc].str)), true); - CHECK_STATUS("decode_tokens", - wuffs_json__decoder__decode_tokens(&dec, &tok, &src)); + CHECK_STATUS("decode_tokens", wuffs_json__decoder__decode_tokens( + &dec, &tok, &src, global_work_slice)); uint64_t src_index = 0; while (tok.meta.ri < tok.meta.wi) { @@ -1941,7 +1951,7 @@ test_wuffs_json_decode_unicode4_escapes() { wuffs_base__make_slice_u8((void*)(test_cases[tc].str), strlen(test_cases[tc].str)), true); - wuffs_json__decoder__decode_tokens(&dec, &tok, &src); + wuffs_json__decoder__decode_tokens(&dec, &tok, &src, global_work_slice); uint32_t have = fail; uint64_t total_length = 0; @@ -2033,8 +2043,8 @@ test_wuffs_json_decode_src_io_buffer_length() { &dec, sizeof dec, WUFFS_VERSION, WUFFS_INITIALIZE__LEAVE_INTERNAL_BUFFERS_UNINITIALIZED)); - wuffs_base__status have = - wuffs_json__decoder__decode_tokens(&dec, &tok, &src); + wuffs_base__status have = wuffs_json__decoder__decode_tokens( + &dec, &tok, &src, global_work_slice); const char* want = (i > WUFFS_JSON__DECODER_NUMBER_LENGTH_MAX_INCL) ? wuffs_json__error__unsupported_number_length @@ -2134,7 +2144,7 @@ test_wuffs_json_decode_string() { strlen(test_cases[tc].str)), true); wuffs_base__status have_status = - wuffs_json__decoder__decode_tokens(&dec, &tok, &src); + wuffs_json__decoder__decode_tokens(&dec, &tok, &src, global_work_slice); uint64_t total_length = 0; size_t i; diff --git a/test/c/testlib/testlib.c b/test/c/testlib/testlib.c index 7a4ac1ab..88da6a2d 100644 --- a/test/c/testlib/testlib.c +++ b/test/c/testlib/testlib.c @@ -1124,8 +1124,8 @@ do_test__wuffs_base__token_decoder(wuffs_base__token_decoder* b, src.meta.closed = true; } - CHECK_STATUS("decode_tokens", - wuffs_base__token_decoder__decode_tokens(b, &tok, &src)); + CHECK_STATUS("decode_tokens", wuffs_base__token_decoder__decode_tokens( + b, &tok, &src, global_work_slice)); uint64_t pos = 0; while (tok.meta.ri < tok.meta.wi) {