diff --git a/example/jsonptr/jsonptr.cc b/example/jsonptr/jsonptr.cc index 1b47bd2a..f791ba26 100644 --- a/example/jsonptr/jsonptr.cc +++ b/example/jsonptr/jsonptr.cc @@ -330,6 +330,10 @@ continue_loop: : context::in_dict_after_brace; goto continue_loop; + case 2: + TRY(write_dst(pt.data.ptr, pt.data.len)); + goto after_value; + case 3: TRY(handle_string(pt)); goto after_value; diff --git a/release/c/wuffs-unsupported-snapshot.c b/release/c/wuffs-unsupported-snapshot.c index 42a979a2..137769ba 100644 --- a/release/c/wuffs-unsupported-snapshot.c +++ b/release/c/wuffs-unsupported-snapshot.c @@ -5081,6 +5081,7 @@ extern "C" { // ---------------- Status Codes extern const char* wuffs_json__error__bad_input; +extern const char* wuffs_json__error__unsupported_number_length; extern const char* wuffs_json__error__unsupported_recursion_depth; // ---------------- Public Consts @@ -18132,8 +18133,12 @@ exit: // ---------------- Status Codes Implementations const char* wuffs_json__error__bad_input = "#json: bad input"; +const char* wuffs_json__error__unsupported_number_length = + "#json: unsupported number length"; const char* wuffs_json__error__unsupported_recursion_depth = "#json: unsupported recursion depth"; +const char* wuffs_json__error__internal_error_inconsistent_i_o = + "#json: internal error: inconsistent I/O"; // ---------------- Private Consts @@ -18141,6 +18146,10 @@ const char* wuffs_json__error__unsupported_recursion_depth = // ---------------- Private Function Prototypes +static uint32_t // +wuffs_json__decoder__decode_number(wuffs_json__decoder* self, + wuffs_base__io_buffer* a_src); + // ---------------- VTables // ---------------- Initializer Implementations @@ -18224,6 +18233,7 @@ wuffs_json__decoder__decode_tokens(wuffs_json__decoder* self, self->private_impl.active_coroutine = 0; wuffs_base__status status = wuffs_base__make_status(NULL); + uint32_t v_number_length = 0; uint32_t v_string_length = 0; uint32_t v_whitespace_length = 0; uint32_t v_depth = 0; @@ -18430,6 +18440,47 @@ wuffs_json__decoder__decode_tokens(wuffs_json__decoder* self, v_expect = 3; } goto label_0_continue; + } else if (v_c >= 48) { + while (true) { + if (a_src) { + a_src->meta.ri = ((size_t)(iop_a_src - a_src->data.ptr)); + } + v_number_length = wuffs_json__decoder__decode_number(self, a_src); + if (a_src) { + iop_a_src = a_src->data.ptr + a_src->meta.ri; + } + if (v_number_length > 1) { + v_number_length -= 1; + *iop_a_dst++ = wuffs_base__make_token( + (((uint64_t)(4194306)) << WUFFS_BASE__TOKEN__VALUE__SHIFT) | + (((uint64_t)(((uint64_t)(v_number_length)))) + << WUFFS_BASE__TOKEN__LENGTH__SHIFT)); + while (v_number_length > 0) { + v_number_length -= 1; + if (((uint64_t)(io2_a_src - iop_a_src)) > 0) { + (iop_a_src += 1, wuffs_base__make_empty_struct()); + } else { + status = wuffs_base__make_status( + wuffs_json__error__internal_error_inconsistent_i_o); + goto exit; + } + } + goto label_4_break; + } else if (v_number_length < 1) { + status = wuffs_base__make_status( + wuffs_json__error__unsupported_number_length); + goto exit; + } + status = + wuffs_base__make_status(wuffs_base__suspension__short_read); + WUFFS_BASE__COROUTINE_SUSPENSION_POINT_MAYBE_SUSPEND(6); + 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(7); + } + } + label_4_break:; } else { status = wuffs_base__make_status(wuffs_json__error__bad_input); goto exit; @@ -18592,6 +18643,50 @@ exit: return status; } +// -------- func json.decoder.decode_number + +static uint32_t // +wuffs_json__decoder__decode_number(wuffs_json__decoder* self, + wuffs_base__io_buffer* a_src) { + uint8_t v_c = 0; + uint32_t v_n = 0; + + uint8_t* iop_a_src = NULL; + uint8_t* io0_a_src WUFFS_BASE__POTENTIALLY_UNUSED = NULL; + uint8_t* io1_a_src WUFFS_BASE__POTENTIALLY_UNUSED = NULL; + uint8_t* io2_a_src WUFFS_BASE__POTENTIALLY_UNUSED = NULL; + if (a_src) { + io0_a_src = a_src->data.ptr; + io1_a_src = io0_a_src + a_src->meta.ri; + iop_a_src = io1_a_src; + io2_a_src = io0_a_src + a_src->meta.wi; + } + + v_n = 0; + while (true) { + if (((uint64_t)(io2_a_src - iop_a_src)) <= 0) { + if (a_src && a_src->meta.closed) { + return (v_n + 1); + } + goto label_0_break; + } + v_c = wuffs_base__load_u8be(iop_a_src); + if ((v_c < 48) || (57 < v_c)) { + return (v_n + 1); + } + if (v_n >= 49) { + return 0; + } + v_n += 1; + (iop_a_src += 1, wuffs_base__make_empty_struct()); + } +label_0_break:; + return 1; + if (a_src) { + a_src->meta.ri = ((size_t)(iop_a_src - a_src->data.ptr)); + } +} + #endif // !defined(WUFFS_CONFIG__MODULES) || // defined(WUFFS_CONFIG__MODULE__JSON) diff --git a/std/json/decode_json.wuffs b/std/json/decode_json.wuffs index f3aae007..3605a444 100644 --- a/std/json/decode_json.wuffs +++ b/std/json/decode_json.wuffs @@ -15,8 +15,11 @@ // TODO: "decoder implements base.token_decoder". pub status "#bad input" +pub status "#unsupported number length" pub status "#unsupported recursion depth" +pri status "#internal error: inconsistent I/O" + pub struct decoder?( )( // stack is conceptually an array of bits, implemented as an array of u32. @@ -50,6 +53,7 @@ pub struct decoder?( ) pub func decoder.decode_tokens?(dst: base.token_writer, src: base.io_reader) { + var number_length : base.u32[..= 50] var string_length : base.u32[..= 0xFFFE] var whitespace_length : base.u32[..= 0xFFFE] var depth : base.u32[..= 1024] @@ -235,8 +239,37 @@ pub func decoder.decode_tokens?(dst: base.token_writer, src: base.io_reader) { } continue.outer + } else if c >= 0x30 { // 0x30 is '0'. + // -------- BEGIN parse numbers. + while true, + pre args.dst.available() > 0, + { + number_length = this.decode_number!(src: args.src) + if number_length > 1 { + number_length -= 1 + args.dst.write_fast_token!(value: 0x40_0002, length: number_length as base.u64) + while number_length > 0 { + number_length -= 1 + if args.src.available() > 0 { + args.src.skip32_fast!(actual: 1, worst_case: 1) + } else { + return "#internal error: inconsistent I/O" + } + } + break + } else if number_length < 1 { + return "#unsupported number length" + } + yield? base."$short read" + while args.dst.available() <= 0, + post args.dst.available() > 0, + { + yield? base."$short write" + } + } + // -------- END parse numbers. + } else { - // TODO: numbers. return "#bad input" } @@ -347,3 +380,33 @@ pub func decoder.decode_tokens?(dst: base.token_writer, src: base.io_reader) { expect = expect_after_value } } + +pri func decoder.decode_number!(src: base.io_reader) base.u32[..= 50] { + var c : base.u8 + var n : base.u32[..= 49] + + // TODO: fractions, exponents, leading '-' sign, special casing when the + // first digit is '0'. + + n = 0 + while true { + if args.src.available() <= 0 { + if args.src.is_closed() { + return n + 1 + } + break + } + c = args.src.peek_u8() + if (c < 0x30) or (0x39 < c) { + return n + 1 + } + if n >= 49 { + return 0 + } + n += 1 + args.src.skip32_fast!(actual: 1, worst_case: 1) + } + + // TODO: explicitly undo arg.src reads. + return 1 +}