From af75772cc255cf191d3180cf2630dfdab730e6d1 Mon Sep 17 00:00:00 2001 From: Nigel Tao Date: Sat, 18 Jul 2020 17:27:11 +1000 Subject: [PATCH] Have std/cbor parse byte strings --- example/jsonptr/jsonptr.cc | 27 ++- release/c/wuffs-unsupported-snapshot.c | 244 +++++++++++++++++++------ std/cbor/decode_cbor.wuffs | 193 ++++++++++++++++--- 3 files changed, 384 insertions(+), 80 deletions(-) diff --git a/example/jsonptr/jsonptr.cc b/example/jsonptr/jsonptr.cc index 60cf617f..9666ac07 100644 --- a/example/jsonptr/jsonptr.cc +++ b/example/jsonptr/jsonptr.cc @@ -651,7 +651,7 @@ parse_flags(int argc, char** argv) { wuffs_base__result_u64 u = wuffs_base__parse_number_u64( wuffs_base__make_slice_u8((uint8_t*)arg, strlen(arg)), WUFFS_BASE__PARSE_NUMBER_XXX__DEFAULT_OPTIONS); - if (wuffs_base__status__is_ok(&u.status) && (u.value <= 0xFFFFFFFF)) { + if (u.status.is_ok() && (u.value <= 0xFFFFFFFF)) { g_flags.max_output_depth = (uint32_t)(u.value); continue; } @@ -1184,9 +1184,28 @@ handle_string(uint64_t vbd, } else if (vbd & WUFFS_BASE__TOKEN__VBD__STRING__CONVERT_1_DST_1_SRC_COPY) { uint8_t* ptr = g_src.data.ptr + g_curr_token_end_src_index - len; if (g_flags.output_format == file_format::json) { - // TODO: if the input is CBOR but the output is JSON then we have to - // escape '\n', '\"', etc. - TRY(write_dst(ptr, len)); + if (g_flags.input_format == file_format::json) { + TRY(write_dst(ptr, len)); + } else if (vbd & WUFFS_BASE__TOKEN__VBD__STRING__CHAIN_MUST_BE_UTF_8) { + // TODO: escape '\n', '\"', etc. + TRY(write_dst(ptr, len)); + } else { + uint8_t as_hex[512]; + uint8_t* p = ptr; + size_t n = len; + while (n > 0) { + wuffs_base__transform__output o = wuffs_base__base_16__encode2( + wuffs_base__make_slice_u8(&as_hex[0], sizeof as_hex), + wuffs_base__make_slice_u8(p, n), true, + WUFFS_BASE__BASE_16__DEFAULT_OPTIONS); + TRY(write_dst(&as_hex[0], o.num_dst)); + p += o.num_src; + n -= o.num_src; + if (!o.status.is_ok()) { + return o.status.message(); + } + } + } } else { TRY(write_cbor_output_string(ptr, len, false)); } diff --git a/release/c/wuffs-unsupported-snapshot.c b/release/c/wuffs-unsupported-snapshot.c index d3be6331..b4353a7a 100644 --- a/release/c/wuffs-unsupported-snapshot.c +++ b/release/c/wuffs-unsupported-snapshot.c @@ -5626,7 +5626,10 @@ struct wuffs_cbor__decoder__struct { struct { struct { + uint64_t v_string_length; uint32_t v_depth; + uint32_t v_token_length; + uint8_t v_indefinite_string_major_type; } s_decode_tokens[1]; } private_data; @@ -16227,6 +16230,7 @@ wuffs_bmp__decoder__workbuf_len( const char wuffs_cbor__error__bad_input[] = "#cbor: bad input"; const char wuffs_cbor__error__internal_error_inconsistent_i_o[] = "#cbor: internal error: inconsistent I/O"; +const char wuffs_cbor__error__internal_error_inconsistent_token_length[] = "#cbor: internal error: inconsistent token length"; // ---------------- Private Consts @@ -16374,9 +16378,16 @@ wuffs_cbor__decoder__decode_tokens( self->private_impl.active_coroutine = 0; wuffs_base__status status = wuffs_base__make_status(NULL); + uint64_t v_string_length = 0; + uint64_t v_n64 = 0; uint32_t v_depth = 0; uint32_t v_token_length = 0; + uint32_t v_value_minor = 0; + uint32_t v_continued = 0; uint8_t v_c = 0; + uint8_t v_c_major = 0; + uint8_t v_c_minor = 0; + uint8_t v_indefinite_string_major_type = 0; wuffs_base__token* iop_a_dst = NULL; wuffs_base__token* io0_a_dst WUFFS_BASE__POTENTIALLY_UNUSED = NULL; @@ -16404,7 +16415,10 @@ wuffs_cbor__decoder__decode_tokens( uint32_t coro_susp_point = self->private_impl.p_decode_tokens[0]; if (coro_susp_point) { + v_string_length = self->private_data.s_decode_tokens[0].v_string_length; v_depth = self->private_data.s_decode_tokens[0].v_depth; + v_token_length = self->private_data.s_decode_tokens[0].v_token_length; + v_indefinite_string_major_type = self->private_data.s_decode_tokens[0].v_indefinite_string_major_type; } switch (coro_susp_point) { WUFFS_BASE__COROUTINE_SUSPENSION_POINT_0; @@ -16416,65 +16430,186 @@ wuffs_cbor__decoder__decode_tokens( label__outer__continue:; while (true) { while (true) { - 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(1); - goto label__outer__continue; - } - if (((uint64_t)(io2_a_src - iop_a_src)) <= 0) { - if (a_src && a_src->meta.closed) { - status = wuffs_base__make_status(wuffs_cbor__error__bad_input); - goto exit; - } - status = wuffs_base__make_status(wuffs_base__suspension__short_read); - WUFFS_BASE__COROUTINE_SUSPENSION_POINT_MAYBE_SUSPEND(2); - goto label__outer__continue; - } - v_c = wuffs_base__load_u8be__no_bounds_check(iop_a_src); - if ((24 <= (v_c & 31)) && ((v_c & 31) <= 27)) { - v_token_length = (1 + (((uint32_t)(1)) << (v_c & 3))); - if (((uint64_t)(io2_a_src - iop_a_src)) >= ((uint64_t)(v_token_length))) { - (iop_a_src += v_token_length, wuffs_base__make_empty_struct()); - } else if (a_src && a_src->meta.closed) { - status = wuffs_base__make_status(wuffs_cbor__error__bad_input); - goto exit; - } else { - status = wuffs_base__make_status(wuffs_base__suspension__short_read); - WUFFS_BASE__COROUTINE_SUSPENSION_POINT_MAYBE_SUSPEND(3); - v_c = 0; + while (true) { + 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(1); goto label__outer__continue; } - } else { + if (((uint64_t)(io2_a_src - iop_a_src)) <= 0) { + if (a_src && a_src->meta.closed) { + status = wuffs_base__make_status(wuffs_cbor__error__bad_input); + goto exit; + } + status = wuffs_base__make_status(wuffs_base__suspension__short_read); + WUFFS_BASE__COROUTINE_SUSPENSION_POINT_MAYBE_SUSPEND(2); + goto label__outer__continue; + } + v_c = wuffs_base__load_u8be__no_bounds_check(iop_a_src); + if ((v_indefinite_string_major_type != 0) && (v_indefinite_string_major_type != (v_c >> 5))) { + if (v_c != 255) { + status = wuffs_base__make_status(wuffs_cbor__error__bad_input); + goto exit; + } + v_value_minor = 4194560; + if (v_indefinite_string_major_type == 3) { + v_value_minor |= 19; + } + v_indefinite_string_major_type = 0; + (iop_a_src += 1, wuffs_base__make_empty_struct()); + *iop_a_dst++ = wuffs_base__make_token( + (((uint64_t)(v_value_minor)) << WUFFS_BASE__TOKEN__VALUE_MINOR__SHIFT) | + (((uint64_t)(1)) << WUFFS_BASE__TOKEN__LENGTH__SHIFT)); + goto label__goto_parsed_a_leaf_value__break; + } (iop_a_src += 1, wuffs_base__make_empty_struct()); - } - if (v_c < 32) { - v_c &= 31; - if (v_c < 24) { - *iop_a_dst++ = wuffs_base__make_token( - (((uint64_t)((12582912 | ((uint32_t)(v_c))))) << WUFFS_BASE__TOKEN__VALUE_MINOR__SHIFT) | - (((uint64_t)(1)) << WUFFS_BASE__TOKEN__LENGTH__SHIFT)); - goto label__goto_parsed_a_leaf_value__break; - } else if (v_c < 28) { - *iop_a_dst++ = wuffs_base__make_token( - (((uint64_t)(10490116)) << WUFFS_BASE__TOKEN__VALUE_MINOR__SHIFT) | - (((uint64_t)((1 + (((uint32_t)(1)) << (v_c - 24))))) << WUFFS_BASE__TOKEN__LENGTH__SHIFT)); - goto label__goto_parsed_a_leaf_value__break; + v_c_major = (v_c >> 5); + v_c_minor = (v_c & 31); + if (v_c_minor < 24) { + v_string_length = ((uint64_t)(v_c_minor)); + } else { + while (true) { + if (v_c_minor == 24) { + if (((uint64_t)(io2_a_src - iop_a_src)) >= 1) { + v_string_length = ((uint64_t)(wuffs_base__load_u8be__no_bounds_check(iop_a_src))); + (iop_a_src += 1, wuffs_base__make_empty_struct()); + goto label__goto_have_string_length__break; + } + } else if (v_c_minor == 25) { + if (((uint64_t)(io2_a_src - iop_a_src)) >= 2) { + v_string_length = ((uint64_t)(wuffs_base__load_u16be__no_bounds_check(iop_a_src))); + (iop_a_src += 2, wuffs_base__make_empty_struct()); + goto label__goto_have_string_length__break; + } + } else if (v_c_minor == 26) { + if (((uint64_t)(io2_a_src - iop_a_src)) >= 4) { + v_string_length = ((uint64_t)(wuffs_base__load_u32be__no_bounds_check(iop_a_src))); + (iop_a_src += 4, wuffs_base__make_empty_struct()); + goto label__goto_have_string_length__break; + } + } else if (v_c_minor == 27) { + if (((uint64_t)(io2_a_src - iop_a_src)) >= 8) { + v_string_length = wuffs_base__load_u64be__no_bounds_check(iop_a_src); + (iop_a_src += 8, wuffs_base__make_empty_struct()); + goto label__goto_have_string_length__break; + } + } else { + v_string_length = 0; + goto label__goto_have_string_length__break; + } + if (iop_a_src > io1_a_src) { + (iop_a_src--, wuffs_base__make_empty_struct()); + if (a_src && a_src->meta.closed) { + status = wuffs_base__make_status(wuffs_cbor__error__bad_input); + goto exit; + } + status = wuffs_base__make_status(wuffs_base__suspension__short_read); + WUFFS_BASE__COROUTINE_SUSPENSION_POINT_MAYBE_SUSPEND(3); + v_c_major = 0; + v_c_minor = 0; + goto label__outer__continue; + } + status = wuffs_base__make_status(wuffs_cbor__error__internal_error_inconsistent_i_o); + goto exit; + } + label__goto_have_string_length__break:; } - } else if (v_c < 64) { - v_c &= 31; - if (v_c < 24) { - *iop_a_dst++ = wuffs_base__make_token( - (((uint64_t)((12582912 | (2097151 - ((uint32_t)(v_c)))))) << WUFFS_BASE__TOKEN__VALUE_MINOR__SHIFT) | - (((uint64_t)(1)) << WUFFS_BASE__TOKEN__LENGTH__SHIFT)); - goto label__goto_parsed_a_leaf_value__break; - } else if (v_c < 28) { - *iop_a_dst++ = wuffs_base__make_token( - (((uint64_t)(787997)) << WUFFS_BASE__TOKEN__VALUE_MAJOR__SHIFT) | - (((uint64_t)(2)) << WUFFS_BASE__TOKEN__VALUE_MINOR__SHIFT) | - (((uint64_t)((1 + (((uint32_t)(1)) << (v_c - 24))))) << WUFFS_BASE__TOKEN__LENGTH__SHIFT)); - goto label__goto_parsed_a_leaf_value__break; + if (v_c_major == 0) { + if (v_c_minor < 24) { + *iop_a_dst++ = wuffs_base__make_token( + (((uint64_t)((12582912 | ((uint32_t)(v_c_minor))))) << WUFFS_BASE__TOKEN__VALUE_MINOR__SHIFT) | + (((uint64_t)(1)) << WUFFS_BASE__TOKEN__LENGTH__SHIFT)); + goto label__goto_parsed_a_leaf_value__break; + } else if (v_c_minor < 28) { + *iop_a_dst++ = wuffs_base__make_token( + (((uint64_t)(10490116)) << WUFFS_BASE__TOKEN__VALUE_MINOR__SHIFT) | + (((uint64_t)((1 + (((uint32_t)(1)) << (v_c_minor - 24))))) << WUFFS_BASE__TOKEN__LENGTH__SHIFT)); + goto label__goto_parsed_a_leaf_value__break; + } + } else if (v_c_major == 1) { + if (v_c_minor < 24) { + *iop_a_dst++ = wuffs_base__make_token( + (((uint64_t)((12582912 | (2097151 - ((uint32_t)(v_c_minor)))))) << WUFFS_BASE__TOKEN__VALUE_MINOR__SHIFT) | + (((uint64_t)(1)) << WUFFS_BASE__TOKEN__LENGTH__SHIFT)); + goto label__goto_parsed_a_leaf_value__break; + } else if (v_c_minor < 28) { + *iop_a_dst++ = wuffs_base__make_token( + (((uint64_t)(787997)) << WUFFS_BASE__TOKEN__VALUE_MAJOR__SHIFT) | + (((uint64_t)(2)) << WUFFS_BASE__TOKEN__VALUE_MINOR__SHIFT) | + (((uint64_t)((1 + (((uint32_t)(1)) << (v_c_minor - 24))))) << WUFFS_BASE__TOKEN__LENGTH__SHIFT)); + goto label__goto_parsed_a_leaf_value__break; + } + } else if (v_c_major == 2) { + if (v_c_minor == 0) { + *iop_a_dst++ = wuffs_base__make_token( + (((uint64_t)(4194560)) << WUFFS_BASE__TOKEN__VALUE_MINOR__SHIFT) | + (((uint64_t)(1)) << WUFFS_BASE__TOKEN__LENGTH__SHIFT)); + goto label__goto_parsed_a_leaf_value__break; + } else if (v_c_minor < 24) { + *iop_a_dst++ = wuffs_base__make_token( + (((uint64_t)(4194560)) << WUFFS_BASE__TOKEN__VALUE_MINOR__SHIFT) | + (((uint64_t)(1)) << WUFFS_BASE__TOKEN__CONTINUED__SHIFT) | + (((uint64_t)(1)) << WUFFS_BASE__TOKEN__LENGTH__SHIFT)); + } else if (v_c_minor < 28) { + *iop_a_dst++ = wuffs_base__make_token( + (((uint64_t)(4194560)) << WUFFS_BASE__TOKEN__VALUE_MINOR__SHIFT) | + (((uint64_t)(1)) << WUFFS_BASE__TOKEN__CONTINUED__SHIFT) | + (((uint64_t)((1 + (((uint32_t)(1)) << (v_c_minor & 3))))) << WUFFS_BASE__TOKEN__LENGTH__SHIFT)); + } else if (v_c_minor == 31) { + v_indefinite_string_major_type = 2; + *iop_a_dst++ = wuffs_base__make_token( + (((uint64_t)(4194560)) << WUFFS_BASE__TOKEN__VALUE_MINOR__SHIFT) | + (((uint64_t)(1)) << WUFFS_BASE__TOKEN__CONTINUED__SHIFT) | + (((uint64_t)(1)) << WUFFS_BASE__TOKEN__LENGTH__SHIFT)); + goto label__outer__continue; + } else { + goto label__goto_fail__break; + } + label__0__continue:; + while (true) { + 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(4); + goto label__0__continue; + } + v_n64 = wuffs_base__u64__min(v_string_length, ((uint64_t)(io2_a_src - iop_a_src))); + v_token_length = ((uint32_t)((v_n64 & 65535))); + if (v_n64 > 65535) { + v_token_length = 65535; + } else if (v_token_length <= 0) { + if (a_src && a_src->meta.closed) { + status = wuffs_base__make_status(wuffs_cbor__error__bad_input); + goto exit; + } + status = wuffs_base__make_status(wuffs_base__suspension__short_read); + WUFFS_BASE__COROUTINE_SUSPENSION_POINT_MAYBE_SUSPEND(5); + goto label__0__continue; + } + if (((uint64_t)(io2_a_src - iop_a_src)) < ((uint64_t)(v_token_length))) { + status = wuffs_base__make_status(wuffs_cbor__error__internal_error_inconsistent_token_length); + goto exit; + } + v_string_length -= ((uint64_t)(v_token_length)); + v_continued = 0; + if ((v_string_length > 0) || (v_indefinite_string_major_type > 0)) { + v_continued = 1; + } + (iop_a_src += v_token_length, wuffs_base__make_empty_struct()); + *iop_a_dst++ = wuffs_base__make_token( + (((uint64_t)(4194816)) << WUFFS_BASE__TOKEN__VALUE_MINOR__SHIFT) | + (((uint64_t)(v_continued)) << WUFFS_BASE__TOKEN__CONTINUED__SHIFT) | + (((uint64_t)(v_token_length)) << WUFFS_BASE__TOKEN__LENGTH__SHIFT)); + if (v_string_length > 0) { + goto label__0__continue; + } else if (v_indefinite_string_major_type > 0) { + goto label__outer__continue; + } + goto label__goto_parsed_a_leaf_value__break; + } } + goto label__goto_fail__break; } + label__goto_fail__break:; if (iop_a_src > io1_a_src) { (iop_a_src--, wuffs_base__make_empty_struct()); status = wuffs_base__make_status(wuffs_cbor__error__bad_input); @@ -16501,7 +16636,10 @@ wuffs_cbor__decoder__decode_tokens( suspend: self->private_impl.p_decode_tokens[0] = wuffs_base__status__is_suspension(&status) ? coro_susp_point : 0; self->private_impl.active_coroutine = wuffs_base__status__is_suspension(&status) ? 1 : 0; + self->private_data.s_decode_tokens[0].v_string_length = v_string_length; self->private_data.s_decode_tokens[0].v_depth = v_depth; + self->private_data.s_decode_tokens[0].v_token_length = v_token_length; + self->private_data.s_decode_tokens[0].v_indefinite_string_major_type = v_indefinite_string_major_type; goto exit; exit: diff --git a/std/cbor/decode_cbor.wuffs b/std/cbor/decode_cbor.wuffs index 8cd3b35c..1e1e70a7 100644 --- a/std/cbor/decode_cbor.wuffs +++ b/std/cbor/decode_cbor.wuffs @@ -15,6 +15,7 @@ pub status "#bad input" pri status "#internal error: inconsistent I/O" +pri status "#internal error: inconsistent token length" // TOKEN_VALUE_MAJOR is the base-38 encoding of "cbor". pub const TOKEN_VALUE_MAJOR : base.u32 = 0x0C_061D @@ -47,9 +48,20 @@ pub func decoder.workbuf_len() base.range_ii_u64 { } pub func decoder.decode_tokens?(dst: base.token_writer, src: base.io_reader, workbuf: slice base.u8) { + var string_length : base.u64 + + var n64 : base.u64 var depth : base.u32[..= 1024] - var token_length : base.u32[..= 9] + var token_length : base.u32[..= 0xFFFF] + var value_minor : base.u32[..= 0x1FF_FFFF] + var continued : base.u32[..= 1] var c : base.u8 + var c_major : base.u8 + var c_minor : base.u8 + + // indefinite_string_major_type is 2 or 3 when we are in an + // indefinite-length byte string or text string. It is 0 otherwise. + var indefinite_string_major_type : base.u8[..= 3] if this.end_of_data { return base."@end of data" @@ -57,6 +69,7 @@ pub func decoder.decode_tokens?(dst: base.token_writer, src: base.io_reader, wor while.outer true { while.goto_parsed_a_leaf_value true {{ + while.goto_fail true {{ if args.dst.available() <= 0 { yield? base."$short write" continue.outer @@ -69,32 +82,90 @@ pub func decoder.decode_tokens?(dst: base.token_writer, src: base.io_reader, wor continue.outer } c = args.src.peek_u8() - if (0x18 <= (c & 0x1F)) and ((c & 0x1F) <= 0x1B) { - token_length = 1 + ((1 as base.u32) << (c & 0x03)) - if args.src.available() >= (token_length as base.u64) { - args.src.skip_u32_fast!(actual: token_length, worst_case: token_length) - } else if args.src.is_closed() { + + if (indefinite_string_major_type <> 0) and (indefinite_string_major_type <> (c >> 5)) { + if c <> 0xFF { return "#bad input" - } else { - yield? base."$short read" - c = 0 - continue.outer } - } else { + value_minor = (base.TOKEN__VBC__STRING << 21) | + base.TOKEN__VBD__STRING__CONVERT_0_DST_1_SRC_DROP + if indefinite_string_major_type == 3 { + value_minor |= base.TOKEN__VBD__STRING__DEFINITELY_UTF_8 | + base.TOKEN__VBD__STRING__CHAIN_MUST_BE_UTF_8 | + base.TOKEN__VBD__STRING__DEFINITELY_ASCII + } + indefinite_string_major_type = 0 args.src.skip_u32_fast!(actual: 1, worst_case: 1) + args.dst.write_simple_token_fast!( + value_major: 0, + value_minor: value_minor, + continued: 0, + length: 1) + break.goto_parsed_a_leaf_value } - if c < 0x20 { // Major type 0: an unsigned integer. - c &= 0x1F - if c < 0x18 { + args.src.skip_u32_fast!(actual: 1, worst_case: 1) + c_major = c >> 5 + c_minor = c & 0x1F + if c_minor < 0x18 { + string_length = c_minor as base.u64 + } else { + while.goto_have_string_length true, + inv args.dst.available() > 0, + {{ + if c_minor == 0x18 { + if args.src.available() >= 1 { + string_length = args.src.peek_u8_as_u64() + args.src.skip_u32_fast!(actual: 1, worst_case: 1) + break.goto_have_string_length + } + } else if c_minor == 0x19 { + if args.src.available() >= 2 { + string_length = args.src.peek_u16be_as_u64() + args.src.skip_u32_fast!(actual: 2, worst_case: 2) + break.goto_have_string_length + } + } else if c_minor == 0x1A { + if args.src.available() >= 4 { + string_length = args.src.peek_u32be_as_u64() + args.src.skip_u32_fast!(actual: 4, worst_case: 4) + break.goto_have_string_length + } + } else if c_minor == 0x1B { + if args.src.available() >= 8 { + string_length = args.src.peek_u64be() + args.src.skip_u32_fast!(actual: 8, worst_case: 8) + break.goto_have_string_length + } + } else { + string_length = 0 + break.goto_have_string_length + } + + if args.src.can_undo_byte() { + args.src.undo_byte!() + if args.src.is_closed() { + return "#bad input" + } + yield? base."$short read" + c_major = 0 + c_minor = 0 + continue.outer + } + return "#internal error: inconsistent I/O" + }} endwhile.goto_have_string_length + } + + if c_major == 0 { // Major type 0: an unsigned integer. + if c_minor < 0x18 { args.dst.write_simple_token_fast!( value_major: 0, value_minor: (base.TOKEN__VBC__INLINE_INTEGER << 21) | - (c as base.u32), + (c_minor as base.u32), continued: 0, length: 1) break.goto_parsed_a_leaf_value - } else if c < 0x1C { + } else if c_minor < 0x1C { args.dst.write_simple_token_fast!( value_major: 0, value_minor: (base.TOKEN__VBC__NUMBER << 21) | @@ -102,29 +173,105 @@ pub func decoder.decode_tokens?(dst: base.token_writer, src: base.io_reader, wor base.TOKEN__VBD__NUMBER__FORMAT_BINARY_BIG_ENDIAN | base.TOKEN__VBD__NUMBER__FORMAT_IGNORE_FIRST_BYTE, continued: 0, - length: 1 + ((1 as base.u32) << (c - 0x18))) + length: 1 + ((1 as base.u32) << (c_minor - 0x18))) break.goto_parsed_a_leaf_value } - } else if c < 0x40 { // Major type 1: a negative integer. - c &= 0x1F - if c < 0x18 { + } else if c_major == 1 { // Major type 1: a negative integer. + if c_minor < 0x18 { args.dst.write_simple_token_fast!( value_major: 0, value_minor: (base.TOKEN__VBC__INLINE_INTEGER << 21) | - (0x1F_FFFF - (c as base.u32)), + (0x1F_FFFF - (c_minor as base.u32)), continued: 0, length: 1) break.goto_parsed_a_leaf_value - } else if c < 0x1C { + } else if c_minor < 0x1C { args.dst.write_simple_token_fast!( value_major: TOKEN_VALUE_MAJOR, value_minor: TOKEN_VALUE_MINOR__MINUS_1_MINUS_X, continued: 0, - length: 1 + ((1 as base.u32) << (c - 0x18))) + length: 1 + ((1 as base.u32) << (c_minor - 0x18))) break.goto_parsed_a_leaf_value } + + } else if c_major == 2 { // Major type 2: a byte string. + if c_minor == 0x00 { + args.dst.write_simple_token_fast!( + value_major: 0, + value_minor: (base.TOKEN__VBC__STRING << 21) | + base.TOKEN__VBD__STRING__CONVERT_0_DST_1_SRC_DROP, + continued: 0, + length: 1) + break.goto_parsed_a_leaf_value + } else if c_minor < 0x18 { + args.dst.write_simple_token_fast!( + value_major: 0, + value_minor: (base.TOKEN__VBC__STRING << 21) | + base.TOKEN__VBD__STRING__CONVERT_0_DST_1_SRC_DROP, + continued: 1, + length: 1) + } else if c_minor < 0x1C { + args.dst.write_simple_token_fast!( + value_major: 0, + value_minor: (base.TOKEN__VBC__STRING << 21) | + base.TOKEN__VBD__STRING__CONVERT_0_DST_1_SRC_DROP, + continued: 1, + length: 1 + ((1 as base.u32) << (c_minor & 3))) + } else if c_minor == 0x1F { + indefinite_string_major_type = 2 + args.dst.write_simple_token_fast!( + value_major: 0, + value_minor: (base.TOKEN__VBC__STRING << 21) | + base.TOKEN__VBD__STRING__CONVERT_0_DST_1_SRC_DROP, + continued: 1, + length: 1) + continue.outer + } else { + break.goto_fail + } + + while true { + if args.dst.available() <= 0 { + yield? base."$short write" + continue + } + n64 = string_length.min(a: args.src.available()) + token_length = (n64 & 0xFFFF) as base.u32 + if n64 > 0xFFFF { + token_length = 0xFFFF + } else if token_length <= 0 { + if args.src.is_closed() { + return "#bad input" + } + yield? base."$short read" + continue + } + if args.src.available() < (token_length as base.u64) { + return "#internal error: inconsistent token length" + } + string_length ~mod-= token_length as base.u64 + continued = 0 + if (string_length > 0) or (indefinite_string_major_type > 0) { + continued = 1 + } + args.src.skip_u32_fast!(actual: token_length, worst_case: token_length) + args.dst.write_simple_token_fast!( + value_major: 0, + value_minor: (base.TOKEN__VBC__STRING << 21) | + base.TOKEN__VBD__STRING__CONVERT_1_DST_1_SRC_COPY, + continued: continued, + length: token_length) + if string_length > 0 { + continue + } else if indefinite_string_major_type > 0 { + continue.outer + } + break.goto_parsed_a_leaf_value + } endwhile } + break.goto_fail + }} endwhile.goto_fail if args.src.can_undo_byte() { args.src.undo_byte!()