mirror of
https://github.com/ddidderr/wuffs.git
synced 2026-11-19 16:47:28 +01:00
260 lines
9.5 KiB
C++
260 lines
9.5 KiB
C++
// After editing this file, run "go generate" in the ../data directory.
|
|
|
|
// Copyright 2020 The Wuffs Authors.
|
|
//
|
|
// Licensed under the Apache License, Version 2.0 (the "License");
|
|
// you may not use this file except in compliance with the License.
|
|
// You may obtain a copy of the License at
|
|
//
|
|
// https://www.apache.org/licenses/LICENSE-2.0
|
|
//
|
|
// Unless required by applicable law or agreed to in writing, software
|
|
// distributed under the License is distributed on an "AS IS" BASIS,
|
|
// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
|
|
// See the License for the specific language governing permissions and
|
|
// limitations under the License.
|
|
|
|
// ---------------- Auxiliary - JSON
|
|
|
|
#if !defined(WUFFS_CONFIG__MODULES) || defined(WUFFS_CONFIG__MODULE__AUX__JSON)
|
|
|
|
#include <utility>
|
|
|
|
namespace wuffs_aux {
|
|
|
|
DecodeJsonResult::DecodeJsonResult(std::string&& error_message0,
|
|
uint64_t cursor_position0)
|
|
: error_message(std::move(error_message0)),
|
|
cursor_position(cursor_position0) {}
|
|
|
|
DecodeJsonResult //
|
|
DecodeJson(DecodeJsonCallbacks&& callbacks,
|
|
sync_io::Input&& input,
|
|
wuffs_base__slice_u32 quirks) {
|
|
// Prepare the wuffs_base__io_buffer and the resultant error_message.
|
|
wuffs_base__io_buffer* io_buf = input.BringsItsOwnIOBuffer();
|
|
wuffs_base__io_buffer fallback_io_buf = wuffs_base__empty_io_buffer();
|
|
std::unique_ptr<uint8_t[]> fallback_io_array(nullptr);
|
|
if (!io_buf) {
|
|
fallback_io_array = std::unique_ptr<uint8_t[]>(new uint8_t[4096]);
|
|
fallback_io_buf = wuffs_base__ptr_u8__writer(fallback_io_array.get(), 4096);
|
|
io_buf = &fallback_io_buf;
|
|
}
|
|
size_t cursor_index = 0;
|
|
std::string ret_error_message;
|
|
std::string io_error_message;
|
|
|
|
do {
|
|
// Prepare the low-level JSON decoder.
|
|
wuffs_json__decoder::unique_ptr dec = wuffs_json__decoder::alloc();
|
|
if (!dec) {
|
|
ret_error_message = "wuffs_aux::JsonDecoder: out of memory";
|
|
goto done;
|
|
}
|
|
for (size_t i = 0; i < quirks.len; i++) {
|
|
dec->set_quirk_enabled(quirks.ptr[i], true);
|
|
}
|
|
|
|
// Prepare the wuffs_base__tok_buffer.
|
|
wuffs_base__token tok_array[256];
|
|
wuffs_base__token_buffer tok_buf =
|
|
wuffs_base__slice_token__writer(wuffs_base__make_slice_token(
|
|
&tok_array[0], (sizeof(tok_array) / sizeof(tok_array[0]))));
|
|
wuffs_base__status tok_status = wuffs_base__make_status(nullptr);
|
|
|
|
// Prepare other state.
|
|
uint32_t depth = 0;
|
|
std::string str;
|
|
|
|
// Loop, doing these two things:
|
|
// 1. Get the next token.
|
|
// 2. Process that token.
|
|
while (true) {
|
|
// 1. Get the next token.
|
|
|
|
while (tok_buf.meta.ri >= tok_buf.meta.wi) {
|
|
if (tok_status.repr == nullptr) {
|
|
// No-op.
|
|
} else if (tok_status.repr == wuffs_base__suspension__short_write) {
|
|
tok_buf.compact();
|
|
} else if (tok_status.repr == wuffs_base__suspension__short_read) {
|
|
// Read from input to io_buf.
|
|
if (!io_error_message.empty()) {
|
|
ret_error_message = std::move(io_error_message);
|
|
goto done;
|
|
} else if (cursor_index != io_buf->meta.ri) {
|
|
ret_error_message =
|
|
"wuffs_aux::JsonDecoder: internal error: bad cursor_index";
|
|
goto done;
|
|
} else if (io_buf->meta.closed) {
|
|
ret_error_message =
|
|
"wuffs_aux::JsonDecoder: internal error: io_buf is closed";
|
|
goto done;
|
|
}
|
|
io_buf->compact();
|
|
if (io_buf->meta.wi >= io_buf->data.len) {
|
|
ret_error_message =
|
|
"wuffs_aux::JsonDecoder: internal error: io_buf is full";
|
|
goto done;
|
|
}
|
|
cursor_index = io_buf->meta.ri;
|
|
io_error_message = input.CopyIn(io_buf);
|
|
} else {
|
|
ret_error_message = tok_status.message();
|
|
goto done;
|
|
}
|
|
|
|
if (WUFFS_JSON__DECODER_WORKBUF_LEN_MAX_INCL_WORST_CASE != 0) {
|
|
ret_error_message =
|
|
"wuffs_aux::JsonDecoder: internal error: bad WORKBUF_LEN";
|
|
goto done;
|
|
}
|
|
wuffs_base__slice_u8 work_buf = wuffs_base__empty_slice_u8();
|
|
tok_status = dec->decode_tokens(&tok_buf, io_buf, work_buf);
|
|
}
|
|
|
|
wuffs_base__token token = tok_buf.data.ptr[tok_buf.meta.ri++];
|
|
uint64_t token_len = token.length();
|
|
if ((io_buf->meta.ri < cursor_index) ||
|
|
((io_buf->meta.ri - cursor_index) < token_len)) {
|
|
ret_error_message =
|
|
"wuffs_aux::JsonDecoder: internal error: bad token indexes";
|
|
goto done;
|
|
}
|
|
uint8_t* token_ptr = io_buf->data.ptr + cursor_index;
|
|
cursor_index += token_len;
|
|
|
|
// 2. Process that token.
|
|
|
|
int64_t vbc = token.value_base_category();
|
|
uint64_t vbd = token.value_base_detail();
|
|
switch (vbc) {
|
|
case WUFFS_BASE__TOKEN__VBC__FILLER:
|
|
continue;
|
|
|
|
case WUFFS_BASE__TOKEN__VBC__STRUCTURE: {
|
|
if (vbd & WUFFS_BASE__TOKEN__VBD__STRUCTURE__PUSH) {
|
|
ret_error_message = callbacks.Push(static_cast<uint32_t>(vbd));
|
|
if (!ret_error_message.empty()) {
|
|
goto done;
|
|
}
|
|
depth++;
|
|
continue;
|
|
}
|
|
ret_error_message = callbacks.Pop(static_cast<uint32_t>(vbd));
|
|
depth--;
|
|
goto parsed_a_value;
|
|
}
|
|
|
|
case WUFFS_BASE__TOKEN__VBC__STRING: {
|
|
if (vbd & WUFFS_BASE__TOKEN__VBD__STRING__CONVERT_0_DST_1_SRC_DROP) {
|
|
// No-op.
|
|
} else if (vbd &
|
|
WUFFS_BASE__TOKEN__VBD__STRING__CONVERT_1_DST_1_SRC_COPY) {
|
|
const char* ptr = // Convert from (uint8_t*).
|
|
static_cast<const char*>(static_cast<void*>(token_ptr));
|
|
str.append(ptr, token_len);
|
|
} else {
|
|
goto fail;
|
|
}
|
|
if (token.continued()) {
|
|
continue;
|
|
}
|
|
ret_error_message = callbacks.AppendString(std::move(str));
|
|
str.clear();
|
|
goto parsed_a_value;
|
|
}
|
|
|
|
case WUFFS_BASE__TOKEN__VBC__UNICODE_CODE_POINT: {
|
|
uint8_t u[WUFFS_BASE__UTF_8__BYTE_LENGTH__MAX_INCL];
|
|
size_t n = wuffs_base__utf_8__encode(
|
|
wuffs_base__make_slice_u8(
|
|
&u[0], WUFFS_BASE__UTF_8__BYTE_LENGTH__MAX_INCL),
|
|
static_cast<uint32_t>(vbd));
|
|
const char* ptr = // Convert from (uint8_t*).
|
|
static_cast<const char*>(static_cast<void*>(&u[0]));
|
|
str.append(ptr, n);
|
|
if (token.continued()) {
|
|
continue;
|
|
}
|
|
goto fail;
|
|
}
|
|
|
|
case WUFFS_BASE__TOKEN__VBC__LITERAL: {
|
|
ret_error_message =
|
|
(vbd & WUFFS_BASE__TOKEN__VBD__LITERAL__NULL)
|
|
? callbacks.AppendNull()
|
|
: callbacks.AppendBool(vbd &
|
|
WUFFS_BASE__TOKEN__VBD__LITERAL__TRUE);
|
|
goto parsed_a_value;
|
|
}
|
|
|
|
case WUFFS_BASE__TOKEN__VBC__NUMBER: {
|
|
if (vbd & WUFFS_BASE__TOKEN__VBD__NUMBER__FORMAT_TEXT) {
|
|
if (vbd & WUFFS_BASE__TOKEN__VBD__NUMBER__CONTENT_INTEGER_SIGNED) {
|
|
wuffs_base__result_i64 r = wuffs_base__parse_number_i64(
|
|
wuffs_base__make_slice_u8(token_ptr, token_len),
|
|
WUFFS_BASE__PARSE_NUMBER_XXX__DEFAULT_OPTIONS);
|
|
if (r.status.is_ok()) {
|
|
ret_error_message = callbacks.AppendI64(r.value);
|
|
goto parsed_a_value;
|
|
}
|
|
}
|
|
if (vbd & WUFFS_BASE__TOKEN__VBD__NUMBER__CONTENT_FLOATING_POINT) {
|
|
wuffs_base__result_f64 r = wuffs_base__parse_number_f64(
|
|
wuffs_base__make_slice_u8(token_ptr, token_len),
|
|
WUFFS_BASE__PARSE_NUMBER_XXX__DEFAULT_OPTIONS);
|
|
if (r.status.is_ok()) {
|
|
ret_error_message = callbacks.AppendF64(r.value);
|
|
goto parsed_a_value;
|
|
}
|
|
}
|
|
} else if (vbd & WUFFS_BASE__TOKEN__VBD__NUMBER__CONTENT_NEG_INF) {
|
|
ret_error_message = callbacks.AppendF64(
|
|
wuffs_base__ieee_754_bit_representation__from_u64_to_f64(
|
|
0xFFF0000000000000ul));
|
|
goto parsed_a_value;
|
|
} else if (vbd & WUFFS_BASE__TOKEN__VBD__NUMBER__CONTENT_POS_INF) {
|
|
ret_error_message = callbacks.AppendF64(
|
|
wuffs_base__ieee_754_bit_representation__from_u64_to_f64(
|
|
0x7FF0000000000000ul));
|
|
goto parsed_a_value;
|
|
} else if (vbd & WUFFS_BASE__TOKEN__VBD__NUMBER__CONTENT_NEG_NAN) {
|
|
ret_error_message = callbacks.AppendF64(
|
|
wuffs_base__ieee_754_bit_representation__from_u64_to_f64(
|
|
0xFFFFFFFFFFFFFFFFul));
|
|
goto parsed_a_value;
|
|
} else if (vbd & WUFFS_BASE__TOKEN__VBD__NUMBER__CONTENT_POS_NAN) {
|
|
ret_error_message = callbacks.AppendF64(
|
|
wuffs_base__ieee_754_bit_representation__from_u64_to_f64(
|
|
0x7FFFFFFFFFFFFFFFul));
|
|
goto parsed_a_value;
|
|
}
|
|
}
|
|
}
|
|
|
|
fail:
|
|
ret_error_message =
|
|
"wuffs_aux::JsonDecoder: internal error: unexpected token";
|
|
goto done;
|
|
|
|
parsed_a_value:
|
|
if (!ret_error_message.empty() || (depth == 0)) {
|
|
goto done;
|
|
}
|
|
}
|
|
} while (false);
|
|
|
|
done:
|
|
DecodeJsonResult result(
|
|
std::move(ret_error_message),
|
|
wuffs_base__u64__sat_add(io_buf->meta.pos, cursor_index));
|
|
callbacks.Done(result, input, *io_buf);
|
|
return result;
|
|
}
|
|
|
|
} // namespace wuffs_aux
|
|
|
|
#endif // !defined(WUFFS_CONFIG__MODULES) ||
|
|
// defined(WUFFS_CONFIG__MODULE__AUX__JSON)
|