diff --git a/example/json-to-cbor/json-to-cbor.cc b/example/json-to-cbor/json-to-cbor.cc index b1e4195b..ae437790 100644 --- a/example/json-to-cbor/json-to-cbor.cc +++ b/example/json-to-cbor/json-to-cbor.cc @@ -289,11 +289,6 @@ class Callbacks : public wuffs_aux::DecodeJsonCallbacks { : Append(static_cast(-(val + 1)), 0x20); } - std::string AppendByteString(std::string&& val) override { - TRY(Append(val.size(), 0x40)); - return write_dst(val.data(), val.size()); - } - std::string AppendTextString(std::string&& val) override { TRY(Append(val.size(), 0x60)); return write_dst(val.data(), val.size()); diff --git a/fuzz/c/std/json_fuzzer.c b/fuzz/c/std/json_fuzzer.c index e47bc36e..c82946b5 100644 --- a/fuzz/c/std/json_fuzzer.c +++ b/fuzz/c/std/json_fuzzer.c @@ -232,8 +232,7 @@ void set_quirks(wuffs_json__decoder* dec, uint64_t hash_44_bits) { WUFFS_JSON__QUIRK_ALLOW_BACKSLASH_QUESTION_MARK, WUFFS_JSON__QUIRK_ALLOW_BACKSLASH_SINGLE_QUOTE, WUFFS_JSON__QUIRK_ALLOW_BACKSLASH_V, - (hash_44_bits & 1) ? WUFFS_JSON__QUIRK_ALLOW_BACKSLASH_X_AS_BYTES - : WUFFS_JSON__QUIRK_ALLOW_BACKSLASH_X_AS_CODE_POINTS, + WUFFS_JSON__QUIRK_ALLOW_BACKSLASH_X_AS_CODE_POINTS, WUFFS_JSON__QUIRK_ALLOW_BACKSLASH_ZERO, WUFFS_JSON__QUIRK_ALLOW_COMMENT_BLOCK, WUFFS_JSON__QUIRK_ALLOW_COMMENT_LINE, @@ -246,13 +245,10 @@ void set_quirks(wuffs_json__decoder* dec, uint64_t hash_44_bits) { 0, }; - // Shift off a bit for the ETC_BACKSLASH_X_ETC choice. - uint64_t hash_43_bits = hash_44_bits >> 1; - uint32_t i; for (i = 0; quirks[i]; i++) { - uint64_t bit = 1 << (i % 43); - if (hash_43_bits & bit) { + uint64_t bit = 1 << (i % 44); + if (hash_44_bits & bit) { wuffs_json__decoder__set_quirk_enabled(dec, quirks[i], true); } } diff --git a/internal/cgen/auxiliary/json.cc b/internal/cgen/auxiliary/json.cc index aec8cbfd..c2e6692e 100644 --- a/internal/cgen/auxiliary/json.cc +++ b/internal/cgen/auxiliary/json.cc @@ -27,11 +27,6 @@ DecodeJsonResult::DecodeJsonResult(std::string&& error_message0, : error_message(std::move(error_message0)), cursor_position(cursor_position0) {} -std::string // -DecodeJsonCallbacks::AppendByteString(std::string&& val) { - return "wuffs_aux::DecodeJson: unexpected JSON byte string"; -} - void // DecodeJsonCallbacks::Done(DecodeJsonResult& result, sync_io::Input& input, @@ -145,32 +140,6 @@ DecodeJson_SplitJsonPointer(std::string& s, return std::make_pair(std::move(fragment), i); } -std::string // -DecodeJson_DecodeBackslashX(std::string& str, - uint8_t* token_ptr, - size_t token_len) { - wuffs_base__slice_u8 encoded = - wuffs_base__make_slice_u8(token_ptr, token_len); - while (encoded.len > 0) { - uint8_t decoded[64]; - constexpr bool src_closed = true; - wuffs_base__transform__output o = wuffs_base__base_16__decode4( - wuffs_base__make_slice_u8(&decoded[0], sizeof decoded), encoded, - src_closed, WUFFS_BASE__BASE_16__DEFAULT_OPTIONS); - if (o.status.is_error()) { - return o.status.message(); - } else if ((o.num_dst > (sizeof decoded)) || (o.num_src > encoded.len)) { - return "wuffs_aux::DecodeJson: internal error: inconsistent base16 " - "decoding"; - } - str.append( // Convert from (uint8_t*). - static_cast(static_cast(&decoded[0])), o.num_dst); - encoded.ptr += o.num_src; - encoded.len -= o.num_src; - } - return ""; -} - // -------- std::string // @@ -229,14 +198,6 @@ do_dict: const char* ptr = // Convert from (uint8_t*). static_cast(static_cast(token_ptr)); str.append(ptr, token_len); - } else if ( - vbd & - WUFFS_BASE__TOKEN__VBD__STRING__CONVERT_1_DST_4_SRC_BACKSLASH_X) { - ret_error_message = - DecodeJson_DecodeBackslashX(str, token_ptr, token_len); - if (!ret_error_message.empty()) { - goto done; - } } else { goto fail; } @@ -465,24 +426,13 @@ DecodeJson(DecodeJsonCallbacks& callbacks, const char* ptr = // Convert from (uint8_t*). static_cast(static_cast(token_ptr)); str.append(ptr, token_len); - } else if ( - vbd & - WUFFS_BASE__TOKEN__VBD__STRING__CONVERT_1_DST_4_SRC_BACKSLASH_X) { - ret_error_message = - DecodeJson_DecodeBackslashX(str, token_ptr, token_len); - if (!ret_error_message.empty()) { - goto done; - } } else { goto fail; } if (token.continued()) { continue; } - ret_error_message = - (vbd & WUFFS_BASE__TOKEN__VBD__STRING__CHAIN_MUST_BE_UTF_8) - ? callbacks.AppendTextString(std::move(str)) - : callbacks.AppendByteString(std::move(str)); + ret_error_message = callbacks.AppendTextString(std::move(str)); str.clear(); goto parsed_a_value; } diff --git a/internal/cgen/auxiliary/json.hh b/internal/cgen/auxiliary/json.hh index 7e58d70f..8e6df1bc 100644 --- a/internal/cgen/auxiliary/json.hh +++ b/internal/cgen/auxiliary/json.hh @@ -31,21 +31,10 @@ class DecodeJsonCallbacks { // strings, the Callbacks implementation is responsible for tracking map keys // versus other values. - // The JSON file format as specified deals only with (UTF-8) text strings, - // but an unofficial extension allows "ijk\x89m" escapes within those - // strings. DecodeJsonCallbacks' AppendByteString will not be called unless - // WUFFS_JSON__QUIRK_ALLOW_BACKSLASH_X_AS_BYTES is passed to DecodeJson. If - // it is passed, AppendTextString will not be called and all byte strings are - // potentially invalid UTF-8. It is up to the AppendByteString implementation - // whether to test the std::string for UTF-8 validity. - // - // The default AppendByteString implementation returns an error message. - virtual std::string AppendNull() = 0; virtual std::string AppendBool(bool val) = 0; virtual std::string AppendF64(double val) = 0; virtual std::string AppendI64(int64_t val) = 0; - virtual std::string AppendByteString(std::string&& val); virtual std::string AppendTextString(std::string&& val) = 0; // Push and Pop are called for container nodes: JSON arrays (lists) and JSON diff --git a/internal/cgen/data/data.go b/internal/cgen/data/data.go index 1aebd22c..0cdec624 100644 --- a/internal/cgen/data/data.go +++ b/internal/cgen/data/data.go @@ -649,7 +649,7 @@ const AuxCborHh = "" + "" const AuxJsonCc = "" + - "// ---------------- Auxiliary - JSON\n\n#if !defined(WUFFS_CONFIG__MODULES) || defined(WUFFS_CONFIG__MODULE__AUX__JSON)\n\n#include \n\nnamespace wuffs_aux {\n\nDecodeJsonResult::DecodeJsonResult(std::string&& error_message0,\n uint64_t cursor_position0)\n : error_message(std::move(error_message0)),\n cursor_position(cursor_position0) {}\n\nstd::string //\nDecodeJsonCallbacks::AppendByteString(std::string&& val) {\n return \"wuffs_aux::DecodeJson: unexpected JSON byte string\";\n}\n\nvoid //\nDecodeJsonCallbacks::Done(DecodeJsonResult& result,\n sync_io::Input& input,\n IOBuffer& buffer) {}\n\nconst char DecodeJson_BadJsonPointer[] =\n \"wuffs_aux::DecodeJson: bad JSON Pointer\";\nconst char DecodeJson_NoMatch[] = \"wuffs_aux::DecodeJson: no match\";\n\n" + + "// ---------------- Auxiliary - JSON\n\n#if !defined(WUFFS_CONFIG__MODULES) || defined(WUFFS_CONFIG__MODULE__AUX__JSON)\n\n#include \n\nnamespace wuffs_aux {\n\nDecodeJsonResult::DecodeJsonResult(std::string&& error_message0,\n uint64_t cursor_position0)\n : error_message(std::move(error_message0)),\n cursor_position(cursor_position0) {}\n\nvoid //\nDecodeJsonCallbacks::Done(DecodeJsonResult& result,\n sync_io::Input& input,\n IOBuffer& buffer) {}\n\nconst char DecodeJson_BadJsonPointer[] =\n \"wuffs_aux::DecodeJson: bad JSON Pointer\";\nconst char DecodeJson_NoMatch[] = \"wuffs_aux::DecodeJson: no match\";\n\n" + "" + "// --------\n\n#define WUFFS_AUX__DECODE_JSON__GET_THE_NEXT_TOKEN \\\n while (tok_buf.meta.ri >= tok_buf.meta.wi) { \\\n if (tok_status.repr == nullptr) { \\\n } else if (tok_status.repr == wuffs_base__suspension__short_write) { \\\n tok_buf.compact(); \\\n } else if (tok_status.repr == wuffs_base__suspension__short_read) { \\\n if (!io_error_message.empty()) { \\\n ret_error_message = std::move(io_error_message); \\\n goto done; \\\n } else if (cursor_index != io_buf->meta.ri) { \\\n ret_error_message = \\\n \"wuffs_aux::DecodeJson: internal error: bad cursor_index\"; \\\n goto done; \\\n } else if (io_buf->meta.closed" + ") { \\\n ret_error_message = \\\n \"wuffs_aux::DecodeJson: internal error: io_buf is closed\"; \\\n goto done; \\\n } \\\n io_buf->compact(); \\\n if (io_buf->meta.wi >= io_buf->data.len) { \\\n ret_error_message = \\\n \"wuffs_aux::DecodeJson: internal error: io_buf is full\"; \\\n goto done; \\\n } \\\n cursor_index = io_buf->meta.ri; \\\n io_error_message = input.CopyIn(io_buf); \\\n } else { \\\n ret_" + @@ -657,31 +657,30 @@ const AuxJsonCc = "" + " \\\n ((io_buf->meta.ri - cursor_index) < token_len)) { \\\n ret_error_message = \\\n \"wuffs_aux::DecodeJson: internal error: bad token indexes\"; \\\n goto done; \\\n } \\\n uint8_t* token_ptr = io_buf->data.ptr + cursor_index; \\\n (void)(token_ptr); \\\n cursor_index += token_len\n\n" + "" + "// --------\n\nnamespace {\n\n// DecodeJson_SplitJsonPointer returns (\"bar\", 8) for (\"/foo/bar/b~1z/qux\", 5,\n// etc). It returns a 0 size_t when s has invalid JSON Pointer syntax.\n//\n// The string returned is unescaped. If calling it again, this time with i=8,\n// the \"b~1z\" substring would be returned as \"b/z\".\nstd::pair //\nDecodeJson_SplitJsonPointer(std::string& s,\n size_t i,\n bool allow_tilde_r_tilde_n) {\n std::string fragment;\n while (i < s.size()) {\n char c = s[i];\n if (c == '/') {\n break;\n } else if (c != '~') {\n fragment.push_back(c);\n i++;\n continue;\n }\n i++;\n if (i >= s.size()) {\n return std::make_pair(std::string(), 0);\n }\n c = s[i];\n if (c == '0') {\n fragment.push_back('~');\n i++;\n continue;\n } else if (c == '1') {\n fragment.push_back('/');\n i++;\n continue;\n } else if (allow_tilde_r_tilde_n) {\n if (c == 'r') {\n fragment.push_ba" + - "ck('\\r');\n i++;\n continue;\n } else if (c == 'n') {\n fragment.push_back('\\n');\n i++;\n continue;\n }\n }\n return std::make_pair(std::string(), 0);\n }\n return std::make_pair(std::move(fragment), i);\n}\n\nstd::string //\nDecodeJson_DecodeBackslashX(std::string& str,\n uint8_t* token_ptr,\n size_t token_len) {\n wuffs_base__slice_u8 encoded =\n wuffs_base__make_slice_u8(token_ptr, token_len);\n while (encoded.len > 0) {\n uint8_t decoded[64];\n constexpr bool src_closed = true;\n wuffs_base__transform__output o = wuffs_base__base_16__decode4(\n wuffs_base__make_slice_u8(&decoded[0], sizeof decoded), encoded,\n src_closed, WUFFS_BASE__BASE_16__DEFAULT_OPTIONS);\n if (o.status.is_error()) {\n return o.status.message();\n } else if ((o.num_dst > (sizeof decoded)) || (o.num_src > encoded.len)) {\n return \"wuffs_aux::DecodeJson: internal error: inconsistent base16 \"\n \"decodi" + - "ng\";\n }\n str.append( // Convert from (uint8_t*).\n static_cast(static_cast(&decoded[0])), o.num_dst);\n encoded.ptr += o.num_src;\n encoded.len -= o.num_src;\n }\n return \"\";\n}\n\n" + + "ck('\\r');\n i++;\n continue;\n } else if (c == 'n') {\n fragment.push_back('\\n');\n i++;\n continue;\n }\n }\n return std::make_pair(std::string(), 0);\n }\n return std::make_pair(std::move(fragment), i);\n}\n\n" + "" + "// --------\n\nstd::string //\nDecodeJson_WalkJsonPointerFragment(wuffs_base__token_buffer& tok_buf,\n wuffs_base__status& tok_status,\n wuffs_json__decoder::unique_ptr& dec,\n wuffs_base__io_buffer* io_buf,\n std::string& io_error_message,\n size_t& cursor_index,\n sync_io::Input& input,\n std::string& json_pointer_fragment) {\n std::string ret_error_message;\n while (true) {\n WUFFS_AUX__DECODE_JSON__GET_THE_NEXT_TOKEN;\n\n int64_t vbc = token.value_base_category();\n uint64_t vbd = token.value_base_detail();\n if (vbc == WUFFS_BASE__TOKEN__VBC__FILLER) {\n continue;\n } else if ((vbc != WUFFS_BASE__TOKEN__VBC__STRUCTURE) ||\n !(vbd & WUFFS_BASE__TOKEN__VBD__STRUCTURE__PUSH)) {\n return DecodeJson_NoMatch;\n } else if (vbd & WUFFS_BASE__TOKEN__VBD__ST" + "RUCTURE__TO_LIST) {\n goto do_list;\n }\n goto do_dict;\n }\n\ndo_dict:\n // Alternate between these two things:\n // 1. Decode the next dict key (a string). If it matches the fragment, we're\n // done (success). If we've reached the dict's end (VBD__STRUCTURE__POP)\n // so that there was no next dict key, we're done (failure).\n // 2. Otherwise, skip the next dict value.\n while (true) {\n for (std::string str; true;) {\n WUFFS_AUX__DECODE_JSON__GET_THE_NEXT_TOKEN;\n\n int64_t vbc = token.value_base_category();\n uint64_t vbd = token.value_base_detail();\n switch (vbc) {\n case WUFFS_BASE__TOKEN__VBC__FILLER:\n continue;\n\n case WUFFS_BASE__TOKEN__VBC__STRUCTURE:\n if (vbd & WUFFS_BASE__TOKEN__VBD__STRUCTURE__PUSH) {\n goto fail;\n }\n return DecodeJson_NoMatch;\n\n case WUFFS_BASE__TOKEN__VBC__STRING: {\n if (vbd & WUFFS_BASE__TOKEN__VBD__STRING__CONVERT_0_DST_1_SRC_DROP) {\n // No-op.\n } els" + - "e if (vbd &\n WUFFS_BASE__TOKEN__VBD__STRING__CONVERT_1_DST_1_SRC_COPY) {\n const char* ptr = // Convert from (uint8_t*).\n static_cast(static_cast(token_ptr));\n str.append(ptr, token_len);\n } else if (\n vbd &\n WUFFS_BASE__TOKEN__VBD__STRING__CONVERT_1_DST_4_SRC_BACKSLASH_X) {\n ret_error_message =\n DecodeJson_DecodeBackslashX(str, token_ptr, token_len);\n if (!ret_error_message.empty()) {\n goto done;\n }\n } else {\n goto fail;\n }\n break;\n }\n\n case WUFFS_BASE__TOKEN__VBC__UNICODE_CODE_POINT: {\n uint8_t u[WUFFS_BASE__UTF_8__BYTE_LENGTH__MAX_INCL];\n size_t n = wuffs_base__utf_8__encode(\n wuffs_base__make_slice_u8(\n &u[0], WUFFS_BASE__UTF_8__BYTE_LENGTH__MAX_INCL),\n static_cast(vbd));\n const char* ptr = // Convert fro" + - "m (uint8_t*).\n static_cast(static_cast(&u[0]));\n str.append(ptr, n);\n break;\n }\n\n default:\n goto fail;\n }\n\n if (token.continued()) {\n continue;\n }\n if (str == json_pointer_fragment) {\n return \"\";\n }\n goto skip_the_next_dict_value;\n }\n\n skip_the_next_dict_value:\n for (uint32_t skip_depth = 0; true;) {\n WUFFS_AUX__DECODE_JSON__GET_THE_NEXT_TOKEN;\n\n int64_t vbc = token.value_base_category();\n uint64_t vbd = token.value_base_detail();\n if (token.continued() || (vbc == WUFFS_BASE__TOKEN__VBC__FILLER)) {\n continue;\n } else if (vbc == WUFFS_BASE__TOKEN__VBC__STRUCTURE) {\n if (vbd & WUFFS_BASE__TOKEN__VBD__STRUCTURE__PUSH) {\n skip_depth++;\n continue;\n }\n skip_depth--;\n }\n\n if (skip_depth == 0) {\n break;\n }\n } // skip_the_next_dict_value\n } // do_dict\n\ndo_list:\n do {\n wuffs_base__result_u64 r" + - "esult_u64 = wuffs_base__parse_number_u64(\n wuffs_base__make_slice_u8(\n static_cast(static_cast(\n const_cast(json_pointer_fragment.data()))),\n json_pointer_fragment.size()),\n WUFFS_BASE__PARSE_NUMBER_XXX__DEFAULT_OPTIONS);\n if (!result_u64.status.is_ok()) {\n return DecodeJson_NoMatch;\n }\n uint64_t remaining = result_u64.value;\n if (remaining == 0) {\n goto check_that_a_value_follows;\n }\n for (uint32_t skip_depth = 0; true;) {\n WUFFS_AUX__DECODE_JSON__GET_THE_NEXT_TOKEN;\n\n int64_t vbc = token.value_base_category();\n uint64_t vbd = token.value_base_detail();\n if (token.continued() || (vbc == WUFFS_BASE__TOKEN__VBC__FILLER)) {\n continue;\n } else if (vbc == WUFFS_BASE__TOKEN__VBC__STRUCTURE) {\n if (vbd & WUFFS_BASE__TOKEN__VBD__STRUCTURE__PUSH) {\n skip_depth++;\n continue;\n }\n if (skip_depth == 0) {\n return DecodeJson_NoMatch;\n }" + - "\n skip_depth--;\n }\n\n if (skip_depth > 0) {\n continue;\n }\n remaining--;\n if (remaining == 0) {\n goto check_that_a_value_follows;\n }\n }\n } while (false); // do_list\n\ncheck_that_a_value_follows:\n while (true) {\n WUFFS_AUX__DECODE_JSON__GET_THE_NEXT_TOKEN;\n\n int64_t vbc = token.value_base_category();\n uint64_t vbd = token.value_base_detail();\n if (vbc == WUFFS_BASE__TOKEN__VBC__FILLER) {\n continue;\n }\n\n // Undo the last part of WUFFS_AUX__DECODE_JSON__GET_THE_NEXT_TOKEN, so that\n // we're only peeking at the next token.\n tok_buf.meta.ri--;\n cursor_index -= token_len;\n\n if ((vbc == WUFFS_BASE__TOKEN__VBC__STRUCTURE) &&\n (vbd & WUFFS_BASE__TOKEN__VBD__STRUCTURE__POP)) {\n return DecodeJson_NoMatch;\n }\n return \"\";\n } // check_that_a_value_follows\n\nfail:\n return \"wuffs_aux::DecodeJson: internal error: unexpected token\";\ndone:\n return ret_error_message;\n}\n\n} // namespace\n\n" + + "e if (vbd &\n WUFFS_BASE__TOKEN__VBD__STRING__CONVERT_1_DST_1_SRC_COPY) {\n const char* ptr = // Convert from (uint8_t*).\n static_cast(static_cast(token_ptr));\n str.append(ptr, token_len);\n } else {\n goto fail;\n }\n break;\n }\n\n case WUFFS_BASE__TOKEN__VBC__UNICODE_CODE_POINT: {\n uint8_t u[WUFFS_BASE__UTF_8__BYTE_LENGTH__MAX_INCL];\n size_t n = wuffs_base__utf_8__encode(\n wuffs_base__make_slice_u8(\n &u[0], WUFFS_BASE__UTF_8__BYTE_LENGTH__MAX_INCL),\n static_cast(vbd));\n const char* ptr = // Convert from (uint8_t*).\n static_cast(static_cast(&u[0]));\n str.append(ptr, n);\n break;\n }\n\n default:\n goto fail;\n }\n\n if (token.continued()) {\n continue;\n }\n if (str == json_pointer_fragment) {\n return \"\";\n }\n" + + " goto skip_the_next_dict_value;\n }\n\n skip_the_next_dict_value:\n for (uint32_t skip_depth = 0; true;) {\n WUFFS_AUX__DECODE_JSON__GET_THE_NEXT_TOKEN;\n\n int64_t vbc = token.value_base_category();\n uint64_t vbd = token.value_base_detail();\n if (token.continued() || (vbc == WUFFS_BASE__TOKEN__VBC__FILLER)) {\n continue;\n } else if (vbc == WUFFS_BASE__TOKEN__VBC__STRUCTURE) {\n if (vbd & WUFFS_BASE__TOKEN__VBD__STRUCTURE__PUSH) {\n skip_depth++;\n continue;\n }\n skip_depth--;\n }\n\n if (skip_depth == 0) {\n break;\n }\n } // skip_the_next_dict_value\n } // do_dict\n\ndo_list:\n do {\n wuffs_base__result_u64 result_u64 = wuffs_base__parse_number_u64(\n wuffs_base__make_slice_u8(\n static_cast(static_cast(\n const_cast(json_pointer_fragment.data()))),\n json_pointer_fragment.size()),\n WUFFS_BASE__PARSE_NUMBER_XXX__DEFAULT_OPTIONS);\n if (!result" + + "_u64.status.is_ok()) {\n return DecodeJson_NoMatch;\n }\n uint64_t remaining = result_u64.value;\n if (remaining == 0) {\n goto check_that_a_value_follows;\n }\n for (uint32_t skip_depth = 0; true;) {\n WUFFS_AUX__DECODE_JSON__GET_THE_NEXT_TOKEN;\n\n int64_t vbc = token.value_base_category();\n uint64_t vbd = token.value_base_detail();\n if (token.continued() || (vbc == WUFFS_BASE__TOKEN__VBC__FILLER)) {\n continue;\n } else if (vbc == WUFFS_BASE__TOKEN__VBC__STRUCTURE) {\n if (vbd & WUFFS_BASE__TOKEN__VBD__STRUCTURE__PUSH) {\n skip_depth++;\n continue;\n }\n if (skip_depth == 0) {\n return DecodeJson_NoMatch;\n }\n skip_depth--;\n }\n\n if (skip_depth > 0) {\n continue;\n }\n remaining--;\n if (remaining == 0) {\n goto check_that_a_value_follows;\n }\n }\n } while (false); // do_list\n\ncheck_that_a_value_follows:\n while (true) {\n WUFFS_AUX__DECODE_JSON__GET_THE_NEXT_TOKEN;" + + "\n\n int64_t vbc = token.value_base_category();\n uint64_t vbd = token.value_base_detail();\n if (vbc == WUFFS_BASE__TOKEN__VBC__FILLER) {\n continue;\n }\n\n // Undo the last part of WUFFS_AUX__DECODE_JSON__GET_THE_NEXT_TOKEN, so that\n // we're only peeking at the next token.\n tok_buf.meta.ri--;\n cursor_index -= token_len;\n\n if ((vbc == WUFFS_BASE__TOKEN__VBC__STRUCTURE) &&\n (vbd & WUFFS_BASE__TOKEN__VBD__STRUCTURE__POP)) {\n return DecodeJson_NoMatch;\n }\n return \"\";\n } // check_that_a_value_follows\n\nfail:\n return \"wuffs_aux::DecodeJson: internal error: unexpected token\";\ndone:\n return ret_error_message;\n}\n\n} // namespace\n\n" + "" + "// --------\n\nDecodeJsonResult //\nDecodeJson(DecodeJsonCallbacks& callbacks,\n sync_io::Input& input,\n wuffs_base__slice_u32 quirks,\n std::string json_pointer) {\n // Prepare the wuffs_base__io_buffer and the resultant error_message.\n wuffs_base__io_buffer* io_buf = input.BringsItsOwnIOBuffer();\n wuffs_base__io_buffer fallback_io_buf = wuffs_base__empty_io_buffer();\n std::unique_ptr fallback_io_array(nullptr);\n if (!io_buf) {\n fallback_io_array = std::unique_ptr(new uint8_t[4096]);\n fallback_io_buf = wuffs_base__ptr_u8__writer(fallback_io_array.get(), 4096);\n io_buf = &fallback_io_buf;\n }\n size_t cursor_index = 0;\n std::string ret_error_message;\n std::string io_error_message;\n\n do {\n // Prepare the low-level JSON decoder.\n wuffs_json__decoder::unique_ptr dec = wuffs_json__decoder::alloc();\n if (!dec) {\n ret_error_message = \"wuffs_aux::DecodeJson: out of memory\";\n goto done;\n }\n bool allow_tilde_r_tilde_n = false;\n " + " for (size_t i = 0; i < quirks.len; i++) {\n dec->set_quirk_enabled(quirks.ptr[i], true);\n if (quirks.ptr[i] ==\n WUFFS_JSON__QUIRK_JSON_POINTER_ALLOW_TILDE_R_TILDE_N) {\n allow_tilde_r_tilde_n = true;\n }\n }\n\n // Prepare the wuffs_base__tok_buffer. 256 tokens is 2KiB.\n wuffs_base__token tok_array[256];\n wuffs_base__token_buffer tok_buf =\n wuffs_base__slice_token__writer(wuffs_base__make_slice_token(\n &tok_array[0], (sizeof(tok_array) / sizeof(tok_array[0]))));\n wuffs_base__status tok_status = wuffs_base__make_status(nullptr);\n\n // Prepare other state.\n uint32_t depth = 0;\n std::string str;\n\n // Walk the (optional) JSON Pointer.\n for (size_t i = 0; i < json_pointer.size();) {\n if (json_pointer[i] != '/') {\n ret_error_message = DecodeJson_BadJsonPointer;\n goto done;\n }\n std::pair split = DecodeJson_SplitJsonPointer(\n json_pointer, i + 1, allow_tilde_r_tilde_n);\n i = std::mo" + "ve(split.second);\n if (i == 0) {\n ret_error_message = DecodeJson_BadJsonPointer;\n goto done;\n }\n ret_error_message = DecodeJson_WalkJsonPointerFragment(\n tok_buf, tok_status, dec, io_buf, io_error_message, cursor_index,\n input, split.first);\n if (!ret_error_message.empty()) {\n goto done;\n }\n }\n\n // Loop, doing these two things:\n // 1. Get the next token.\n // 2. Process that token.\n while (true) {\n WUFFS_AUX__DECODE_JSON__GET_THE_NEXT_TOKEN;\n\n int64_t vbc = token.value_base_category();\n uint64_t vbd = token.value_base_detail();\n switch (vbc) {\n case WUFFS_BASE__TOKEN__VBC__FILLER:\n continue;\n\n case WUFFS_BASE__TOKEN__VBC__STRUCTURE: {\n if (vbd & WUFFS_BASE__TOKEN__VBD__STRUCTURE__PUSH) {\n ret_error_message = callbacks.Push(static_cast(vbd));\n if (!ret_error_message.empty()) {\n goto done;\n }\n depth++;\n c" + - "ontinue;\n }\n ret_error_message = callbacks.Pop(static_cast(vbd));\n depth--;\n goto parsed_a_value;\n }\n\n case WUFFS_BASE__TOKEN__VBC__STRING: {\n if (vbd & WUFFS_BASE__TOKEN__VBD__STRING__CONVERT_0_DST_1_SRC_DROP) {\n // No-op.\n } else if (vbd &\n WUFFS_BASE__TOKEN__VBD__STRING__CONVERT_1_DST_1_SRC_COPY) {\n const char* ptr = // Convert from (uint8_t*).\n static_cast(static_cast(token_ptr));\n str.append(ptr, token_len);\n } else if (\n vbd &\n WUFFS_BASE__TOKEN__VBD__STRING__CONVERT_1_DST_4_SRC_BACKSLASH_X) {\n ret_error_message =\n DecodeJson_DecodeBackslashX(str, token_ptr, token_len);\n if (!ret_error_message.empty()) {\n goto done;\n }\n } else {\n goto fail;\n }\n if (token.continued()) {\n continue;\n }\n " + - " ret_error_message =\n (vbd & WUFFS_BASE__TOKEN__VBD__STRING__CHAIN_MUST_BE_UTF_8)\n ? callbacks.AppendTextString(std::move(str))\n : callbacks.AppendByteString(std::move(str));\n str.clear();\n goto parsed_a_value;\n }\n\n case WUFFS_BASE__TOKEN__VBC__UNICODE_CODE_POINT: {\n uint8_t u[WUFFS_BASE__UTF_8__BYTE_LENGTH__MAX_INCL];\n size_t n = wuffs_base__utf_8__encode(\n wuffs_base__make_slice_u8(\n &u[0], WUFFS_BASE__UTF_8__BYTE_LENGTH__MAX_INCL),\n static_cast(vbd));\n const char* ptr = // Convert from (uint8_t*).\n static_cast(static_cast(&u[0]));\n str.append(ptr, n);\n if (token.continued()) {\n continue;\n }\n goto fail;\n }\n\n case WUFFS_BASE__TOKEN__VBC__LITERAL: {\n ret_error_message =\n (vbd & WUFFS_BASE__TOKEN__VBD__LITERAL__NULL)\n " + - "? callbacks.AppendNull()\n : callbacks.AppendBool(vbd &\n WUFFS_BASE__TOKEN__VBD__LITERAL__TRUE);\n goto parsed_a_value;\n }\n\n case WUFFS_BASE__TOKEN__VBC__NUMBER: {\n if (vbd & WUFFS_BASE__TOKEN__VBD__NUMBER__FORMAT_TEXT) {\n if (vbd & WUFFS_BASE__TOKEN__VBD__NUMBER__CONTENT_INTEGER_SIGNED) {\n wuffs_base__result_i64 r = wuffs_base__parse_number_i64(\n wuffs_base__make_slice_u8(token_ptr, token_len),\n WUFFS_BASE__PARSE_NUMBER_XXX__DEFAULT_OPTIONS);\n if (r.status.is_ok()) {\n ret_error_message = callbacks.AppendI64(r.value);\n goto parsed_a_value;\n }\n }\n if (vbd & WUFFS_BASE__TOKEN__VBD__NUMBER__CONTENT_FLOATING_POINT) {\n wuffs_base__result_f64 r = wuffs_base__parse_number_f64(\n wuffs_base__make_slice_u8(token_ptr, token_len),\n WUFFS_BASE__PARSE_NUMBER" + - "_XXX__DEFAULT_OPTIONS);\n if (r.status.is_ok()) {\n ret_error_message = callbacks.AppendF64(r.value);\n goto parsed_a_value;\n }\n }\n } else if (vbd & WUFFS_BASE__TOKEN__VBD__NUMBER__CONTENT_NEG_INF) {\n ret_error_message = callbacks.AppendF64(\n wuffs_base__ieee_754_bit_representation__from_u64_to_f64(\n 0xFFF0000000000000ul));\n goto parsed_a_value;\n } else if (vbd & WUFFS_BASE__TOKEN__VBD__NUMBER__CONTENT_POS_INF) {\n ret_error_message = callbacks.AppendF64(\n wuffs_base__ieee_754_bit_representation__from_u64_to_f64(\n 0x7FF0000000000000ul));\n goto parsed_a_value;\n } else if (vbd & WUFFS_BASE__TOKEN__VBD__NUMBER__CONTENT_NEG_NAN) {\n ret_error_message = callbacks.AppendF64(\n wuffs_base__ieee_754_bit_representation__from_u64_to_f64(\n 0xFFFFFFFFFFFFFFFFul));\n goto" + - " parsed_a_value;\n } else if (vbd & WUFFS_BASE__TOKEN__VBD__NUMBER__CONTENT_POS_NAN) {\n ret_error_message = callbacks.AppendF64(\n wuffs_base__ieee_754_bit_representation__from_u64_to_f64(\n 0x7FFFFFFFFFFFFFFFul));\n goto parsed_a_value;\n }\n goto fail;\n }\n }\n\n fail:\n ret_error_message =\n \"wuffs_aux::DecodeJson: internal error: unexpected token\";\n goto done;\n\n parsed_a_value:\n if (!ret_error_message.empty() || (depth == 0)) {\n goto done;\n }\n }\n } while (false);\n\ndone:\n DecodeJsonResult result(\n std::move(ret_error_message),\n wuffs_base__u64__sat_add(io_buf->meta.pos, cursor_index));\n callbacks.Done(result, input, *io_buf);\n return result;\n}\n\n#undef WUFFS_AUX__DECODE_JSON__GET_THE_NEXT_TOKEN\n\n} // namespace wuffs_aux\n\n#endif // !defined(WUFFS_CONFIG__MODULES) ||\n // defined(WUFFS_CONFIG__MODULE__AUX__JSON)\n" + + "ontinue;\n }\n ret_error_message = callbacks.Pop(static_cast(vbd));\n depth--;\n goto parsed_a_value;\n }\n\n case WUFFS_BASE__TOKEN__VBC__STRING: {\n if (vbd & WUFFS_BASE__TOKEN__VBD__STRING__CONVERT_0_DST_1_SRC_DROP) {\n // No-op.\n } else if (vbd &\n WUFFS_BASE__TOKEN__VBD__STRING__CONVERT_1_DST_1_SRC_COPY) {\n const char* ptr = // Convert from (uint8_t*).\n static_cast(static_cast(token_ptr));\n str.append(ptr, token_len);\n } else {\n goto fail;\n }\n if (token.continued()) {\n continue;\n }\n ret_error_message = callbacks.AppendTextString(std::move(str));\n str.clear();\n goto parsed_a_value;\n }\n\n case WUFFS_BASE__TOKEN__VBC__UNICODE_CODE_POINT: {\n uint8_t u[WUFFS_BASE__UTF_8__BYTE_LENGTH__MAX_INCL];\n size_t n = wuffs_base__utf_8__encode(\n " + + " wuffs_base__make_slice_u8(\n &u[0], WUFFS_BASE__UTF_8__BYTE_LENGTH__MAX_INCL),\n static_cast(vbd));\n const char* ptr = // Convert from (uint8_t*).\n static_cast(static_cast(&u[0]));\n str.append(ptr, n);\n if (token.continued()) {\n continue;\n }\n goto fail;\n }\n\n case WUFFS_BASE__TOKEN__VBC__LITERAL: {\n ret_error_message =\n (vbd & WUFFS_BASE__TOKEN__VBD__LITERAL__NULL)\n ? callbacks.AppendNull()\n : callbacks.AppendBool(vbd &\n WUFFS_BASE__TOKEN__VBD__LITERAL__TRUE);\n goto parsed_a_value;\n }\n\n case WUFFS_BASE__TOKEN__VBC__NUMBER: {\n if (vbd & WUFFS_BASE__TOKEN__VBD__NUMBER__FORMAT_TEXT) {\n if (vbd & WUFFS_BASE__TOKEN__VBD__NUMBER__CONTENT_INTEGER_SIGNED) {\n wuffs_base__result_i64 r = wuffs_base__parse_number_i64(\n " + + " wuffs_base__make_slice_u8(token_ptr, token_len),\n WUFFS_BASE__PARSE_NUMBER_XXX__DEFAULT_OPTIONS);\n if (r.status.is_ok()) {\n ret_error_message = callbacks.AppendI64(r.value);\n goto parsed_a_value;\n }\n }\n if (vbd & WUFFS_BASE__TOKEN__VBD__NUMBER__CONTENT_FLOATING_POINT) {\n wuffs_base__result_f64 r = wuffs_base__parse_number_f64(\n wuffs_base__make_slice_u8(token_ptr, token_len),\n WUFFS_BASE__PARSE_NUMBER_XXX__DEFAULT_OPTIONS);\n if (r.status.is_ok()) {\n ret_error_message = callbacks.AppendF64(r.value);\n goto parsed_a_value;\n }\n }\n } else if (vbd & WUFFS_BASE__TOKEN__VBD__NUMBER__CONTENT_NEG_INF) {\n ret_error_message = callbacks.AppendF64(\n wuffs_base__ieee_754_bit_representation__from_u64_to_f64(\n 0xFFF0000000000000ul));\n goto parsed_a" + + "_value;\n } else if (vbd & WUFFS_BASE__TOKEN__VBD__NUMBER__CONTENT_POS_INF) {\n ret_error_message = callbacks.AppendF64(\n wuffs_base__ieee_754_bit_representation__from_u64_to_f64(\n 0x7FF0000000000000ul));\n goto parsed_a_value;\n } else if (vbd & WUFFS_BASE__TOKEN__VBD__NUMBER__CONTENT_NEG_NAN) {\n ret_error_message = callbacks.AppendF64(\n wuffs_base__ieee_754_bit_representation__from_u64_to_f64(\n 0xFFFFFFFFFFFFFFFFul));\n goto parsed_a_value;\n } else if (vbd & WUFFS_BASE__TOKEN__VBD__NUMBER__CONTENT_POS_NAN) {\n ret_error_message = callbacks.AppendF64(\n wuffs_base__ieee_754_bit_representation__from_u64_to_f64(\n 0x7FFFFFFFFFFFFFFFul));\n goto parsed_a_value;\n }\n goto fail;\n }\n }\n\n fail:\n ret_error_message =\n \"wuffs_aux::DecodeJson: internal error: unexpected token\";\n goto do" + + "ne;\n\n parsed_a_value:\n if (!ret_error_message.empty() || (depth == 0)) {\n goto done;\n }\n }\n } while (false);\n\ndone:\n DecodeJsonResult result(\n std::move(ret_error_message),\n wuffs_base__u64__sat_add(io_buf->meta.pos, cursor_index));\n callbacks.Done(result, input, *io_buf);\n return result;\n}\n\n#undef WUFFS_AUX__DECODE_JSON__GET_THE_NEXT_TOKEN\n\n} // namespace wuffs_aux\n\n#endif // !defined(WUFFS_CONFIG__MODULES) ||\n // defined(WUFFS_CONFIG__MODULE__AUX__JSON)\n" + "" const AuxJsonHh = "" + - "// ---------------- Auxiliary - JSON\n\nnamespace wuffs_aux {\n\nstruct DecodeJsonResult {\n DecodeJsonResult(std::string&& error_message0, uint64_t cursor_position0);\n\n std::string error_message;\n uint64_t cursor_position;\n};\n\nclass DecodeJsonCallbacks {\n public:\n // AppendXxx are called for leaf nodes: literals, numbers and strings. For\n // strings, the Callbacks implementation is responsible for tracking map keys\n // versus other values.\n\n // The JSON file format as specified deals only with (UTF-8) text strings,\n // but an unofficial extension allows \"ijk\\x89m\" escapes within those\n // strings. DecodeJsonCallbacks' AppendByteString will not be called unless\n // WUFFS_JSON__QUIRK_ALLOW_BACKSLASH_X_AS_BYTES is passed to DecodeJson. If\n // it is passed, AppendTextString will not be called and all byte strings are\n // potentially invalid UTF-8. It is up to the AppendByteString implementation\n // whether to test the std::string for UTF-8 validity.\n //\n // The default AppendByteString implementation r" + - "eturns an error message.\n\n virtual std::string AppendNull() = 0;\n virtual std::string AppendBool(bool val) = 0;\n virtual std::string AppendF64(double val) = 0;\n virtual std::string AppendI64(int64_t val) = 0;\n virtual std::string AppendByteString(std::string&& val);\n virtual std::string AppendTextString(std::string&& val) = 0;\n\n // Push and Pop are called for container nodes: JSON arrays (lists) and JSON\n // objects (dictionaries).\n //\n // The flags bits combine exactly one of:\n // - WUFFS_BASE__TOKEN__VBD__STRUCTURE__FROM_NONE\n // - WUFFS_BASE__TOKEN__VBD__STRUCTURE__FROM_LIST\n // - WUFFS_BASE__TOKEN__VBD__STRUCTURE__FROM_DICT\n // and exactly one of:\n // - WUFFS_BASE__TOKEN__VBD__STRUCTURE__TO_NONE\n // - WUFFS_BASE__TOKEN__VBD__STRUCTURE__TO_LIST\n // - WUFFS_BASE__TOKEN__VBD__STRUCTURE__TO_DICT\n\n virtual std::string Push(uint32_t flags) = 0;\n virtual std::string Pop(uint32_t flags) = 0;\n\n // Done is always the last Callback method called by DecodeJson, whether or\n // not parsing th" + - "e input as JSON encountered an error. Even when successful,\n // trailing data may remain in input and buffer. See \"Unintuitive JSON\n // Parsing\" (https://nullprogram.com/blog/2019/12/28/) which discusses JSON\n // parsing and when it stops.\n //\n // Do not keep a reference to buffer or buffer.data.ptr after Done returns,\n // as DecodeJson may then de-allocate the backing array.\n //\n // The default Done implementation is a no-op.\n virtual void Done(DecodeJsonResult& result,\n sync_io::Input& input,\n IOBuffer& buffer);\n};\n\nextern const char DecodeJson_BadJsonPointer[];\nextern const char DecodeJson_NoMatch[];\n\n// DecodeJson calls callbacks based on the JSON-formatted data in input.\n//\n// On success, the returned error_message is empty and cursor_position counts\n// the number of bytes consumed. On failure, error_message is non-empty and\n// cursor_position is the location of the error. That error may be a content\n// error (invalid JSON) or an input error (e.g. network fa" + - "ilure).\n//\n// json_pointer is a query in the JSON Pointer (RFC 6901) syntax. The callbacks\n// run for the input's sub-node that matches the query. DecodeJson_NoMatch is\n// returned if no matching sub-node was found. The empty query matches the\n// input's root node, consistent with JSON Pointer semantics.\n//\n// The JSON Pointer implementation is greedy: duplicate keys are not rejected\n// but only the first match for each '/'-separated fragment is followed.\nDecodeJsonResult DecodeJson(\n DecodeJsonCallbacks& callbacks,\n sync_io::Input& input,\n wuffs_base__slice_u32 quirks = wuffs_base__empty_slice_u32(),\n std::string json_pointer = std::string());\n\n} // namespace wuffs_aux\n" + + "// ---------------- Auxiliary - JSON\n\nnamespace wuffs_aux {\n\nstruct DecodeJsonResult {\n DecodeJsonResult(std::string&& error_message0, uint64_t cursor_position0);\n\n std::string error_message;\n uint64_t cursor_position;\n};\n\nclass DecodeJsonCallbacks {\n public:\n // AppendXxx are called for leaf nodes: literals, numbers and strings. For\n // strings, the Callbacks implementation is responsible for tracking map keys\n // versus other values.\n\n virtual std::string AppendNull() = 0;\n virtual std::string AppendBool(bool val) = 0;\n virtual std::string AppendF64(double val) = 0;\n virtual std::string AppendI64(int64_t val) = 0;\n virtual std::string AppendTextString(std::string&& val) = 0;\n\n // Push and Pop are called for container nodes: JSON arrays (lists) and JSON\n // objects (dictionaries).\n //\n // The flags bits combine exactly one of:\n // - WUFFS_BASE__TOKEN__VBD__STRUCTURE__FROM_NONE\n // - WUFFS_BASE__TOKEN__VBD__STRUCTURE__FROM_LIST\n // - WUFFS_BASE__TOKEN__VBD__STRUCTURE__FROM_DICT\n // and e" + + "xactly one of:\n // - WUFFS_BASE__TOKEN__VBD__STRUCTURE__TO_NONE\n // - WUFFS_BASE__TOKEN__VBD__STRUCTURE__TO_LIST\n // - WUFFS_BASE__TOKEN__VBD__STRUCTURE__TO_DICT\n\n virtual std::string Push(uint32_t flags) = 0;\n virtual std::string Pop(uint32_t flags) = 0;\n\n // Done is always the last Callback method called by DecodeJson, whether or\n // not parsing the input as JSON encountered an error. Even when successful,\n // trailing data may remain in input and buffer. See \"Unintuitive JSON\n // Parsing\" (https://nullprogram.com/blog/2019/12/28/) which discusses JSON\n // parsing and when it stops.\n //\n // Do not keep a reference to buffer or buffer.data.ptr after Done returns,\n // as DecodeJson may then de-allocate the backing array.\n //\n // The default Done implementation is a no-op.\n virtual void Done(DecodeJsonResult& result,\n sync_io::Input& input,\n IOBuffer& buffer);\n};\n\nextern const char DecodeJson_BadJsonPointer[];\nextern const char DecodeJson_NoMatch[];\n\n// " + + "DecodeJson calls callbacks based on the JSON-formatted data in input.\n//\n// On success, the returned error_message is empty and cursor_position counts\n// the number of bytes consumed. On failure, error_message is non-empty and\n// cursor_position is the location of the error. That error may be a content\n// error (invalid JSON) or an input error (e.g. network failure).\n//\n// json_pointer is a query in the JSON Pointer (RFC 6901) syntax. The callbacks\n// run for the input's sub-node that matches the query. DecodeJson_NoMatch is\n// returned if no matching sub-node was found. The empty query matches the\n// input's root node, consistent with JSON Pointer semantics.\n//\n// The JSON Pointer implementation is greedy: duplicate keys are not rejected\n// but only the first match for each '/'-separated fragment is followed.\nDecodeJsonResult DecodeJson(\n DecodeJsonCallbacks& callbacks,\n sync_io::Input& input,\n wuffs_base__slice_u32 quirks = wuffs_base__empty_slice_u32(),\n std::string json_pointer = std::string()" + + ");\n\n} // namespace wuffs_aux\n" + "" var AuxNonBaseCcFiles = []string{ diff --git a/release/c/wuffs-unsupported-snapshot.c b/release/c/wuffs-unsupported-snapshot.c index 854353ff..98fdcc1e 100644 --- a/release/c/wuffs-unsupported-snapshot.c +++ b/release/c/wuffs-unsupported-snapshot.c @@ -7637,8 +7637,6 @@ extern const char wuffs_json__error__unsupported_recursion_depth[]; #define WUFFS_JSON__QUIRK_ALLOW_BACKSLASH_V 1225364487 -#define WUFFS_JSON__QUIRK_ALLOW_BACKSLASH_X_AS_BYTES 1225364488 - #define WUFFS_JSON__QUIRK_ALLOW_BACKSLASH_X_AS_CODE_POINTS 1225364489 #define WUFFS_JSON__QUIRK_ALLOW_BACKSLASH_ZERO 1225364490 @@ -7753,7 +7751,6 @@ struct wuffs_json__decoder__struct { bool f_allow_leading_ars; bool f_allow_leading_ubom; bool f_end_of_data; - uint32_t f_string_value_minor; uint32_t p_decode_tokens[1]; uint32_t p_decode_leading[1]; @@ -8592,21 +8589,10 @@ class DecodeJsonCallbacks { // strings, the Callbacks implementation is responsible for tracking map keys // versus other values. - // The JSON file format as specified deals only with (UTF-8) text strings, - // but an unofficial extension allows "ijk\x89m" escapes within those - // strings. DecodeJsonCallbacks' AppendByteString will not be called unless - // WUFFS_JSON__QUIRK_ALLOW_BACKSLASH_X_AS_BYTES is passed to DecodeJson. If - // it is passed, AppendTextString will not be called and all byte strings are - // potentially invalid UTF-8. It is up to the AppendByteString implementation - // whether to test the std::string for UTF-8 validity. - // - // The default AppendByteString implementation returns an error message. - virtual std::string AppendNull() = 0; virtual std::string AppendBool(bool val) = 0; virtual std::string AppendF64(double val) = 0; virtual std::string AppendI64(int64_t val) = 0; - virtual std::string AppendByteString(std::string&& val); virtual std::string AppendTextString(std::string&& val) = 0; // Push and Pop are called for container nodes: JSON arrays (lists) and JSON @@ -25967,7 +25953,6 @@ wuffs_json__decoder__decode_tokens( uint8_t v_char = 0; uint8_t v_class = 0; uint32_t v_multi_byte_utf8 = 0; - uint32_t v_backslash_x_length = 0; uint8_t v_backslash_x_ok = 0; uint8_t v_backslash_x_value = 0; uint32_t v_backslash_x_string = 0; @@ -26037,15 +26022,6 @@ wuffs_json__decoder__decode_tokens( goto suspend; } } - if (self->private_impl.f_quirks[8]) { - if (self->private_impl.f_quirks[9]) { - status = wuffs_base__make_status(wuffs_json__error__bad_quirk_combination); - goto exit; - } - self->private_impl.f_string_value_minor = 4194304; - } else { - self->private_impl.f_string_value_minor = 4194306; - } v_expect = 7858; label__outer__continue:; while (true) { @@ -26106,10 +26082,7 @@ wuffs_json__decoder__decode_tokens( } if (v_class == 1) { *iop_a_dst++ = wuffs_base__make_token( - (((uint64_t)((self->private_impl.f_string_value_minor | - 1 | - 16 | - 256))) << WUFFS_BASE__TOKEN__VALUE_MINOR__SHIFT) | + (((uint64_t)(4194579)) << WUFFS_BASE__TOKEN__VALUE_MINOR__SHIFT) | (((uint64_t)(1)) << WUFFS_BASE__TOKEN__CONTINUED__SHIFT) | (((uint64_t)(1)) << WUFFS_BASE__TOKEN__LENGTH__SHIFT)); (iop_a_src += 1, wuffs_base__make_empty_struct()); @@ -26126,7 +26099,7 @@ wuffs_json__decoder__decode_tokens( if (((uint64_t)(io2_a_src - iop_a_src)) <= 0) { if (v_string_length > 0) { *iop_a_dst++ = wuffs_base__make_token( - (((uint64_t)((self->private_impl.f_string_value_minor | 1 | 512))) << WUFFS_BASE__TOKEN__VALUE_MINOR__SHIFT) | + (((uint64_t)(4194819)) << WUFFS_BASE__TOKEN__VALUE_MINOR__SHIFT) | (((uint64_t)(1)) << WUFFS_BASE__TOKEN__CONTINUED__SHIFT) | (((uint64_t)(v_string_length)) << WUFFS_BASE__TOKEN__LENGTH__SHIFT)); v_string_length = 0; @@ -26151,7 +26124,7 @@ wuffs_json__decoder__decode_tokens( (iop_a_src += 4, wuffs_base__make_empty_struct()); if (v_string_length > 65527) { *iop_a_dst++ = wuffs_base__make_token( - (((uint64_t)((self->private_impl.f_string_value_minor | 1 | 512))) << WUFFS_BASE__TOKEN__VALUE_MINOR__SHIFT) | + (((uint64_t)(4194819)) << WUFFS_BASE__TOKEN__VALUE_MINOR__SHIFT) | (((uint64_t)(1)) << WUFFS_BASE__TOKEN__CONTINUED__SHIFT) | (((uint64_t)((v_string_length + 4))) << WUFFS_BASE__TOKEN__LENGTH__SHIFT)); v_string_length = 0; @@ -26166,7 +26139,7 @@ wuffs_json__decoder__decode_tokens( (iop_a_src += 1, wuffs_base__make_empty_struct()); if (v_string_length >= 65531) { *iop_a_dst++ = wuffs_base__make_token( - (((uint64_t)((self->private_impl.f_string_value_minor | 1 | 512))) << WUFFS_BASE__TOKEN__VALUE_MINOR__SHIFT) | + (((uint64_t)(4194819)) << WUFFS_BASE__TOKEN__VALUE_MINOR__SHIFT) | (((uint64_t)(1)) << WUFFS_BASE__TOKEN__CONTINUED__SHIFT) | (((uint64_t)(65532)) << WUFFS_BASE__TOKEN__LENGTH__SHIFT)); v_string_length = 0; @@ -26177,7 +26150,7 @@ wuffs_json__decoder__decode_tokens( } else if (v_char == 1) { if (v_string_length != 0) { *iop_a_dst++ = wuffs_base__make_token( - (((uint64_t)((self->private_impl.f_string_value_minor | 1 | 512))) << WUFFS_BASE__TOKEN__VALUE_MINOR__SHIFT) | + (((uint64_t)(4194819)) << WUFFS_BASE__TOKEN__VALUE_MINOR__SHIFT) | (((uint64_t)(1)) << WUFFS_BASE__TOKEN__CONTINUED__SHIFT) | (((uint64_t)(v_string_length)) << WUFFS_BASE__TOKEN__LENGTH__SHIFT)); v_string_length = 0; @@ -26186,7 +26159,7 @@ wuffs_json__decoder__decode_tokens( } else if (v_char == 2) { if (v_string_length > 0) { *iop_a_dst++ = wuffs_base__make_token( - (((uint64_t)((self->private_impl.f_string_value_minor | 1 | 512))) << WUFFS_BASE__TOKEN__VALUE_MINOR__SHIFT) | + (((uint64_t)(4194819)) << WUFFS_BASE__TOKEN__VALUE_MINOR__SHIFT) | (((uint64_t)(1)) << WUFFS_BASE__TOKEN__CONTINUED__SHIFT) | (((uint64_t)(v_string_length)) << WUFFS_BASE__TOKEN__LENGTH__SHIFT)); v_string_length = 0; @@ -26380,74 +26353,36 @@ wuffs_json__decoder__decode_tokens( (((uint64_t)(10)) << WUFFS_BASE__TOKEN__LENGTH__SHIFT)); goto label__string_loop_outer__continue; } - } else if (v_c == 120) { - if (self->private_impl.f_quirks[9]) { - if (((uint64_t)(io2_a_src - iop_a_src)) < 4) { - if (a_src && a_src->meta.closed) { - status = wuffs_base__make_status(wuffs_json__error__bad_backslash_escape); - goto exit; - } - status = wuffs_base__make_status(wuffs_base__suspension__short_read); - WUFFS_BASE__COROUTINE_SUSPENSION_POINT_MAYBE_SUSPEND(10); - v_string_length = 0; - v_char = 0; - goto label__string_loop_outer__continue; - } - v_backslash_x_string = wuffs_base__load_u32le__no_bounds_check(iop_a_src); - v_backslash_x_ok = 128; - v_c = WUFFS_JSON__LUT_HEXADECIMAL_DIGITS[(255 & (v_backslash_x_string >> 16))]; - v_backslash_x_ok &= v_c; - v_backslash_x_value = ((uint8_t)(((v_c & 15) << 4))); - v_c = WUFFS_JSON__LUT_HEXADECIMAL_DIGITS[(255 & (v_backslash_x_string >> 24))]; - v_backslash_x_ok &= v_c; - v_backslash_x_value = ((uint8_t)((v_backslash_x_value | (v_c & 15)))); - if ((v_backslash_x_ok == 0) || ((v_backslash_x_string & 65535) != 30812)) { + } else if ((v_c == 120) && self->private_impl.f_quirks[9]) { + if (((uint64_t)(io2_a_src - iop_a_src)) < 4) { + if (a_src && a_src->meta.closed) { status = wuffs_base__make_status(wuffs_json__error__bad_backslash_escape); goto exit; } - (iop_a_src += 4, wuffs_base__make_empty_struct()); - *iop_a_dst++ = wuffs_base__make_token( - (((uint64_t)((6291456 | ((uint32_t)(v_backslash_x_value))))) << WUFFS_BASE__TOKEN__VALUE_MINOR__SHIFT) | - (((uint64_t)(1)) << WUFFS_BASE__TOKEN__CONTINUED__SHIFT) | - (((uint64_t)(4)) << WUFFS_BASE__TOKEN__LENGTH__SHIFT)); - goto label__string_loop_outer__continue; - } else if (self->private_impl.f_quirks[8]) { - if (((uint64_t)(io2_a_src - iop_a_src)) < 4) { - if (a_src && a_src->meta.closed) { - status = wuffs_base__make_status(wuffs_json__error__bad_backslash_escape); - goto exit; - } - status = wuffs_base__make_status(wuffs_base__suspension__short_read); - WUFFS_BASE__COROUTINE_SUSPENSION_POINT_MAYBE_SUSPEND(11); - v_string_length = 0; - v_char = 0; - goto label__string_loop_outer__continue; - } - v_backslash_x_length = 0; - while ((v_backslash_x_length <= 65531) && (((uint64_t)(io2_a_src - iop_a_src)) >= 4)) { - v_backslash_x_string = wuffs_base__load_u32le__no_bounds_check(iop_a_src); - v_backslash_x_ok = 128; - v_c = WUFFS_JSON__LUT_HEXADECIMAL_DIGITS[(255 & (v_backslash_x_string >> 16))]; - v_backslash_x_ok &= v_c; - v_c = WUFFS_JSON__LUT_HEXADECIMAL_DIGITS[(255 & (v_backslash_x_string >> 24))]; - v_backslash_x_ok &= v_c; - if ((v_backslash_x_ok == 0) || ((v_backslash_x_string & 65535) != 30812)) { - goto label__1__break; - } - (iop_a_src += 4, wuffs_base__make_empty_struct()); - v_backslash_x_length += 4; - } - label__1__break:; - if (v_backslash_x_length == 0) { - status = wuffs_base__make_status(wuffs_json__error__bad_backslash_escape); - goto exit; - } - *iop_a_dst++ = wuffs_base__make_token( - (((uint64_t)((self->private_impl.f_string_value_minor | 1 | 2048))) << WUFFS_BASE__TOKEN__VALUE_MINOR__SHIFT) | - (((uint64_t)(1)) << WUFFS_BASE__TOKEN__CONTINUED__SHIFT) | - (((uint64_t)(v_backslash_x_length)) << WUFFS_BASE__TOKEN__LENGTH__SHIFT)); + status = wuffs_base__make_status(wuffs_base__suspension__short_read); + WUFFS_BASE__COROUTINE_SUSPENSION_POINT_MAYBE_SUSPEND(10); + v_string_length = 0; + v_char = 0; goto label__string_loop_outer__continue; } + v_backslash_x_string = wuffs_base__load_u32le__no_bounds_check(iop_a_src); + v_backslash_x_ok = 128; + v_c = WUFFS_JSON__LUT_HEXADECIMAL_DIGITS[(255 & (v_backslash_x_string >> 16))]; + v_backslash_x_ok &= v_c; + v_backslash_x_value = ((uint8_t)(((v_c & 15) << 4))); + v_c = WUFFS_JSON__LUT_HEXADECIMAL_DIGITS[(255 & (v_backslash_x_string >> 24))]; + v_backslash_x_ok &= v_c; + v_backslash_x_value = ((uint8_t)((v_backslash_x_value | (v_c & 15)))); + if ((v_backslash_x_ok == 0) || ((v_backslash_x_string & 65535) != 30812)) { + status = wuffs_base__make_status(wuffs_json__error__bad_backslash_escape); + goto exit; + } + (iop_a_src += 4, wuffs_base__make_empty_struct()); + *iop_a_dst++ = wuffs_base__make_token( + (((uint64_t)((6291456 | ((uint32_t)(v_backslash_x_value))))) << WUFFS_BASE__TOKEN__VALUE_MINOR__SHIFT) | + (((uint64_t)(1)) << WUFFS_BASE__TOKEN__CONTINUED__SHIFT) | + (((uint64_t)(4)) << WUFFS_BASE__TOKEN__LENGTH__SHIFT)); + goto label__string_loop_outer__continue; } status = wuffs_base__make_status(wuffs_json__error__bad_backslash_escape); goto exit; @@ -26455,7 +26390,52 @@ wuffs_json__decoder__decode_tokens( if (((uint64_t)(io2_a_src - iop_a_src)) < 2) { if (v_string_length > 0) { *iop_a_dst++ = wuffs_base__make_token( - (((uint64_t)((self->private_impl.f_string_value_minor | 1 | 512))) << WUFFS_BASE__TOKEN__VALUE_MINOR__SHIFT) | + (((uint64_t)(4194819)) << WUFFS_BASE__TOKEN__VALUE_MINOR__SHIFT) | + (((uint64_t)(1)) << WUFFS_BASE__TOKEN__CONTINUED__SHIFT) | + (((uint64_t)(v_string_length)) << WUFFS_BASE__TOKEN__LENGTH__SHIFT)); + v_string_length = 0; + if (((uint64_t)(io2_a_dst - iop_a_dst)) <= 0) { + goto label__string_loop_outer__continue; + } + } + if (a_src && a_src->meta.closed) { + if (self->private_impl.f_quirks[19]) { + *iop_a_dst++ = wuffs_base__make_token( + (((uint64_t)(6356989)) << WUFFS_BASE__TOKEN__VALUE_MINOR__SHIFT) | + (((uint64_t)(1)) << WUFFS_BASE__TOKEN__CONTINUED__SHIFT) | + (((uint64_t)(1)) << WUFFS_BASE__TOKEN__LENGTH__SHIFT)); + (iop_a_src += 1, wuffs_base__make_empty_struct()); + goto label__string_loop_outer__continue; + } + status = wuffs_base__make_status(wuffs_json__error__bad_utf_8); + goto exit; + } + status = wuffs_base__make_status(wuffs_base__suspension__short_read); + WUFFS_BASE__COROUTINE_SUSPENSION_POINT_MAYBE_SUSPEND(11); + v_string_length = 0; + v_char = 0; + goto label__string_loop_outer__continue; + } + v_multi_byte_utf8 = ((uint32_t)(wuffs_base__load_u16le__no_bounds_check(iop_a_src))); + if ((v_multi_byte_utf8 & 49152) == 32768) { + v_multi_byte_utf8 = ((1984 & (v_multi_byte_utf8 << 6)) | (63 & (v_multi_byte_utf8 >> 8))); + (iop_a_src += 2, wuffs_base__make_empty_struct()); + if (v_string_length >= 65528) { + *iop_a_dst++ = wuffs_base__make_token( + (((uint64_t)(4194819)) << WUFFS_BASE__TOKEN__VALUE_MINOR__SHIFT) | + (((uint64_t)(1)) << WUFFS_BASE__TOKEN__CONTINUED__SHIFT) | + (((uint64_t)((v_string_length + 2))) << WUFFS_BASE__TOKEN__LENGTH__SHIFT)); + v_string_length = 0; + goto label__string_loop_outer__continue; + } + v_string_length += 2; + goto label__string_loop_inner__continue; + } + } else if (v_char == 4) { + if (((uint64_t)(io2_a_src - iop_a_src)) < 3) { + if (v_string_length > 0) { + *iop_a_dst++ = wuffs_base__make_token( + (((uint64_t)(4194819)) << WUFFS_BASE__TOKEN__VALUE_MINOR__SHIFT) | (((uint64_t)(1)) << WUFFS_BASE__TOKEN__CONTINUED__SHIFT) | (((uint64_t)(v_string_length)) << WUFFS_BASE__TOKEN__LENGTH__SHIFT)); v_string_length = 0; @@ -26481,26 +26461,28 @@ wuffs_json__decoder__decode_tokens( v_char = 0; goto label__string_loop_outer__continue; } - v_multi_byte_utf8 = ((uint32_t)(wuffs_base__load_u16le__no_bounds_check(iop_a_src))); - if ((v_multi_byte_utf8 & 49152) == 32768) { - v_multi_byte_utf8 = ((1984 & (v_multi_byte_utf8 << 6)) | (63 & (v_multi_byte_utf8 >> 8))); - (iop_a_src += 2, wuffs_base__make_empty_struct()); - if (v_string_length >= 65528) { - *iop_a_dst++ = wuffs_base__make_token( - (((uint64_t)((self->private_impl.f_string_value_minor | 1 | 512))) << WUFFS_BASE__TOKEN__VALUE_MINOR__SHIFT) | - (((uint64_t)(1)) << WUFFS_BASE__TOKEN__CONTINUED__SHIFT) | - (((uint64_t)((v_string_length + 2))) << WUFFS_BASE__TOKEN__LENGTH__SHIFT)); - v_string_length = 0; - goto label__string_loop_outer__continue; + v_multi_byte_utf8 = ((uint32_t)(wuffs_base__load_u24le__no_bounds_check(iop_a_src))); + if ((v_multi_byte_utf8 & 12632064) == 8421376) { + v_multi_byte_utf8 = ((61440 & (v_multi_byte_utf8 << 12)) | (4032 & (v_multi_byte_utf8 >> 2)) | (63 & (v_multi_byte_utf8 >> 16))); + if ((2047 < v_multi_byte_utf8) && ((v_multi_byte_utf8 < 55296) || (57343 < v_multi_byte_utf8))) { + (iop_a_src += 3, wuffs_base__make_empty_struct()); + if (v_string_length >= 65528) { + *iop_a_dst++ = wuffs_base__make_token( + (((uint64_t)(4194819)) << WUFFS_BASE__TOKEN__VALUE_MINOR__SHIFT) | + (((uint64_t)(1)) << WUFFS_BASE__TOKEN__CONTINUED__SHIFT) | + (((uint64_t)((v_string_length + 3))) << WUFFS_BASE__TOKEN__LENGTH__SHIFT)); + v_string_length = 0; + goto label__string_loop_outer__continue; + } + v_string_length += 3; + goto label__string_loop_inner__continue; } - v_string_length += 2; - goto label__string_loop_inner__continue; } - } else if (v_char == 4) { - if (((uint64_t)(io2_a_src - iop_a_src)) < 3) { + } else if (v_char == 5) { + if (((uint64_t)(io2_a_src - iop_a_src)) < 4) { if (v_string_length > 0) { *iop_a_dst++ = wuffs_base__make_token( - (((uint64_t)((self->private_impl.f_string_value_minor | 1 | 512))) << WUFFS_BASE__TOKEN__VALUE_MINOR__SHIFT) | + (((uint64_t)(4194819)) << WUFFS_BASE__TOKEN__VALUE_MINOR__SHIFT) | (((uint64_t)(1)) << WUFFS_BASE__TOKEN__CONTINUED__SHIFT) | (((uint64_t)(v_string_length)) << WUFFS_BASE__TOKEN__LENGTH__SHIFT)); v_string_length = 0; @@ -26526,53 +26508,6 @@ wuffs_json__decoder__decode_tokens( v_char = 0; goto label__string_loop_outer__continue; } - v_multi_byte_utf8 = ((uint32_t)(wuffs_base__load_u24le__no_bounds_check(iop_a_src))); - if ((v_multi_byte_utf8 & 12632064) == 8421376) { - v_multi_byte_utf8 = ((61440 & (v_multi_byte_utf8 << 12)) | (4032 & (v_multi_byte_utf8 >> 2)) | (63 & (v_multi_byte_utf8 >> 16))); - if ((2047 < v_multi_byte_utf8) && ((v_multi_byte_utf8 < 55296) || (57343 < v_multi_byte_utf8))) { - (iop_a_src += 3, wuffs_base__make_empty_struct()); - if (v_string_length >= 65528) { - *iop_a_dst++ = wuffs_base__make_token( - (((uint64_t)((self->private_impl.f_string_value_minor | 1 | 512))) << WUFFS_BASE__TOKEN__VALUE_MINOR__SHIFT) | - (((uint64_t)(1)) << WUFFS_BASE__TOKEN__CONTINUED__SHIFT) | - (((uint64_t)((v_string_length + 3))) << WUFFS_BASE__TOKEN__LENGTH__SHIFT)); - v_string_length = 0; - goto label__string_loop_outer__continue; - } - v_string_length += 3; - goto label__string_loop_inner__continue; - } - } - } else if (v_char == 5) { - if (((uint64_t)(io2_a_src - iop_a_src)) < 4) { - if (v_string_length > 0) { - *iop_a_dst++ = wuffs_base__make_token( - (((uint64_t)((self->private_impl.f_string_value_minor | 1 | 512))) << WUFFS_BASE__TOKEN__VALUE_MINOR__SHIFT) | - (((uint64_t)(1)) << WUFFS_BASE__TOKEN__CONTINUED__SHIFT) | - (((uint64_t)(v_string_length)) << WUFFS_BASE__TOKEN__LENGTH__SHIFT)); - v_string_length = 0; - if (((uint64_t)(io2_a_dst - iop_a_dst)) <= 0) { - goto label__string_loop_outer__continue; - } - } - if (a_src && a_src->meta.closed) { - if (self->private_impl.f_quirks[19]) { - *iop_a_dst++ = wuffs_base__make_token( - (((uint64_t)(6356989)) << WUFFS_BASE__TOKEN__VALUE_MINOR__SHIFT) | - (((uint64_t)(1)) << WUFFS_BASE__TOKEN__CONTINUED__SHIFT) | - (((uint64_t)(1)) << WUFFS_BASE__TOKEN__LENGTH__SHIFT)); - (iop_a_src += 1, wuffs_base__make_empty_struct()); - goto label__string_loop_outer__continue; - } - status = wuffs_base__make_status(wuffs_json__error__bad_utf_8); - goto exit; - } - status = wuffs_base__make_status(wuffs_base__suspension__short_read); - WUFFS_BASE__COROUTINE_SUSPENSION_POINT_MAYBE_SUSPEND(14); - v_string_length = 0; - v_char = 0; - goto label__string_loop_outer__continue; - } v_multi_byte_utf8 = wuffs_base__load_u32le__no_bounds_check(iop_a_src); if ((v_multi_byte_utf8 & 3233857536) == 2155905024) { v_multi_byte_utf8 = ((1835008 & (v_multi_byte_utf8 << 18)) | @@ -26583,7 +26518,7 @@ wuffs_json__decoder__decode_tokens( (iop_a_src += 4, wuffs_base__make_empty_struct()); if (v_string_length >= 65528) { *iop_a_dst++ = wuffs_base__make_token( - (((uint64_t)((self->private_impl.f_string_value_minor | 1 | 512))) << WUFFS_BASE__TOKEN__VALUE_MINOR__SHIFT) | + (((uint64_t)(4194819)) << WUFFS_BASE__TOKEN__VALUE_MINOR__SHIFT) | (((uint64_t)(1)) << WUFFS_BASE__TOKEN__CONTINUED__SHIFT) | (((uint64_t)((v_string_length + 4))) << WUFFS_BASE__TOKEN__LENGTH__SHIFT)); v_string_length = 0; @@ -26596,7 +26531,7 @@ wuffs_json__decoder__decode_tokens( } if (v_string_length > 0) { *iop_a_dst++ = wuffs_base__make_token( - (((uint64_t)((self->private_impl.f_string_value_minor | 1 | 512))) << WUFFS_BASE__TOKEN__VALUE_MINOR__SHIFT) | + (((uint64_t)(4194819)) << WUFFS_BASE__TOKEN__VALUE_MINOR__SHIFT) | (((uint64_t)(1)) << WUFFS_BASE__TOKEN__CONTINUED__SHIFT) | (((uint64_t)(v_string_length)) << WUFFS_BASE__TOKEN__LENGTH__SHIFT)); v_string_length = 0; @@ -26633,7 +26568,7 @@ wuffs_json__decoder__decode_tokens( } } label__string_loop_outer__break:; - label__2__continue:; + label__1__continue:; while (true) { if (((uint64_t)(io2_a_src - iop_a_src)) <= 0) { if (a_src && a_src->meta.closed) { @@ -26641,24 +26576,21 @@ wuffs_json__decoder__decode_tokens( goto exit; } status = wuffs_base__make_status(wuffs_base__suspension__short_read); - WUFFS_BASE__COROUTINE_SUSPENSION_POINT_MAYBE_SUSPEND(15); - goto label__2__continue; + WUFFS_BASE__COROUTINE_SUSPENSION_POINT_MAYBE_SUSPEND(14); + goto label__1__continue; } if (((uint64_t)(io2_a_dst - iop_a_dst)) <= 0) { status = wuffs_base__make_status(wuffs_base__suspension__short_write); - WUFFS_BASE__COROUTINE_SUSPENSION_POINT_MAYBE_SUSPEND(16); - goto label__2__continue; + WUFFS_BASE__COROUTINE_SUSPENSION_POINT_MAYBE_SUSPEND(15); + goto label__1__continue; } (iop_a_src += 1, wuffs_base__make_empty_struct()); *iop_a_dst++ = wuffs_base__make_token( - (((uint64_t)((self->private_impl.f_string_value_minor | - 1 | - 16 | - 256))) << WUFFS_BASE__TOKEN__VALUE_MINOR__SHIFT) | + (((uint64_t)(4194579)) << WUFFS_BASE__TOKEN__VALUE_MINOR__SHIFT) | (((uint64_t)(1)) << WUFFS_BASE__TOKEN__LENGTH__SHIFT)); - goto label__2__break; + goto label__1__break; } - label__2__break:; + label__1__break:; if (0 == (v_expect & (((uint32_t)(1)) << 4))) { v_expect = 4104; goto label__outer__continue; @@ -26709,7 +26641,7 @@ wuffs_json__decoder__decode_tokens( *iop_a_dst++ = wuffs_base__make_token( (((uint64_t)(v_vminor)) << WUFFS_BASE__TOKEN__VALUE_MINOR__SHIFT) | (((uint64_t)(v_number_length)) << WUFFS_BASE__TOKEN__LENGTH__SHIFT)); - goto label__3__break; + goto label__2__break; } while (v_number_length > 0) { v_number_length -= 1; @@ -26728,7 +26660,7 @@ wuffs_json__decoder__decode_tokens( if (a_src) { a_src->meta.ri = ((size_t)(iop_a_src - a_src->data.ptr)); } - WUFFS_BASE__COROUTINE_SUSPENSION_POINT(17); + WUFFS_BASE__COROUTINE_SUSPENSION_POINT(16); status = wuffs_json__decoder__decode_inf_nan(self, a_dst, a_src); if (a_dst) { iop_a_dst = a_dst->data.ptr + a_dst->meta.wi; @@ -26739,7 +26671,7 @@ wuffs_json__decoder__decode_tokens( if (status.repr) { goto suspend; } - goto label__3__break; + goto label__2__break; } status = wuffs_base__make_status(wuffs_json__error__bad_input); goto exit; @@ -26748,14 +26680,14 @@ wuffs_json__decoder__decode_tokens( goto exit; } else { status = wuffs_base__make_status(wuffs_base__suspension__short_read); - WUFFS_BASE__COROUTINE_SUSPENSION_POINT_MAYBE_SUSPEND(18); + WUFFS_BASE__COROUTINE_SUSPENSION_POINT_MAYBE_SUSPEND(17); while (((uint64_t)(io2_a_dst - iop_a_dst)) <= 0) { status = wuffs_base__make_status(wuffs_base__suspension__short_write); - WUFFS_BASE__COROUTINE_SUSPENSION_POINT_MAYBE_SUSPEND(19); + WUFFS_BASE__COROUTINE_SUSPENSION_POINT_MAYBE_SUSPEND(18); } } } - label__3__break:; + label__2__break:; goto label__goto_parsed_a_leaf_value__break; } else if (v_class == 5) { v_vminor = 2113553; @@ -26867,7 +26799,7 @@ wuffs_json__decoder__decode_tokens( goto label__goto_parsed_a_leaf_value__break; } else if (v_match == 1) { status = wuffs_base__make_status(wuffs_base__suspension__short_read); - WUFFS_BASE__COROUTINE_SUSPENSION_POINT_MAYBE_SUSPEND(20); + WUFFS_BASE__COROUTINE_SUSPENSION_POINT_MAYBE_SUSPEND(19); goto label__outer__continue; } } else if (v_class == 10) { @@ -26884,7 +26816,7 @@ wuffs_json__decoder__decode_tokens( goto label__goto_parsed_a_leaf_value__break; } else if (v_match == 1) { status = wuffs_base__make_status(wuffs_base__suspension__short_read); - WUFFS_BASE__COROUTINE_SUSPENSION_POINT_MAYBE_SUSPEND(21); + WUFFS_BASE__COROUTINE_SUSPENSION_POINT_MAYBE_SUSPEND(20); goto label__outer__continue; } } else if (v_class == 11) { @@ -26901,7 +26833,7 @@ wuffs_json__decoder__decode_tokens( goto label__goto_parsed_a_leaf_value__break; } else if (v_match == 1) { status = wuffs_base__make_status(wuffs_base__suspension__short_read); - WUFFS_BASE__COROUTINE_SUSPENSION_POINT_MAYBE_SUSPEND(22); + WUFFS_BASE__COROUTINE_SUSPENSION_POINT_MAYBE_SUSPEND(21); goto label__outer__continue; } if (self->private_impl.f_quirks[14]) { @@ -26911,7 +26843,7 @@ wuffs_json__decoder__decode_tokens( if (a_src) { a_src->meta.ri = ((size_t)(iop_a_src - a_src->data.ptr)); } - WUFFS_BASE__COROUTINE_SUSPENSION_POINT(23); + WUFFS_BASE__COROUTINE_SUSPENSION_POINT(22); status = wuffs_json__decoder__decode_inf_nan(self, a_dst, a_src); if (a_dst) { iop_a_dst = a_dst->data.ptr + a_dst->meta.wi; @@ -26932,7 +26864,7 @@ wuffs_json__decoder__decode_tokens( if (a_src) { a_src->meta.ri = ((size_t)(iop_a_src - a_src->data.ptr)); } - WUFFS_BASE__COROUTINE_SUSPENSION_POINT(24); + WUFFS_BASE__COROUTINE_SUSPENSION_POINT(23); status = wuffs_json__decoder__decode_comment(self, a_dst, a_src); if (a_dst) { iop_a_dst = a_dst->data.ptr + a_dst->meta.wi; @@ -26963,7 +26895,7 @@ wuffs_json__decoder__decode_tokens( if (a_src) { a_src->meta.ri = ((size_t)(iop_a_src - a_src->data.ptr)); } - WUFFS_BASE__COROUTINE_SUSPENSION_POINT(25); + WUFFS_BASE__COROUTINE_SUSPENSION_POINT(24); status = wuffs_json__decoder__decode_trailing_new_line(self, a_dst, a_src); if (a_dst) { iop_a_dst = a_dst->data.ptr + a_dst->meta.wi; @@ -29428,11 +29360,6 @@ DecodeJsonResult::DecodeJsonResult(std::string&& error_message0, : error_message(std::move(error_message0)), cursor_position(cursor_position0) {} -std::string // -DecodeJsonCallbacks::AppendByteString(std::string&& val) { - return "wuffs_aux::DecodeJson: unexpected JSON byte string"; -} - void // DecodeJsonCallbacks::Done(DecodeJsonResult& result, sync_io::Input& input, @@ -29546,32 +29473,6 @@ DecodeJson_SplitJsonPointer(std::string& s, return std::make_pair(std::move(fragment), i); } -std::string // -DecodeJson_DecodeBackslashX(std::string& str, - uint8_t* token_ptr, - size_t token_len) { - wuffs_base__slice_u8 encoded = - wuffs_base__make_slice_u8(token_ptr, token_len); - while (encoded.len > 0) { - uint8_t decoded[64]; - constexpr bool src_closed = true; - wuffs_base__transform__output o = wuffs_base__base_16__decode4( - wuffs_base__make_slice_u8(&decoded[0], sizeof decoded), encoded, - src_closed, WUFFS_BASE__BASE_16__DEFAULT_OPTIONS); - if (o.status.is_error()) { - return o.status.message(); - } else if ((o.num_dst > (sizeof decoded)) || (o.num_src > encoded.len)) { - return "wuffs_aux::DecodeJson: internal error: inconsistent base16 " - "decoding"; - } - str.append( // Convert from (uint8_t*). - static_cast(static_cast(&decoded[0])), o.num_dst); - encoded.ptr += o.num_src; - encoded.len -= o.num_src; - } - return ""; -} - // -------- std::string // @@ -29630,14 +29531,6 @@ do_dict: const char* ptr = // Convert from (uint8_t*). static_cast(static_cast(token_ptr)); str.append(ptr, token_len); - } else if ( - vbd & - WUFFS_BASE__TOKEN__VBD__STRING__CONVERT_1_DST_4_SRC_BACKSLASH_X) { - ret_error_message = - DecodeJson_DecodeBackslashX(str, token_ptr, token_len); - if (!ret_error_message.empty()) { - goto done; - } } else { goto fail; } @@ -29866,24 +29759,13 @@ DecodeJson(DecodeJsonCallbacks& callbacks, const char* ptr = // Convert from (uint8_t*). static_cast(static_cast(token_ptr)); str.append(ptr, token_len); - } else if ( - vbd & - WUFFS_BASE__TOKEN__VBD__STRING__CONVERT_1_DST_4_SRC_BACKSLASH_X) { - ret_error_message = - DecodeJson_DecodeBackslashX(str, token_ptr, token_len); - if (!ret_error_message.empty()) { - goto done; - } } else { goto fail; } if (token.continued()) { continue; } - ret_error_message = - (vbd & WUFFS_BASE__TOKEN__VBD__STRING__CHAIN_MUST_BE_UTF_8) - ? callbacks.AppendTextString(std::move(str)) - : callbacks.AppendByteString(std::move(str)); + ret_error_message = callbacks.AppendTextString(std::move(str)); str.clear(); goto parsed_a_value; } diff --git a/std/json/decode_json.wuffs b/std/json/decode_json.wuffs index 49bfd903..761ea00d 100644 --- a/std/json/decode_json.wuffs +++ b/std/json/decode_json.wuffs @@ -20,8 +20,6 @@ pub struct decoder? implements base.token_decoder( end_of_data : base.bool, - string_value_minor : base.u32[..= 0x1FF_FFFF], - util : base.utility, )( // stack is conceptually an array of bits, implemented as an array of u32. @@ -92,7 +90,6 @@ pub func decoder.decode_tokens?(dst: base.token_writer, src: base.io_reader, wor var class : base.u8[..= 0x0F] var multi_byte_utf8 : base.u32 - var backslash_x_length : base.u32[..= 0xFFFF] var backslash_x_ok : base.u8 var backslash_x_value : base.u8 var backslash_x_string : base.u32 @@ -124,16 +121,6 @@ pub func decoder.decode_tokens?(dst: base.token_writer, src: base.io_reader, wor this.decode_leading?(dst: args.dst, src: args.src) } - if this.quirks[QUIRK_ALLOW_BACKSLASH_X_AS_BYTES - QUIRKS_BASE] { - if this.quirks[QUIRK_ALLOW_BACKSLASH_X_AS_CODE_POINTS - QUIRKS_BASE] { - return "#bad quirk combination" - } - this.string_value_minor = (base.TOKEN__VBC__STRING << 21) - } else { - this.string_value_minor = (base.TOKEN__VBC__STRING << 21) | - base.TOKEN__VBD__STRING__CHAIN_MUST_BE_UTF_8 - } - expect = EXPECT_VALUE while.outer true { @@ -217,8 +204,9 @@ pub func decoder.decode_tokens?(dst: base.token_writer, src: base.io_reader, wor // Emit the leading '"'. args.dst.write_simple_token_fast!( value_major: 0, - value_minor: this.string_value_minor | + value_minor: (base.TOKEN__VBC__STRING << 21) | base.TOKEN__VBD__STRING__DEFINITELY_UTF_8 | + base.TOKEN__VBD__STRING__CHAIN_MUST_BE_UTF_8 | base.TOKEN__VBD__STRING__DEFINITELY_ASCII | base.TOKEN__VBD__STRING__CONVERT_0_DST_1_SRC_DROP, continued: 1, @@ -239,8 +227,9 @@ pub func decoder.decode_tokens?(dst: base.token_writer, src: base.io_reader, wor if string_length > 0 { args.dst.write_simple_token_fast!( value_major: 0, - value_minor: this.string_value_minor | + value_minor: (base.TOKEN__VBC__STRING << 21) | base.TOKEN__VBD__STRING__DEFINITELY_UTF_8 | + base.TOKEN__VBD__STRING__CHAIN_MUST_BE_UTF_8 | base.TOKEN__VBD__STRING__CONVERT_1_DST_1_SRC_COPY, continued: 1, length: string_length) @@ -271,8 +260,9 @@ pub func decoder.decode_tokens?(dst: base.token_writer, src: base.io_reader, wor if string_length > (0xFFFB - 4) { args.dst.write_simple_token_fast!( value_major: 0, - value_minor: this.string_value_minor | + value_minor: (base.TOKEN__VBC__STRING << 21) | base.TOKEN__VBD__STRING__DEFINITELY_UTF_8 | + base.TOKEN__VBD__STRING__CHAIN_MUST_BE_UTF_8 | base.TOKEN__VBD__STRING__CONVERT_1_DST_1_SRC_COPY, continued: 1, length: string_length + 4) @@ -290,8 +280,9 @@ pub func decoder.decode_tokens?(dst: base.token_writer, src: base.io_reader, wor if string_length >= 0xFFFB { args.dst.write_simple_token_fast!( value_major: 0, - value_minor: this.string_value_minor | + value_minor: (base.TOKEN__VBC__STRING << 21) | base.TOKEN__VBD__STRING__DEFINITELY_UTF_8 | + base.TOKEN__VBD__STRING__CHAIN_MUST_BE_UTF_8 | base.TOKEN__VBD__STRING__CONVERT_1_DST_1_SRC_COPY, continued: 1, length: 0xFFFC) @@ -305,8 +296,9 @@ pub func decoder.decode_tokens?(dst: base.token_writer, src: base.io_reader, wor if string_length <> 0 { args.dst.write_simple_token_fast!( value_major: 0, - value_minor: this.string_value_minor | + value_minor: (base.TOKEN__VBC__STRING << 21) | base.TOKEN__VBD__STRING__DEFINITELY_UTF_8 | + base.TOKEN__VBD__STRING__CHAIN_MUST_BE_UTF_8 | base.TOKEN__VBD__STRING__CONVERT_1_DST_1_SRC_COPY, continued: 1, length: string_length) @@ -318,8 +310,9 @@ pub func decoder.decode_tokens?(dst: base.token_writer, src: base.io_reader, wor if string_length > 0 { args.dst.write_simple_token_fast!( value_major: 0, - value_minor: this.string_value_minor | + value_minor: (base.TOKEN__VBC__STRING << 21) | base.TOKEN__VBD__STRING__DEFINITELY_UTF_8 | + base.TOKEN__VBD__STRING__CHAIN_MUST_BE_UTF_8 | base.TOKEN__VBD__STRING__CONVERT_1_DST_1_SRC_COPY, continued: 1, length: string_length) @@ -566,88 +559,43 @@ pub func decoder.decode_tokens?(dst: base.token_writer, src: base.io_reader, wor } // -------- END backslash-capital-u. - } else if (c == 'x') { + } else if (c == 'x') and + this.quirks[QUIRK_ALLOW_BACKSLASH_X_AS_CODE_POINTS - QUIRKS_BASE] { // -------- BEGIN backslash-x - if this.quirks[QUIRK_ALLOW_BACKSLASH_X_AS_CODE_POINTS - QUIRKS_BASE] { - if args.src.length() < 4 { - if args.src.is_closed() { - return "#bad backslash-escape" - } - yield? base."$short read" - string_length = 0 - char = 0 - continue.string_loop_outer - } - - backslash_x_string = args.src.peek_u32le() - backslash_x_ok = 0x80 - - c = LUT_HEXADECIMAL_DIGITS[0xFF & (backslash_x_string >> 16)] - backslash_x_ok &= c - backslash_x_value = ((c & 0x0F) << 4) as base.u8 - c = LUT_HEXADECIMAL_DIGITS[0xFF & (backslash_x_string >> 24)] - backslash_x_ok &= c - backslash_x_value = (backslash_x_value | (c & 0x0F)) as base.u8 - - if (backslash_x_ok == 0) or - ((backslash_x_string & 0xFFFF) <> 0x785C) { - // It wasn't "\\x34", for some hexadecimal - // digits "34". + if args.src.length() < 4 { + if args.src.is_closed() { return "#bad backslash-escape" } - args.src.skip_u32_fast!(actual: 4, worst_case: 4) - args.dst.write_simple_token_fast!( - value_major: 0, - value_minor: (base.TOKEN__VBC__UNICODE_CODE_POINT << 21) | - (backslash_x_value as base.u32), - continued: 1, - length: 4) - continue.string_loop_outer - } else if this.quirks[QUIRK_ALLOW_BACKSLASH_X_AS_BYTES - QUIRKS_BASE] { - if args.src.length() < 4 { - if args.src.is_closed() { - return "#bad backslash-escape" - } - yield? base."$short read" - string_length = 0 - char = 0 - continue.string_loop_outer - } - - backslash_x_length = 0 - while (backslash_x_length <= 0xFFFB) and (args.src.length() >= 4), - inv args.dst.length() > 0, - { - backslash_x_string = args.src.peek_u32le() - backslash_x_ok = 0x80 - - c = LUT_HEXADECIMAL_DIGITS[0xFF & (backslash_x_string >> 16)] - backslash_x_ok &= c - c = LUT_HEXADECIMAL_DIGITS[0xFF & (backslash_x_string >> 24)] - backslash_x_ok &= c - - if (backslash_x_ok == 0) or - ((backslash_x_string & 0xFFFF) <> 0x785C) { - // It wasn't "\\x34", for some hexadecimal - // digits "34". - break - } - args.src.skip_u32_fast!(actual: 4, worst_case: 4) - backslash_x_length += 4 - } endwhile - - if backslash_x_length == 0 { - return "#bad backslash-escape" - } - args.dst.write_simple_token_fast!( - value_major: 0, - value_minor: this.string_value_minor | - base.TOKEN__VBD__STRING__DEFINITELY_UTF_8 | - base.TOKEN__VBD__STRING__CONVERT_1_DST_4_SRC_BACKSLASH_X, - continued: 1, - length: backslash_x_length) + yield? base."$short read" + string_length = 0 + char = 0 continue.string_loop_outer } + + backslash_x_string = args.src.peek_u32le() + backslash_x_ok = 0x80 + + c = LUT_HEXADECIMAL_DIGITS[0xFF & (backslash_x_string >> 16)] + backslash_x_ok &= c + backslash_x_value = ((c & 0x0F) << 4) as base.u8 + c = LUT_HEXADECIMAL_DIGITS[0xFF & (backslash_x_string >> 24)] + backslash_x_ok &= c + backslash_x_value = (backslash_x_value | (c & 0x0F)) as base.u8 + + if (backslash_x_ok == 0) or + ((backslash_x_string & 0xFFFF) <> 0x785C) { + // It wasn't "\\x34", for some hexadecimal + // digits "34". + return "#bad backslash-escape" + } + args.src.skip_u32_fast!(actual: 4, worst_case: 4) + args.dst.write_simple_token_fast!( + value_major: 0, + value_minor: (base.TOKEN__VBC__UNICODE_CODE_POINT << 21) | + (backslash_x_value as base.u32), + continued: 1, + length: 4) + continue.string_loop_outer // -------- END backslash-x } @@ -658,8 +606,9 @@ pub func decoder.decode_tokens?(dst: base.token_writer, src: base.io_reader, wor if string_length > 0 { args.dst.write_simple_token_fast!( value_major: 0, - value_minor: this.string_value_minor | + value_minor: (base.TOKEN__VBC__STRING << 21) | base.TOKEN__VBD__STRING__DEFINITELY_UTF_8 | + base.TOKEN__VBD__STRING__CHAIN_MUST_BE_UTF_8 | base.TOKEN__VBD__STRING__CONVERT_1_DST_1_SRC_COPY, continued: 1, length: string_length) @@ -694,8 +643,9 @@ pub func decoder.decode_tokens?(dst: base.token_writer, src: base.io_reader, wor if string_length >= 0xFFF8 { args.dst.write_simple_token_fast!( value_major: 0, - value_minor: this.string_value_minor | + value_minor: (base.TOKEN__VBC__STRING << 21) | base.TOKEN__VBD__STRING__DEFINITELY_UTF_8 | + base.TOKEN__VBD__STRING__CHAIN_MUST_BE_UTF_8 | base.TOKEN__VBD__STRING__CONVERT_1_DST_1_SRC_COPY, continued: 1, length: string_length + 2) @@ -711,8 +661,9 @@ pub func decoder.decode_tokens?(dst: base.token_writer, src: base.io_reader, wor if string_length > 0 { args.dst.write_simple_token_fast!( value_major: 0, - value_minor: this.string_value_minor | + value_minor: (base.TOKEN__VBC__STRING << 21) | base.TOKEN__VBD__STRING__DEFINITELY_UTF_8 | + base.TOKEN__VBD__STRING__CHAIN_MUST_BE_UTF_8 | base.TOKEN__VBD__STRING__CONVERT_1_DST_1_SRC_COPY, continued: 1, length: string_length) @@ -751,8 +702,9 @@ pub func decoder.decode_tokens?(dst: base.token_writer, src: base.io_reader, wor if string_length >= 0xFFF8 { args.dst.write_simple_token_fast!( value_major: 0, - value_minor: this.string_value_minor | + value_minor: (base.TOKEN__VBC__STRING << 21) | base.TOKEN__VBD__STRING__DEFINITELY_UTF_8 | + base.TOKEN__VBD__STRING__CHAIN_MUST_BE_UTF_8 | base.TOKEN__VBD__STRING__CONVERT_1_DST_1_SRC_COPY, continued: 1, length: string_length + 3) @@ -769,8 +721,9 @@ pub func decoder.decode_tokens?(dst: base.token_writer, src: base.io_reader, wor if string_length > 0 { args.dst.write_simple_token_fast!( value_major: 0, - value_minor: this.string_value_minor | + value_minor: (base.TOKEN__VBC__STRING << 21) | base.TOKEN__VBD__STRING__DEFINITELY_UTF_8 | + base.TOKEN__VBD__STRING__CHAIN_MUST_BE_UTF_8 | base.TOKEN__VBD__STRING__CONVERT_1_DST_1_SRC_COPY, continued: 1, length: string_length) @@ -808,8 +761,9 @@ pub func decoder.decode_tokens?(dst: base.token_writer, src: base.io_reader, wor if string_length >= 0xFFF8 { args.dst.write_simple_token_fast!( value_major: 0, - value_minor: this.string_value_minor | + value_minor: (base.TOKEN__VBC__STRING << 21) | base.TOKEN__VBD__STRING__DEFINITELY_UTF_8 | + base.TOKEN__VBD__STRING__CHAIN_MUST_BE_UTF_8 | base.TOKEN__VBD__STRING__CONVERT_1_DST_1_SRC_COPY, continued: 1, length: string_length + 4) @@ -825,8 +779,9 @@ pub func decoder.decode_tokens?(dst: base.token_writer, src: base.io_reader, wor if string_length > 0 { args.dst.write_simple_token_fast!( value_major: 0, - value_minor: this.string_value_minor | + value_minor: (base.TOKEN__VBC__STRING << 21) | base.TOKEN__VBD__STRING__DEFINITELY_UTF_8 | + base.TOKEN__VBD__STRING__CHAIN_MUST_BE_UTF_8 | base.TOKEN__VBD__STRING__CONVERT_1_DST_1_SRC_COPY, continued: 1, length: string_length) @@ -881,8 +836,9 @@ pub func decoder.decode_tokens?(dst: base.token_writer, src: base.io_reader, wor args.src.skip_u32_fast!(actual: 1, worst_case: 1) args.dst.write_simple_token_fast!( value_major: 0, - value_minor: this.string_value_minor | + value_minor: (base.TOKEN__VBC__STRING << 21) | base.TOKEN__VBD__STRING__DEFINITELY_UTF_8 | + base.TOKEN__VBD__STRING__CHAIN_MUST_BE_UTF_8 | base.TOKEN__VBD__STRING__DEFINITELY_ASCII | base.TOKEN__VBD__STRING__CONVERT_0_DST_1_SRC_DROP, continued: 0, diff --git a/std/json/decode_quirks.wuffs b/std/json/decode_quirks.wuffs index 6fbe85f7..c74c7b58 100644 --- a/std/json/decode_quirks.wuffs +++ b/std/json/decode_quirks.wuffs @@ -75,19 +75,11 @@ pub const QUIRK_ALLOW_BACKSLASH_SINGLE_QUOTE : base.u32 = 0x4909_9400 | 0x06 // character. pub const QUIRK_ALLOW_BACKSLASH_V : base.u32 = 0x4909_9400 | 0x07 -// When this quirk is enabled, e.g. "abc\xeFz" is accepted as a JSON string. It -// decodes to 5 bytes: 0x61, 0x62, 0x63, 0xEF and 0x7A. Decoded strings are -// byte strings, no longer guaranteed to be valid UTF-8 and even if the overall -// byte string is valid UTF-8, tokens are also no longer guaranteed to split on -// UTF-8 boundaries. -// -// It is up to the caller whether and how to run UTF-8 validation. -// -// There are exactly 2 encoded bytes after each "\x". "\x", "\x9", "\x9$" and -// "\X99" are all still rejected. -// -// This quirk cannot be combined with QUIRK_ALLOW_BACKSLASH_X_AS_CODE_POINTS. -pub const QUIRK_ALLOW_BACKSLASH_X_AS_BYTES : base.u32 = 0x4909_9400 | 0x08 +// (0x4909_9400 | 0x08) is reserved for QUIRK_ALLOW_BACKSLASH_X_AS_BYTES. This +// quirk used to be implemented, but it was removed due to its complexity. +// Enabling it (as a run-time option) meant that decoded JSON strings are no +// longer guaranteed to be valid UTF-8. We could re-implement it if there is +// sufficient demand. // When this quirk is enabled, e.g. "abc\xeFz" is accepted as a JSON string. It // decodes to 6 bytes: 0x61, 0x62, 0x63, 0xC3, 0xAF and 0x7A. The UTF-8 @@ -97,8 +89,6 @@ pub const QUIRK_ALLOW_BACKSLASH_X_AS_BYTES : base.u32 = 0x4909_9400 | 0x08 // // There are exactly 2 encoded bytes after each "\x". "\x", "\x9", "\x9$" and // "\X99" are all still rejected. -// -// This quirk cannot be combined with QUIRK_ALLOW_BACKSLASH_X_AS_BYTES. pub const QUIRK_ALLOW_BACKSLASH_X_AS_CODE_POINTS : base.u32 = 0x4909_9400 | 0x09 // When this quirk is enabled, e.g. "abc\0z" is accepted as a JSON string, diff --git a/test/c/std/json.c b/test/c/std/json.c index e907f724..d83c3b07 100644 --- a/test/c/std/json.c +++ b/test/c/std/json.c @@ -2856,7 +2856,6 @@ test_wuffs_json_decode_quirk_allow_backslash_x() { CHECK_FOCUS(__func__); struct { - uint64_t want_bytes; uint64_t want_code_points; const char* want_status_repr; const char* str; @@ -2864,102 +2863,74 @@ test_wuffs_json_decode_quirk_allow_backslash_x() { // U+009A in UTF-8 is C2 9A. // U+00FF in UTF-8 is C3 BF. // U+3456 in UTF-8 is E3 91 96. - {.want_bytes = 0x12E39196789A, - .want_code_points = 0x12E3919678C29A, + {.want_code_points = 0x12E3919678C29A, .want_status_repr = NULL, .str = "\"\\x12\\u3456\\x78\\x9A\""}, - {.want_bytes = 0xFF, - .want_code_points = 0xC3BF, + {.want_code_points = 0xC3BF, .want_status_repr = NULL, .str = "\"\\xFf\""}, - {.want_bytes = 0x00, - .want_code_points = 0x00, + {.want_code_points = 0x00, .want_status_repr = wuffs_json__error__bad_backslash_escape, .str = "\"a\\X6A\""}, - {.want_bytes = 0x6A6B, - .want_code_points = 0x6A6B, + {.want_code_points = 0x6A6B, .want_status_repr = NULL, .str = "\"a\\x6A\\x6bz\""}, - {.want_bytes = 0x6A, - .want_code_points = 0x6A, + {.want_code_points = 0x6A, .want_status_repr = wuffs_json__error__bad_backslash_escape, .str = "\"a\\x6A\\x6yz\""}, - {.want_bytes = 0x00, - .want_code_points = 0x00, + {.want_code_points = 0x00, .want_status_repr = wuffs_json__error__bad_backslash_escape, .str = "\"a\\x\""}, }; int tc; for (tc = 0; tc < WUFFS_TESTLIB_ARRAY_SIZE(test_cases); tc++) { - int q; - for (q = 0; q < 2; q++) { - wuffs_json__decoder dec; - CHECK_STATUS("initialize", wuffs_json__decoder__initialize( - &dec, sizeof dec, WUFFS_VERSION, - WUFFS_INITIALIZE__DEFAULT_OPTIONS)); - wuffs_json__decoder__set_quirk_enabled( - &dec, - q ? WUFFS_JSON__QUIRK_ALLOW_BACKSLASH_X_AS_CODE_POINTS - : WUFFS_JSON__QUIRK_ALLOW_BACKSLASH_X_AS_BYTES, - true); + wuffs_json__decoder dec; + CHECK_STATUS("initialize", wuffs_json__decoder__initialize( + &dec, sizeof dec, WUFFS_VERSION, + WUFFS_INITIALIZE__DEFAULT_OPTIONS)); + wuffs_json__decoder__set_quirk_enabled( + &dec, WUFFS_JSON__QUIRK_ALLOW_BACKSLASH_X_AS_CODE_POINTS, true); - wuffs_base__token_buffer tok = - wuffs_base__slice_token__writer(g_have_slice_token); - wuffs_base__slice_u8 src_slice = wuffs_base__make_slice_u8( - (void*)(test_cases[tc].str), strlen(test_cases[tc].str)); - wuffs_base__io_buffer src = wuffs_base__slice_u8__reader(src_slice, true); - const char* have_status_repr = - wuffs_json__decoder__decode_tokens(&dec, &tok, &src, g_work_slice_u8) - .repr; - if (have_status_repr != test_cases[tc].want_status_repr) { - RETURN_FAIL("tc=%d, q=%d: decode_tokens: have \"%s\", want \"%s\"", tc, - q, have_status_repr, test_cases[tc].want_status_repr); - } + wuffs_base__token_buffer tok = + wuffs_base__slice_token__writer(g_have_slice_token); + wuffs_base__slice_u8 src_slice = wuffs_base__make_slice_u8( + (void*)(test_cases[tc].str), strlen(test_cases[tc].str)); + wuffs_base__io_buffer src = wuffs_base__slice_u8__reader(src_slice, true); + const char* have_status_repr = + wuffs_json__decoder__decode_tokens(&dec, &tok, &src, g_work_slice_u8) + .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); + } - uint64_t src_index = 0; - uint64_t have = 0; - while (tok.meta.ri < tok.meta.wi) { - wuffs_base__token* t = &tok.data.ptr[tok.meta.ri++]; - int64_t vbc = wuffs_base__token__value_base_category(t); - uint64_t vbd = wuffs_base__token__value_base_detail(t); - uint64_t token_length = wuffs_base__token__length(t); - if ((vbc == WUFFS_BASE__TOKEN__VBC__STRING) && - (vbd & - WUFFS_BASE__TOKEN__VBD__STRING__CONVERT_1_DST_4_SRC_BACKSLASH_X)) { - uint8_t b[8] = {0}; - const bool src_closed = true; - wuffs_base__transform__output o = wuffs_base__base_16__decode4( - wuffs_base__make_slice_u8(&b[0], 8), - wuffs_base__make_slice_u8(src_slice.ptr + src_index, - token_length), - src_closed, 0); - size_t i = 0; - for (; i < o.num_dst; i++) { - have <<= 8; - have |= b[i]; - } - } else if (vbc == WUFFS_BASE__TOKEN__VBC__UNICODE_CODE_POINT) { - uint8_t b[WUFFS_BASE__UTF_8__BYTE_LENGTH__MAX_INCL]; - size_t n = wuffs_base__utf_8__encode( - wuffs_base__make_slice_u8( - &b[0], WUFFS_BASE__UTF_8__BYTE_LENGTH__MAX_INCL), - vbd); - size_t i = 0; - for (; i < n; i++) { - have <<= 8; - have |= b[i]; - } + uint64_t src_index = 0; + uint64_t have = 0; + while (tok.meta.ri < tok.meta.wi) { + wuffs_base__token* t = &tok.data.ptr[tok.meta.ri++]; + int64_t vbc = wuffs_base__token__value_base_category(t); + uint64_t vbd = wuffs_base__token__value_base_detail(t); + uint64_t token_length = wuffs_base__token__length(t); + if (vbc == WUFFS_BASE__TOKEN__VBC__UNICODE_CODE_POINT) { + uint8_t b[WUFFS_BASE__UTF_8__BYTE_LENGTH__MAX_INCL]; + size_t n = wuffs_base__utf_8__encode( + wuffs_base__make_slice_u8(&b[0], + WUFFS_BASE__UTF_8__BYTE_LENGTH__MAX_INCL), + vbd); + size_t i = 0; + for (; i < n; i++) { + have <<= 8; + have |= b[i]; } + } - src_index += token_length; - } - uint64_t want = - q ? test_cases[tc].want_code_points : test_cases[tc].want_bytes; - if (have != want) { - RETURN_FAIL("tc=%d, q=%d: have U+%08" PRIX64 ", want U+%08" PRIX64, tc, - q, have, want); - } + src_index += token_length; + } + uint64_t want = test_cases[tc].want_code_points; + if (have != want) { + RETURN_FAIL("tc=%d: have U+%08" PRIX64 ", want U+%08" PRIX64, tc, have, + want); } }