Drop WUFFS_JSON__QUIRK_ALLOW_BACKSLASH_X_AS_BYTES

We can always add it back later if there's demand for it.
This commit is contained in:
Nigel Tao committed 2020-08-30 16:15:35 +10:00
1 parent 6bc3f5716d
commit 6c13877688
9 files changed
+250 -522

No files matched your search

-5
View File
@@ -289,11 +289,6 @@ class Callbacks : public wuffs_aux::DecodeJsonCallbacks {
: Append(static_cast<uint64_t>(-(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());
+3 -7
View File
@@ -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);
}
}
+1 -51
View File
@@ -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<const char*>(static_cast<void*>(&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<const char*>(static_cast<void*>(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<const char*>(static_cast<void*>(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;
}
-11
View File
@@ -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
+15 -16
View File
@@ -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 <utility>\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 <utility>\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<std::string, size_t> //\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<const char*>(static_cast<void*>(&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<const char*>(static_cast<void*>(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<uint32_t>(vbd));\n const char* ptr = // Convert fro" +
"m (uint8_t*).\n static_cast<const char*>(static_cast<void*>(&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<uint8_t*>(static_cast<void*>(\n const_cast<char*>(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<const char*>(static_cast<void*>(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<uint32_t>(vbd));\n const char* ptr = // Convert from (uint8_t*).\n static_cast<const char*>(static_cast<void*>(&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<uint8_t*>(static_cast<void*>(\n const_cast<char*>(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<uint8_t[]> fallback_io_array(nullptr);\n if (!io_buf) {\n fallback_io_array = std::unique_ptr<uint8_t[]>(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<std::string, size_t> 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<uint32_t>(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<uint32_t>(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<const char*>(static_cast<void*>(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<uint32_t>(vbd));\n const char* ptr = // Convert from (uint8_t*).\n static_cast<const char*>(static_cast<void*>(&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<uint32_t>(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<const char*>(static_cast<void*>(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<uint32_t>(vbd));\n const char* ptr = // Convert from (uint8_t*).\n static_cast<const char*>(static_cast<void*>(&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{
+118 -236
View File
@@ -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<const char*>(static_cast<void*>(&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<const char*>(static_cast<void*>(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<const char*>(static_cast<void*>(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;
}
+60 -104
View File
@@ -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,
+5 -15
View File
@@ -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,
+48 -77
View File
@@ -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);
}
}