From 3f27badd8096390fcde0a089eca36ffe33ba83eb Mon Sep 17 00:00:00 2001 From: Zack Slayton Date: Thu, 6 Jun 2024 17:17:45 -0400 Subject: [PATCH 1/2] Shift writer opcodes between 0x50 and 0xE0 right by 16 --- .../encoder/binary/v1_1/container_writers.rs | 12 +- src/lazy/encoder/binary/v1_1/flex_sym.rs | 2 +- src/lazy/encoder/binary/v1_1/value_writer.rs | 398 +++++++++--------- 3 files changed, 206 insertions(+), 206 deletions(-) diff --git a/src/lazy/encoder/binary/v1_1/container_writers.rs b/src/lazy/encoder/binary/v1_1/container_writers.rs index cc8d82c2..178efe65 100644 --- a/src/lazy/encoder/binary/v1_1/container_writers.rs +++ b/src/lazy/encoder/binary/v1_1/container_writers.rs @@ -167,8 +167,8 @@ impl<'value, 'top> BinaryListWriter_1_1<'value, 'top> { allocator: &'top BumpAllocator, buffer: &'value mut BumpVec<'top, u8>, ) -> Self { - const LENGTH_PREFIXED_LIST_TYPE_CODE: u8 = 0xA0; - const LENGTH_PREFIXED_FLEX_LEN_LIST_TYPE_CODE: u8 = 0xFA; + const LENGTH_PREFIXED_LIST_TYPE_CODE: u8 = 0xB0; + const LENGTH_PREFIXED_FLEX_LEN_LIST_TYPE_CODE: u8 = 0xFB; let container_writer = BinaryContainerWriter_1_1::new_length_prefixed( LENGTH_PREFIXED_LIST_TYPE_CODE, LENGTH_PREFIXED_FLEX_LEN_LIST_TYPE_CODE, @@ -225,8 +225,8 @@ impl<'value, 'top> BinarySExpWriter_1_1<'value, 'top> { allocator: &'top BumpAllocator, buffer: &'value mut BumpVec<'top, u8>, ) -> Self { - const LENGTH_PREFIXED_SEXP_TYPE_CODE: u8 = 0xB0; - const LENGTH_PREFIXED_FLEX_LEN_SEXP_TYPE_CODE: u8 = 0xFB; + const LENGTH_PREFIXED_SEXP_TYPE_CODE: u8 = 0xC0; + const LENGTH_PREFIXED_FLEX_LEN_SEXP_TYPE_CODE: u8 = 0xFC; let container_writer = BinaryContainerWriter_1_1::new_length_prefixed( LENGTH_PREFIXED_SEXP_TYPE_CODE, LENGTH_PREFIXED_FLEX_LEN_SEXP_TYPE_CODE, @@ -278,8 +278,8 @@ impl<'value, 'top> BinaryStructWriter_1_1<'value, 'top> { allocator: &'top BumpAllocator, buffer: &'value mut BumpVec<'top, u8>, ) -> Self { - const LENGTH_PREFIXED_STRUCT_TYPE_CODE: u8 = 0xC0; - const LENGTH_PREFIXED_FLEX_LEN_STRUCT_TYPE_CODE: u8 = 0xFC; + const LENGTH_PREFIXED_STRUCT_TYPE_CODE: u8 = 0xD0; + const LENGTH_PREFIXED_FLEX_LEN_STRUCT_TYPE_CODE: u8 = 0xFD; let container_writer = BinaryContainerWriter_1_1::new_length_prefixed( LENGTH_PREFIXED_STRUCT_TYPE_CODE, LENGTH_PREFIXED_FLEX_LEN_STRUCT_TYPE_CODE, diff --git a/src/lazy/encoder/binary/v1_1/flex_sym.rs b/src/lazy/encoder/binary/v1_1/flex_sym.rs index cbc6f142..ef89b9fa 100644 --- a/src/lazy/encoder/binary/v1_1/flex_sym.rs +++ b/src/lazy/encoder/binary/v1_1/flex_sym.rs @@ -50,7 +50,7 @@ impl<'top> FlexSym<'top> { fn encode_special_case(output: &mut BumpVec, symbol: RawSymbolRef) { let encoding: &[u8] = match symbol { SymbolId(_) => &[FlexSym::ZERO, 0xE1, 0x00], - Text(_) => &[FlexSym::ZERO, 0x80], + Text(_) => &[FlexSym::ZERO, 0x90], }; output.extend_from_slice_copy(encoding); } diff --git a/src/lazy/encoder/binary/v1_1/value_writer.rs b/src/lazy/encoder/binary/v1_1/value_writer.rs index fe3c3a37..73deb58e 100644 --- a/src/lazy/encoder/binary/v1_1/value_writer.rs +++ b/src/lazy/encoder/binary/v1_1/value_writer.rs @@ -95,8 +95,8 @@ impl<'value, 'top> BinaryValueWriter_1_1<'value, 'top> { pub fn write_bool(mut self, value: bool) -> IonResult<()> { let encoding = match value { - true => 0x5E, - false => 0x5F, + true => 0x6E, + false => 0x6F, }; self.push_byte(encoding); Ok(()) @@ -104,7 +104,7 @@ impl<'value, 'top> BinaryValueWriter_1_1<'value, 'top> { #[inline] pub fn write_i64(mut self, value: i64) -> IonResult<()> { - let mut opcode = 0x50; + let mut opcode = 0x60; if value == 0 { self.push_byte(opcode); return Ok(()); @@ -135,7 +135,7 @@ impl<'value, 'top> BinaryValueWriter_1_1<'value, 'top> { let value: i128 = value.data; // Because we've ruled out numbers small enough to fit in an i64, its encoded length // must be greater than 8. Write the opcode for an integer with a FlexUInt length. - self.push_byte(0xF5); + self.push_byte(0xF6); let num_sign_bits = if value < 0 { value.leading_ones() } else { @@ -153,15 +153,14 @@ impl<'value, 'top> BinaryValueWriter_1_1<'value, 'top> { }} } - // TODO: write_f16(...) - pub fn write_f32(mut self, value: f32) -> IonResult<()> { match value.smallest_repr() { FloatRepr::Zero => { - self.push_byte(0x5A); + self.push_byte(0x6A); } + // TODO: FloatRepr::Half => ...0x6B... FloatRepr::Single(f) => { - self.push_byte(0x5C); + self.push_byte(0x6C); self.push_bytes(&f.to_le_bytes()); } FloatRepr::Double(_) => unreachable!("smallest repr for f32 cannot be f64"), @@ -172,14 +171,15 @@ impl<'value, 'top> BinaryValueWriter_1_1<'value, 'top> { pub fn write_f64(mut self, value: f64) -> IonResult<()> { match value.smallest_repr() { FloatRepr::Zero => { - self.push_byte(0x5A); + self.push_byte(0x6A); } + // TODO: FloatRepr::Half => ...0x6B... FloatRepr::Single(f) => { - self.push_byte(0x5C); + self.push_byte(0x6C); self.push_bytes(&f.to_le_bytes()); } FloatRepr::Double(f) => { - self.push_byte(0x5D); + self.push_byte(0x6D); self.push_bytes(&f.to_le_bytes()); } } @@ -191,7 +191,7 @@ impl<'value, 'top> BinaryValueWriter_1_1<'value, 'top> { // Insert a placeholder opcode; we'll overwrite the length nibble with the appropriate value when the encoding // is complete. let opcode_index = self.encoding_buffer.len(); - self.push_byte(0x60); + self.push_byte(0x70); // Whether the decimal has a positive zero coefficient (of any exponent). This value is needed in two places // and is non-trivial, so we compute it up front and store the result. @@ -235,7 +235,7 @@ impl<'value, 'top> BinaryValueWriter_1_1<'value, 'top> { _ => { // If the encoded size ends up being unusually large, we will splice in a corrected header. // Start by overwriting our original opcode with 0xF6, which indicates a Decimal with a FlexUInt length. - self.encoding_buffer[opcode_index] = 0xF6; + self.encoding_buffer[opcode_index] = 0xF7; // We'll use an `ArrayVec` as our encoding buffer because it's stack-allocated and implements `io::Write`. // It has a capacity of 16 bytes because it's the smallest power of two that is still large enough to // hold a FlexUInt encoding of usize::MAX on a 64-bit platform. @@ -334,18 +334,18 @@ impl<'value, 'top> BinaryValueWriter_1_1<'value, 'top> { // These opcodes assume UTC or unknown offset--we adjust for known offsets afterwards. let (mut opcode, bits_populated, mut encoded_body_length, subseconds) = match (precision, scale) { - (Year, _) => (0x70, 7, 1, 0), - (Month, _) => (0x71, 11, 2, 0), - (Day, _) => (0x72, 16, 2, 0), - (HourAndMinute, _) => (0x73, 27 + num_offset_bits, 4, 0), + (Year, _) => (0x80, 7, 1, 0), + (Month, _) => (0x81, 11, 2, 0), + (Day, _) => (0x82, 16, 2, 0), + (HourAndMinute, _) => (0x83, 27 + num_offset_bits, 4, 0), // Seconds - (Second, 0) => (0x74, 33 + num_offset_bits, 5, 0), + (Second, 0) => (0x84, 33 + num_offset_bits, 5, 0), // Milliseconds - (Second, 3) => (0x75, 43 + num_offset_bits, 6, value.milliseconds()), + (Second, 3) => (0x85, 43 + num_offset_bits, 6, value.milliseconds()), // Microseconds - (Second, 6) => (0x76, 53 + num_offset_bits, 7, value.microseconds()), + (Second, 6) => (0x86, 53 + num_offset_bits, 7, value.microseconds()), // Nanoseconds - (Second, 9) => (0x77, 63 + num_offset_bits, 8, value.nanoseconds()), + (Second, 9) => (0x87, 63 + num_offset_bits, 8, value.nanoseconds()), _ => { unreachable!("illegal precision / fractional second seconds scale encountered") } @@ -382,7 +382,7 @@ impl<'value, 'top> BinaryValueWriter_1_1<'value, 'top> { self.push_byte(opcode); // If the timestamp is at a known offset and uses nanosecond precision... - if opcode == 0x7C { + if opcode == 0x8C { // ...then its encoding requires 70 bits. We've been using a u64 to hold the encoding, so the most // significant 6 bits have been lost at this point. We need to get the most significant 6 bits of the // nanoseconds field and write them out as a final byte. Because `subseconds` represents a number of @@ -465,9 +465,9 @@ impl<'value, 'top> BinaryValueWriter_1_1<'value, 'top> { .wrapping_sub(1); encoding &= mask; - // Push 0xF7 (the opcode for a Timestamp w/FlexUInt length) and 0x01 (a placeholder 0 FlexUInt that we'll + // Push 0xF8 (the opcode for a Timestamp w/FlexUInt length) and 0x01 (a placeholder 0 FlexUInt that we'll // overwrite when the final encoding size is known. - self.push_bytes(&[0xF7, 0x01]); + self.push_bytes(&[0xF8, 0x01]); let length_byte_index = self.encoding_buffer.len() - 1; self.push_bytes(&encoding.to_le_bytes()[..encoded_length]); @@ -501,16 +501,16 @@ impl<'value, 'top> BinaryValueWriter_1_1<'value, 'top> { #[inline] pub fn write_string>(mut self, value: A) -> IonResult<()> { - const STRING_OPCODE: u8 = 0x80; - const STRING_FLEX_UINT_LEN_OPCODE: u8 = 0xF8; + const STRING_OPCODE: u8 = 0x90; + const STRING_FLEX_UINT_LEN_OPCODE: u8 = 0xF9; self.write_text(STRING_OPCODE, STRING_FLEX_UINT_LEN_OPCODE, value.as_ref()); Ok(()) } #[inline] pub fn write_symbol(mut self, value: A) -> IonResult<()> { - const SYMBOL_OPCODE: u8 = 0x90; - const SYMBOL_FLEX_UINT_LEN_OPCODE: u8 = 0xF9; + const SYMBOL_OPCODE: u8 = 0xA0; + const SYMBOL_FLEX_UINT_LEN_OPCODE: u8 = 0xFA; match value.as_raw_symbol_token_ref() { RawSymbolRef::SymbolId(sid) => self.write_symbol_id(sid), RawSymbolRef::Text(text) => { @@ -896,7 +896,7 @@ mod tests { #[test] fn write_bools() -> IonResult<()> { - let test_cases: &[(bool, &[u8])] = &[(true, &[0x5E]), (false, &[0x5F])]; + let test_cases: &[(bool, &[u8])] = &[(true, &[0x6E]), (false, &[0x6F])]; for (value, expected_encoding) in test_cases { encoding_test( |writer: &mut LazyRawBinaryWriter_1_1<&mut Vec>| { @@ -912,22 +912,22 @@ mod tests { #[test] fn write_ints() -> IonResult<()> { let test_cases: &[(i64, &[u8])] = &[ - (0, &[0x50]), - (-1, &[0x51, 0xFF]), - (1, &[0x51, 0x01]), - (100, &[0x51, 0x64]), - (-100, &[0x51, 0x9C]), - (127, &[0x51, 0x7F]), - (-127, &[0x51, 0x81]), - (128, &[0x52, 0x80, 0x00]), - (-128, &[0x51, 0x80]), + (0, &[0x60]), + (-1, &[0x61, 0xFF]), + (1, &[0x61, 0x01]), + (100, &[0x61, 0x64]), + (-100, &[0x61, 0x9C]), + (127, &[0x61, 0x7F]), + (-127, &[0x61, 0x81]), + (128, &[0x62, 0x80, 0x00]), + (-128, &[0x61, 0x80]), ( i64::MAX, - &[0x58, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0x7F], + &[0x68, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0x7F], ), ( i64::MIN, - &[0x58, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x80], + &[0x68, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x80], ), ]; for (value, expected_encoding) in test_cases { @@ -956,7 +956,7 @@ mod tests { f32::NAN, ]; for value in test_f64s { - let mut expected_encoding = vec![0x5C]; + let mut expected_encoding = vec![0x6C]; expected_encoding.extend_from_slice(&value.to_le_bytes()[..]); encoding_test( |writer: &mut LazyRawBinaryWriter_1_1<&mut Vec>| { @@ -989,14 +989,14 @@ mod tests { let mut expected_encoding = vec![]; match value.smallest_repr() { FloatRepr::Zero => { - expected_encoding.push(0x5A); + expected_encoding.push(0x6A); } FloatRepr::Single(f) => { - expected_encoding.push(0x5C); + expected_encoding.push(0x6C); expected_encoding.extend_from_slice(&f.to_le_bytes()[..]); } FloatRepr::Double(f) => { - expected_encoding.push(0x5D); + expected_encoding.push(0x6D); expected_encoding.extend_from_slice(&f.to_le_bytes()[..]); } } @@ -1014,13 +1014,13 @@ mod tests { #[test] fn write_strings() -> IonResult<()> { let test_cases: &[(&str, &[u8])] = &[ - ("", &[0x80]), + ("", &[0x90]), // f o o - ("foo", &[0x83, 0x66, 0x6F, 0x6F]), + ("foo", &[0x93, 0x66, 0x6F, 0x6F]), ( "foo bar baz quux quuz", &[ - 0xF8, // Opcode: string with variable-width length + 0xF9, // Opcode: string with variable-width length 0x2B, // FlexUInt length 0x66, // UTF-8 text bytes 0x6F, 0x6F, 0x20, 0x62, 0x61, 0x72, 0x20, 0x62, 0x61, 0x7a, 0x20, 0x71, 0x75, @@ -1043,13 +1043,13 @@ mod tests { #[test] fn write_symbols_with_inline_text() -> IonResult<()> { let test_cases: &[(&str, &[u8])] = &[ - ("", &[0x90]), + ("", &[0xA0]), // f o o - ("foo", &[0x93, 0x66, 0x6F, 0x6F]), + ("foo", &[0xA3, 0x66, 0x6F, 0x6F]), ( "foo bar baz quux quuz", &[ - 0xF9, // Opcode: symbol with variable-width length + 0xFA, // Opcode: symbol with variable-width length 0x2B, // FlexUInt length 0x66, // UTF-8 text bytes 0x6F, 0x6F, 0x20, 0x62, 0x61, 0x72, 0x20, 0x62, 0x61, 0x7a, 0x20, 0x71, 0x75, @@ -1094,25 +1094,25 @@ mod tests { #[test] fn write_decimals() -> IonResult<()> { let test_cases: &[(Decimal, &[u8])] = &[ - (Decimal::new(0, 0), &[0x60]), - (Decimal::new(0, 3), &[0x61, 0x07]), - (Decimal::negative_zero(), &[0x62, 0x01, 0x00]), - (Decimal::negative_zero_with_exponent(3), &[0x62, 0x07, 0x00]), + (Decimal::new(0, 0), &[0x70]), + (Decimal::new(0, 3), &[0x71, 0x07]), + (Decimal::negative_zero(), &[0x72, 0x01, 0x00]), + (Decimal::negative_zero_with_exponent(3), &[0x72, 0x07, 0x00]), ( Decimal::negative_zero_with_exponent(-3), - &[0x62, 0xFB, 0x00], + &[0x72, 0xFB, 0x00], ), - (Decimal::new(7, 4), &[0x62, 0x09, 0x07]), + (Decimal::new(7, 4), &[0x72, 0x09, 0x07]), ( // ~Pi Decimal::new(3_1415926535i64, -10), - &[0x66, 0xED, 0x07, 0xFF, 0x88, 0x50, 0x07], + &[0x76, 0xED, 0x07, 0xFF, 0x88, 0x50, 0x07], ), ( // ~e Decimal::new(Int::from(27182818284590452353602874713526624i128), -40), &[ - 0xF6, 0x21, 0xB1, 0x60, 0x51, 0x2B, 0xF8, 0xFE, 0x2B, 0xA4, 0x11, 0xAF, 0x90, + 0xF7, 0x21, 0xB1, 0x60, 0x51, 0x2B, 0xF8, 0xFE, 0x2B, 0xA4, 0x11, 0xAF, 0x90, 0xF7, 0x66, 0x37, 0x3C, 0x05, ], ), @@ -1134,39 +1134,39 @@ mod tests { let test_cases: &[(&str, &[u8])] = &[ // === Year === // .YYY_YYYY - ("1970T", &[0x70, 0b0000_0000]), - ("2097T", &[0x70, 0b0111_1111]), - ("2024T", &[0x70, 0b0011_0110]), + ("1970T", &[0x80, 0b0000_0000]), + ("2097T", &[0x80, 0b0111_1111]), + ("2024T", &[0x80, 0b0011_0110]), // // === Month === // MYYY_YYYY ...._.MMM - ("2024-01T", &[0x71, 0b1011_0110, 0b0000_0000]), - ("2024-10T", &[0x71, 0b0011_0110, 0b0000_0101]), - ("2024-11T", &[0x71, 0b1011_0110, 0b0000_0101]), - ("2024-12T", &[0x71, 0b0011_0110, 0b0000_0110]), + ("2024-01T", &[0x81, 0b1011_0110, 0b0000_0000]), + ("2024-10T", &[0x81, 0b0011_0110, 0b0000_0101]), + ("2024-11T", &[0x81, 0b1011_0110, 0b0000_0101]), + ("2024-12T", &[0x81, 0b0011_0110, 0b0000_0110]), // // === Day === // MYYY_YYYY DDDD_DMMM - ("2024-06-01", &[0x72, 0b0011_0110, 0b0000_1011]), - ("2024-06-15", &[0x72, 0b0011_0110, 0b0111_1011]), - ("2024-06-30", &[0x72, 0b0011_0110, 0b1111_0011]), + ("2024-06-01", &[0x82, 0b0011_0110, 0b0000_1011]), + ("2024-06-15", &[0x82, 0b0011_0110, 0b0111_1011]), + ("2024-06-30", &[0x82, 0b0011_0110, 0b1111_0011]), // // === Hour & Minute @ UTC === // ( "2024-06-01T08:00Z", // MYYY_YYYY DDDD_DMMM mmmH_HHHH ...._Ummm - &[0x73, 0b0011_0110, 0b0000_1011, 0b0000_1000, 0b0000_0000], + &[0x83, 0b0011_0110, 0b0000_1011, 0b0000_1000, 0b0000_0000], ), ( "2024-06-15T12:30Z", // MYYY_YYYY DDDD_DMMM mmmH_HHHH ...._Ummm - &[0x73, 0b0011_0110, 0b0111_1011, 0b1100_1100, 0b0000_0011], + &[0x83, 0b0011_0110, 0b0111_1011, 0b1100_1100, 0b0000_0011], ), ( "2024-06-30T16:45Z", // MYYY_YYYY DDDD_DMMM mmmH_HHHH ...._Ummm - &[0x73, 0b0011_0110, 0b1111_0011, 0b1011_0000, 0b0000_0101], + &[0x83, 0b0011_0110, 0b1111_0011, 0b1011_0000, 0b0000_0101], ), // // === Hour & Minute @ Unknown Offset === @@ -1174,17 +1174,17 @@ mod tests { ( "2024-06-01T08:00-00:00", // MYYY_YYYY DDDD_DMMM mmmH_HHHH ...._Ummm - &[0x73, 0b0011_0110, 0b0000_1011, 0b0000_1000, 0b0000_1000], + &[0x83, 0b0011_0110, 0b0000_1011, 0b0000_1000, 0b0000_1000], ), ( "2024-06-15T12:30-00:00", // MYYY_YYYY DDDD_DMMM mmmH_HHHH ...._Ummm - &[0x73, 0b0011_0110, 0b0111_1011, 0b1100_1100, 0b0000_1011], + &[0x83, 0b0011_0110, 0b0111_1011, 0b1100_1100, 0b0000_1011], ), ( "2024-06-30T16:45-00:00", // MYYY_YYYY DDDD_DMMM mmmH_HHHH ...._Ummm - &[0x73, 0b0011_0110, 0b1111_0011, 0b1011_0000, 0b0000_1101], + &[0x83, 0b0011_0110, 0b1111_0011, 0b1011_0000, 0b0000_1101], ), // // === Second @ UTC === @@ -1192,7 +1192,7 @@ mod tests { ( "2024-06-01T08:00:00Z", &[ - 0x74, + 0x84, 0b0011_0110, // MYYY_YYYY 0b0000_1011, // DDDD_DMMM 0b0000_1000, // mmmH_HHHH @@ -1203,7 +1203,7 @@ mod tests { ( "2024-06-15T12:30:30Z", &[ - 0x74, + 0x84, 0b0011_0110, // MYYY_YYYY 0b0111_1011, // DDDD_DMMM 0b1100_1100, // mmmH_HHHH @@ -1214,7 +1214,7 @@ mod tests { ( "2024-06-30T16:45:45Z", &[ - 0x74, + 0x84, 0b0011_0110, // MYYY_YYYY 0b1111_0011, // DDDD_DMMM 0b1011_0000, // mmmH_HHHH @@ -1228,7 +1228,7 @@ mod tests { ( "2024-06-01T08:00:00-00:00", &[ - 0x74, + 0x84, 0b0011_0110, // MYYY_YYYY 0b0000_1011, // DDDD_DMMM 0b0000_1000, // mmmH_HHHH @@ -1239,7 +1239,7 @@ mod tests { ( "2024-06-15T12:30:30-00:00", &[ - 0x74, + 0x84, 0b0011_0110, // MYYY_YYYY 0b0111_1011, // DDDD_DMMM 0b1100_1100, // mmmH_HHHH @@ -1250,7 +1250,7 @@ mod tests { ( "2024-06-30T16:45:45-00:00", &[ - 0x74, + 0x84, 0b0011_0110, // MYYY_YYYY 0b1111_0011, // DDDD_DMMM 0b1011_0000, // mmmH_HHHH @@ -1264,7 +1264,7 @@ mod tests { ( "2024-06-01T08:00:00.000Z", &[ - 0x75, + 0x85, 0b0011_0110, // MYYY_YYYY 0b0000_1011, // DDDD_DMMM 0b0000_1000, // mmmH_HHHH @@ -1276,7 +1276,7 @@ mod tests { ( "2024-06-15T12:30:30.030Z", &[ - 0x75, + 0x85, 0b0011_0110, // MYYY_YYYY 0b0111_1011, // DDDD_DMMM 0b1100_1100, // mmmH_HHHH @@ -1288,7 +1288,7 @@ mod tests { ( "2024-06-30T16:45:45.045Z", &[ - 0x75, + 0x85, 0b0011_0110, // MYYY_YYYY 0b1111_0011, // DDDD_DMMM 0b1011_0000, // mmmH_HHHH @@ -1303,7 +1303,7 @@ mod tests { ( "2024-06-01T08:00:00.000-00:00", &[ - 0x75, + 0x85, 0b0011_0110, // MYYY_YYYY 0b0000_1011, // DDDD_DMMM 0b0000_1000, // mmmH_HHHH @@ -1315,7 +1315,7 @@ mod tests { ( "2024-06-15T12:30:30.030-00:00", &[ - 0x75, + 0x85, 0b0011_0110, // MYYY_YYYY 0b0111_1011, // DDDD_DMMM 0b1100_1100, // mmmH_HHHH @@ -1327,7 +1327,7 @@ mod tests { ( "2024-06-30T16:45:45.045-00:00", &[ - 0x75, + 0x85, 0b0011_0110, // MYYY_YYYY 0b1111_0011, // DDDD_DMMM 0b1011_0000, // mmmH_HHHH @@ -1342,7 +1342,7 @@ mod tests { ( "2024-06-01T08:00:00.000000Z", &[ - 0x76, + 0x86, 0b0011_0110, // MYYY_YYYY 0b0000_1011, // DDDD_DMMM 0b0000_1000, // mmmH_HHHH @@ -1355,7 +1355,7 @@ mod tests { ( "2024-06-15T12:30:30.000030Z", &[ - 0x76, + 0x86, 0b0011_0110, // MYYY_YYYY 0b0111_1011, // DDDD_DMMM 0b1100_1100, // mmmH_HHHH @@ -1368,7 +1368,7 @@ mod tests { ( "2024-06-30T16:45:45.000045Z", &[ - 0x76, + 0x86, 0b0011_0110, // MYYY_YYYY 0b1111_0011, // DDDD_DMMM 0b1011_0000, // mmmH_HHHH @@ -1384,7 +1384,7 @@ mod tests { ( "2024-06-01T08:00:00.000000-00:00", &[ - 0x76, + 0x86, 0b0011_0110, // MYYY_YYYY 0b0000_1011, // DDDD_DMMM 0b0000_1000, // mmmH_HHHH @@ -1397,7 +1397,7 @@ mod tests { ( "2024-06-15T12:30:30.000030-00:00", &[ - 0x76, + 0x86, 0b0011_0110, // MYYY_YYYY 0b0111_1011, // DDDD_DMMM 0b1100_1100, // mmmH_HHHH @@ -1410,7 +1410,7 @@ mod tests { ( "2024-06-30T16:45:45.000045-00:00", &[ - 0x76, + 0x86, 0b0011_0110, // MYYY_YYYY 0b1111_0011, // DDDD_DMMM 0b1011_0000, // mmmH_HHHH @@ -1426,7 +1426,7 @@ mod tests { ( "2024-06-01T08:00:00.000000000Z", &[ - 0x77, + 0x87, 0b0011_0110, // MYYY_YYYY 0b0000_1011, // DDDD_DMMM 0b0000_1000, // mmmH_HHHH @@ -1440,7 +1440,7 @@ mod tests { ( "2024-06-15T12:30:30.000000030Z", &[ - 0x77, + 0x87, 0b0011_0110, // MYYY_YYYY 0b0111_1011, // DDDD_DMMM 0b1100_1100, // mmmH_HHHH @@ -1454,7 +1454,7 @@ mod tests { ( "2024-06-30T16:45:45.000000045Z", &[ - 0x77, + 0x87, 0b0011_0110, // MYYY_YYYY 0b1111_0011, // DDDD_DMMM 0b1011_0000, // mmmH_HHHH @@ -1471,7 +1471,7 @@ mod tests { ( "2024-06-01T08:00:00.000000000-00:00", &[ - 0x77, + 0x87, 0b0011_0110, // MYYY_YYYY 0b0000_1011, // DDDD_DMMM 0b0000_1000, // mmmH_HHHH @@ -1485,7 +1485,7 @@ mod tests { ( "2024-06-15T12:30:30.000000030-00:00", &[ - 0x77, + 0x87, 0b0011_0110, // MYYY_YYYY 0b0111_1011, // DDDD_DMMM 0b1100_1100, // mmmH_HHHH @@ -1499,7 +1499,7 @@ mod tests { ( "2024-06-30T16:45:45.000000045-00:00", &[ - 0x77, + 0x87, 0b0011_0110, // MYYY_YYYY 0b1111_0011, // DDDD_DMMM 0b1011_0000, // mmmH_HHHH @@ -1517,7 +1517,7 @@ mod tests { ( "2024-06-01T08:00-05:00", &[ - 0x78, + 0x88, 0b0011_0110, // MYYY_YYYY 0b0000_1011, // DDDD_DMMM 0b0000_1000, // mmmH_HHHH @@ -1528,7 +1528,7 @@ mod tests { ( "2024-06-15T12:30-05:00", &[ - 0x78, + 0x88, 0b0011_0110, // MYYY_YYYY 0b0111_1011, // DDDD_DMMM 0b1100_1100, // mmmH_HHHH @@ -1539,7 +1539,7 @@ mod tests { ( "2024-06-30T16:45-05:00", &[ - 0x78, + 0x88, 0b0011_0110, // MYYY_YYYY 0b1111_0011, // DDDD_DMMM 0b1011_0000, // mmmH_HHHH @@ -1553,7 +1553,7 @@ mod tests { ( "2024-06-01T08:00:00-05:00", &[ - 0x79, + 0x89, 0b0011_0110, // MYYY_YYYY 0b0000_1011, // DDDD_DMMM 0b0000_1000, // mmmH_HHHH @@ -1564,7 +1564,7 @@ mod tests { ( "2024-06-15T12:30:30-05:00", &[ - 0x79, + 0x89, 0b0011_0110, // MYYY_YYYY 0b0111_1011, // DDDD_DMMM 0b1100_1100, // mmmH_HHHH @@ -1575,7 +1575,7 @@ mod tests { ( "2024-06-30T16:45:45-05:00", &[ - 0x79, + 0x89, 0b0011_0110, // MYYY_YYYY 0b1111_0011, // DDDD_DMMM 0b1011_0000, // mmmH_HHHH @@ -1589,7 +1589,7 @@ mod tests { ( "2024-06-01T08:00:00.000-05:00", &[ - 0x7A, + 0x8A, 0b0011_0110, // MYYY_YYYY 0b0000_1011, // DDDD_DMMM 0b0000_1000, // mmmH_HHHH @@ -1602,7 +1602,7 @@ mod tests { ( "2024-06-15T12:30:30.030-05:00", &[ - 0x7A, + 0x8A, 0b0011_0110, // MYYY_YYYY 0b0111_1011, // DDDD_DMMM 0b1100_1100, // mmmH_HHHH @@ -1615,7 +1615,7 @@ mod tests { ( "2024-06-30T16:45:45.045-05:00", &[ - 0x7A, + 0x8A, 0b0011_0110, // MYYY_YYYY 0b1111_0011, // DDDD_DMMM 0b1011_0000, // mmmH_HHHH @@ -1631,7 +1631,7 @@ mod tests { ( "2024-06-01T08:00:00.000000-05:00", &[ - 0x7B, + 0x8B, 0b0011_0110, // MYYY_YYYY 0b0000_1011, // DDDD_DMMM 0b0000_1000, // mmmH_HHHH @@ -1645,7 +1645,7 @@ mod tests { ( "2024-06-15T12:30:30.000030-05:00", &[ - 0x7B, + 0x8B, 0b0011_0110, // MYYY_YYYY 0b0111_1011, // DDDD_DMMM 0b1100_1100, // mmmH_HHHH @@ -1659,7 +1659,7 @@ mod tests { ( "2024-06-30T16:45:45.000045-05:00", &[ - 0x7B, + 0x8B, 0b0011_0110, // MYYY_YYYY 0b1111_0011, // DDDD_DMMM 0b1011_0000, // mmmH_HHHH @@ -1676,7 +1676,7 @@ mod tests { ( "2024-06-01T08:00:00.000000000-05:00", &[ - 0x7C, + 0x8C, 0b0011_0110, // MYYY_YYYY 0b0000_1011, // DDDD_DMMM 0b0000_1000, // mmmH_HHHH @@ -1691,7 +1691,7 @@ mod tests { ( "2024-06-15T12:30:30.000000030-05:00", &[ - 0x7C, + 0x8C, 0b0011_0110, // MYYY_YYYY 0b0111_1011, // DDDD_DMMM 0b1100_1100, // mmmH_HHHH @@ -1706,7 +1706,7 @@ mod tests { ( "2024-06-30T16:45:45.000000045-05:00", &[ - 0x7C, + 0x8C, 0b0011_0110, // MYYY_YYYY 0b1111_0011, // DDDD_DMMM 0b1011_0000, // mmmH_HHHH @@ -1724,7 +1724,7 @@ mod tests { ( "1969T", &[ - 0xF7, // Timestamp w/FlexUInt length + 0xF8, // Timestamp w/FlexUInt length 0x05, // FlexUInt length 2 0b1011_0001, // YYYY_YYYY 0b0000_0111, // ..YY_YYYY @@ -1733,7 +1733,7 @@ mod tests { ( "0001T", &[ - 0xF7, // Timestamp w/FlexUInt length + 0xF8, // Timestamp w/FlexUInt length 0x05, // FlexUInt length 2 0b0000_0001, // YYYY_YYYY 0b0000_0000, // ..YY_YYYY @@ -1742,7 +1742,7 @@ mod tests { ( "9999T", &[ - 0xF7, // Timestamp w/FlexUInt length + 0xF8, // Timestamp w/FlexUInt length 0x05, // FlexUInt length 2 0b0000_1111, // YYYY_YYYY 0b0010_0111, // ..YY_YYYY @@ -1754,7 +1754,7 @@ mod tests { ( "1969-01T", &[ - 0xF7, // Timestamp w/FlexUInt length + 0xF8, // Timestamp w/FlexUInt length 0x07, // FlexUInt length 3 0b1011_0001, // YYYY_YYYY 0b0100_0111, // MMYY_YYYY @@ -1764,7 +1764,7 @@ mod tests { ( "1969-06T", &[ - 0xF7, // Timestamp w/FlexUInt length + 0xF8, // Timestamp w/FlexUInt length 0x07, // FlexUInt length 3 0b1011_0001, // YYYY_YYYY 0b1000_0111, // MMYY_YYYY @@ -1774,7 +1774,7 @@ mod tests { ( "1969-12T", &[ - 0xF7, // Timestamp w/FlexUInt length + 0xF8, // Timestamp w/FlexUInt length 0x07, // FlexUInt length 3 0b1011_0001, // YYYY_YYYY 0b0000_0111, // MMYY_YYYY @@ -1787,7 +1787,7 @@ mod tests { ( "1969-01-01T", &[ - 0xF7, // Timestamp w/FlexUInt length + 0xF8, // Timestamp w/FlexUInt length 0x07, // FlexUInt length 3 0b1011_0001, // YYYY_YYYY 0b0100_0111, // MMYY_YYYY @@ -1797,7 +1797,7 @@ mod tests { ( "1969-06-15T", &[ - 0xF7, // Timestamp w/FlexUInt length + 0xF8, // Timestamp w/FlexUInt length 0x07, // FlexUInt length 3 0b1011_0001, // YYYY_YYYY 0b1000_0111, // MMYY_YYYY @@ -1807,7 +1807,7 @@ mod tests { ( "1969-12-31T", &[ - 0xF7, // Timestamp w/FlexUInt length + 0xF8, // Timestamp w/FlexUInt length 0x07, // FlexUInt length 3 0b1011_0001, // YYYY_YYYY 0b0000_0111, // MMYY_YYYY @@ -1820,7 +1820,7 @@ mod tests { ( "1969-01-01T00:00Z", &[ - 0xF7, // Timestamp w/FlexUInt length + 0xF8, // Timestamp w/FlexUInt length 0x0D, // FlexUInt length 6 0b1011_0001, // YYYY_YYYY 0b0100_0111, // MMYY_YYYY @@ -1833,7 +1833,7 @@ mod tests { ( "1969-06-15T12:30Z", &[ - 0xF7, // Timestamp w/FlexUInt length + 0xF8, // Timestamp w/FlexUInt length 0x0D, // FlexUInt length 6 0b1011_0001, // YYYY_YYYY 0b1000_0111, // MMYY_YYYY @@ -1846,7 +1846,7 @@ mod tests { ( "1969-12-31T18:45Z", &[ - 0xF7, // Timestamp w/FlexUInt length + 0xF8, // Timestamp w/FlexUInt length 0x0D, // FlexUInt length 6 0b1011_0001, // YYYY_YYYY 0b0000_0111, // MMYY_YYYY @@ -1859,7 +1859,7 @@ mod tests { ( "1969-12-31T18:45-00:00", // Unknown offset &[ - 0xF7, // Timestamp w/FlexUInt length + 0xF8, // Timestamp w/FlexUInt length 0x0D, // FlexUInt length 6 0b1011_0001, // YYYY_YYYY 0b0000_0111, // MMYY_YYYY @@ -1875,7 +1875,7 @@ mod tests { ( "1969-01-01T00:00:00Z", &[ - 0xF7, // Timestamp w/FlexUInt length + 0xF8, // Timestamp w/FlexUInt length 0x0F, // FlexUInt length 7 0b1011_0001, // YYYY_YYYY 0b0100_0111, // MMYY_YYYY @@ -1889,7 +1889,7 @@ mod tests { ( "1969-06-15T12:30:30Z", &[ - 0xF7, // Timestamp w/FlexUInt length + 0xF8, // Timestamp w/FlexUInt length 0x0F, // FlexUInt length 7 0b1011_0001, // YYYY_YYYY 0b1000_0111, // MMYY_YYYY @@ -1903,7 +1903,7 @@ mod tests { ( "1969-12-31T18:45:45Z", &[ - 0xF7, // Timestamp w/FlexUInt length + 0xF8, // Timestamp w/FlexUInt length 0x0F, // FlexUInt length 7 0b1011_0001, // YYYY_YYYY 0b0000_0111, // MMYY_YYYY @@ -1917,7 +1917,7 @@ mod tests { ( "1969-12-31T18:45:45-00:00", // Unknown offset &[ - 0xF7, // Timestamp w/FlexUInt length + 0xF8, // Timestamp w/FlexUInt length 0x0F, // FlexUInt length 7 0b1011_0001, // YYYY_YYYY 0b0000_0111, // MMYY_YYYY @@ -1934,7 +1934,7 @@ mod tests { ( "1969-01-01T00:00:00.000Z", &[ - 0xF7, // Timestamp w/FlexUInt length + 0xF8, // Timestamp w/FlexUInt length 0x13, // FlexUInt length 9 0b1011_0001, // YYYY_YYYY 0b0100_0111, // MMYY_YYYY @@ -1950,7 +1950,7 @@ mod tests { ( "1969-06-15T12:30:30.000030Z", &[ - 0xF7, // Timestamp w/FlexUInt length + 0xF8, // Timestamp w/FlexUInt length 0x13, // FlexUInt length 9 0b1011_0001, // YYYY_YYYY 0b1000_0111, // MMYY_YYYY @@ -1966,7 +1966,7 @@ mod tests { ( "1969-12-31T18:45:45.000000045Z", &[ - 0xF7, // Timestamp w/FlexUInt length + 0xF8, // Timestamp w/FlexUInt length 0x13, // FlexUInt length 7 0b1011_0001, // YYYY_YYYY 0b0000_0111, // MMYY_YYYY @@ -1982,7 +1982,7 @@ mod tests { ( "1969-12-31T18:45:45.000000045-00:00", // Unknown offset &[ - 0xF7, // Timestamp w/FlexUInt length + 0xF8, // Timestamp w/FlexUInt length 0x13, // FlexUInt length 7 0b1011_0001, // YYYY_YYYY 0b0000_0111, // MMYY_YYYY @@ -2144,35 +2144,35 @@ mod tests { #[test] fn write_length_prefixed_lists() -> IonResult<()> { let test_cases: &[(&[&str], &[u8])] = &[ - (&[], &[0xA0]), + (&[], &[0xB0]), ( &["foo"], &[ // f o o - 0xA4, 0x83, 0x66, 0x6F, 0x6F, + 0xB4, 0x93, 0x66, 0x6F, 0x6F, ], ), ( &["foo", "bar"], &[ // f o o b a r - 0xA8, 0x83, 0x66, 0x6F, 0x6F, 0x83, 0x62, 0x61, 0x72, + 0xB8, 0x93, 0x66, 0x6F, 0x6F, 0x93, 0x62, 0x61, 0x72, ], ), ( &["foo", "bar", "baz"], &[ // f o o b a r b a z - 0xAC, 0x83, 0x66, 0x6F, 0x6F, 0x83, 0x62, 0x61, 0x72, 0x83, 0x62, 0x61, 0x7a, + 0xBC, 0x93, 0x66, 0x6F, 0x6F, 0x93, 0x62, 0x61, 0x72, 0x93, 0x62, 0x61, 0x7a, ], ), ( &["foo", "bar", "baz", "quux", "quuz"], &[ // f o o b a r b a - 0xFA, 0x2D, 0x83, 0x66, 0x6F, 0x6F, 0x83, 0x62, 0x61, 0x72, 0x83, 0x62, 0x61, + 0xFB, 0x2D, 0x93, 0x66, 0x6F, 0x6F, 0x93, 0x62, 0x61, 0x72, 0x93, 0x62, 0x61, // r q u u x q u u z - 0x7a, 0x84, 0x71, 0x75, 0x75, 0x78, 0x84, 0x71, 0x75, 0x75, 0x7a, + 0x7a, 0x94, 0x71, 0x75, 0x75, 0x78, 0x94, 0x71, 0x75, 0x75, 0x7a, ], ), ]; @@ -2196,21 +2196,21 @@ mod tests { &["foo"], &[ // f o o - 0xF1, 0x83, 0x66, 0x6F, 0x6F, 0xF0, + 0xF1, 0x93, 0x66, 0x6F, 0x6F, 0xF0, ], ), ( &["foo", "bar"], &[ // f o o b a r - 0xF1, 0x83, 0x66, 0x6F, 0x6F, 0x83, 0x62, 0x61, 0x72, 0xF0, + 0xF1, 0x93, 0x66, 0x6F, 0x6F, 0x93, 0x62, 0x61, 0x72, 0xF0, ], ), ( &["foo", "bar", "baz"], &[ // f o o b a r b a z - 0xF1, 0x83, 0x66, 0x6F, 0x6F, 0x83, 0x62, 0x61, 0x72, 0x83, 0x62, 0x61, 0x7a, + 0xF1, 0x93, 0x66, 0x6F, 0x6F, 0x93, 0x62, 0x61, 0x72, 0x93, 0x62, 0x61, 0x7a, 0xF0, ], ), @@ -2218,9 +2218,9 @@ mod tests { &["foo", "bar", "baz", "quux", "quuz"], &[ // f o o b a r b a - 0xF1, 0x83, 0x66, 0x6F, 0x6F, 0x83, 0x62, 0x61, 0x72, 0x83, 0x62, 0x61, + 0xF1, 0x93, 0x66, 0x6F, 0x6F, 0x93, 0x62, 0x61, 0x72, 0x93, 0x62, 0x61, // r q u u x q u u z - 0x7a, 0x84, 0x71, 0x75, 0x75, 0x78, 0x84, 0x71, 0x75, 0x75, 0x7a, 0xF0, + 0x7a, 0x94, 0x71, 0x75, 0x75, 0x78, 0x94, 0x71, 0x75, 0x75, 0x7a, 0xF0, ], ), ]; @@ -2243,35 +2243,35 @@ mod tests { #[test] fn write_length_prefixed_sexps() -> IonResult<()> { let test_cases: &[(&[&str], &[u8])] = &[ - (&[], &[0xB0]), + (&[], &[0xC0]), ( &["foo"], &[ // f o o - 0xB4, 0x83, 0x66, 0x6F, 0x6F, + 0xC4, 0x93, 0x66, 0x6F, 0x6F, ], ), ( &["foo", "bar"], &[ // f o o b a r - 0xB8, 0x83, 0x66, 0x6F, 0x6F, 0x83, 0x62, 0x61, 0x72, + 0xC8, 0x93, 0x66, 0x6F, 0x6F, 0x93, 0x62, 0x61, 0x72, ], ), ( &["foo", "bar", "baz"], &[ // f o o b a r b a z - 0xBC, 0x83, 0x66, 0x6F, 0x6F, 0x83, 0x62, 0x61, 0x72, 0x83, 0x62, 0x61, 0x7a, + 0xCC, 0x93, 0x66, 0x6F, 0x6F, 0x93, 0x62, 0x61, 0x72, 0x93, 0x62, 0x61, 0x7a, ], ), ( &["foo", "bar", "baz", "quux", "quuz"], &[ // f o o b a r b a - 0xFB, 0x2D, 0x83, 0x66, 0x6F, 0x6F, 0x83, 0x62, 0x61, 0x72, 0x83, 0x62, 0x61, + 0xFC, 0x2D, 0x93, 0x66, 0x6F, 0x6F, 0x93, 0x62, 0x61, 0x72, 0x93, 0x62, 0x61, // r q u u x q u u z - 0x7a, 0x84, 0x71, 0x75, 0x75, 0x78, 0x84, 0x71, 0x75, 0x75, 0x7a, + 0x7a, 0x94, 0x71, 0x75, 0x75, 0x78, 0x94, 0x71, 0x75, 0x75, 0x7a, ], ), ]; @@ -2295,21 +2295,21 @@ mod tests { &["foo"], &[ // f o o - 0xF2, 0x83, 0x66, 0x6F, 0x6F, 0xF0, + 0xF2, 0x93, 0x66, 0x6F, 0x6F, 0xF0, ], ), ( &["foo", "bar"], &[ // f o o b a r - 0xF2, 0x83, 0x66, 0x6F, 0x6F, 0x83, 0x62, 0x61, 0x72, 0xF0, + 0xF2, 0x93, 0x66, 0x6F, 0x6F, 0x93, 0x62, 0x61, 0x72, 0xF0, ], ), ( &["foo", "bar", "baz"], &[ // f o o b a r b a z - 0xF2, 0x83, 0x66, 0x6F, 0x6F, 0x83, 0x62, 0x61, 0x72, 0x83, 0x62, 0x61, 0x7a, + 0xF2, 0x93, 0x66, 0x6F, 0x6F, 0x93, 0x62, 0x61, 0x72, 0x93, 0x62, 0x61, 0x7a, 0xF0, ], ), @@ -2317,9 +2317,9 @@ mod tests { &["foo", "bar", "baz", "quux", "quuz"], &[ // f o o b a r b a - 0xF2, 0x83, 0x66, 0x6F, 0x6F, 0x83, 0x62, 0x61, 0x72, 0x83, 0x62, 0x61, + 0xF2, 0x93, 0x66, 0x6F, 0x6F, 0x93, 0x62, 0x61, 0x72, 0x93, 0x62, 0x61, // r q u u x q u u z - 0x7a, 0x84, 0x71, 0x75, 0x75, 0x78, 0x84, 0x71, 0x75, 0x75, 0x7a, 0xF0, + 0x7a, 0x94, 0x71, 0x75, 0x75, 0x78, 0x94, 0x71, 0x75, 0x75, 0x7a, 0xF0, ], ), ]; @@ -2364,18 +2364,18 @@ mod tests { #[rustfmt::skip] let test_cases: &[(TestStruct, &[u8])] = &[ // Empty struct - (&[], &[0xC0]), + (&[], &[0xD0]), // Struct with a single FlexUInt field name ( &[field(4, "foo")], &[ // 5-byte struct - 0xC5, + 0xD5, // FlexUInt symbol ID 4 0x09, // 3-byte symbol // ↓ f o o - 0x93, 0x66, 0x6F, 0x6F, + 0xA3, 0x66, 0x6F, 0x6F, ], ), // Struct with multiple FlexUInt field names @@ -2383,31 +2383,31 @@ mod tests { &[field(4, "foo"), field(5, "bar"), field(6, "baz")], &[ // 15-byte struct - 0xCF, + 0xDF, // FlexUInt symbol ID 4 0x09, // 3-byte symbol // ↓ f o o - 0x93, 0x66, 0x6F, 0x6F, + 0xA3, 0x66, 0x6F, 0x6F, // FlexUInt symbol ID 5 0x0B, // 3-byte symbol // ↓ b a r - 0x93, 0x62, 0x61, 0x72, + 0xA3, 0x62, 0x61, 0x72, // -------------------- // FlexUInt symbol ID 6 0x0D, // 3-byte symbol // ↓ b a z - 0x93, 0x62, 0x61, 0x7A, + 0xA3, 0x62, 0x61, 0x7A, ], ), // Struct with single FlexSym field name ( &[field("foo", "bar")], &[ - // 8-byte struct - 0xC9, + // 9-byte struct + 0xD9, // Enable FlexSym field name encoding 0x01, // Inline 3-byte field name @@ -2415,7 +2415,7 @@ mod tests { 0xFB, 0x66, 0x6F, 0x6F, // 3-byte symbol // ↓ b a r - 0x93, 0x62, 0x61, 0x72, + 0xA3, 0x62, 0x61, 0x72, ], ), // Struct with multiple FlexSym field names @@ -2423,7 +2423,7 @@ mod tests { &[field("foo", "bar"), field("baz", "quux")], &[ // Struct with FlexUInt length - 0xFC, + 0xFD, // FlexUInt 18 0x25, // Enable FlexSym field name encoding @@ -2433,13 +2433,13 @@ mod tests { 0xFB, 0x66, 0x6F, 0x6F, // 3-byte symbol // ↓ b a r - 0x93, 0x62, 0x61, 0x72, + 0xA3, 0x62, 0x61, 0x72, // Inline 3-byte field name // ↓ b a z 0xFB, 0x62, 0x61, 0x7A, // 4-byte symbol // ↓ q u u x - 0x94, 0x71, 0x75, 0x75, 0x78 + 0xA4, 0x71, 0x75, 0x75, 0x78 ], ), // Struct with multiple FlexUInt field names followed by a FlexSym field name @@ -2447,19 +2447,19 @@ mod tests { &[field(4, "foo"), field(5, "bar"), field("quux", "quuz")], &[ // Struct with FlexUInt length - 0xFC, + 0xFD, // FlexUInt length 21 0x2B, // FlexUInt symbol ID 4 0x09, // 3-byte symbol // ↓ f o o - 0x93, 0x66, 0x6F, 0x6F, + 0xA3, 0x66, 0x6F, 0x6F, // FlexUInt symbol ID 5 0x0B, // 3-byte symbol // ↓ b a r - 0x93, 0x62, 0x61, 0x72, + 0xA3, 0x62, 0x61, 0x72, // Enable FlexSym field name encoding 0x01, // Inline 4-byte field name @@ -2467,7 +2467,7 @@ mod tests { 0xF9, 0x71, 0x75, 0x75, 0x78, // 4-byte symbol // ↓ q u u z - 0x94, 0x71, 0x75, 0x75, 0x7A + 0xA4, 0x71, 0x75, 0x75, 0x7A ], ), ]; @@ -2499,7 +2499,7 @@ mod tests { 0x09, // 3-byte symbol // ↓ f o o - 0x93, 0x66, 0x6F, 0x6F, + 0xA3, 0x66, 0x6F, 0x6F, // End delimited struct 0x01, 0xF0, ], @@ -2514,18 +2514,18 @@ mod tests { 0x09, // 3-byte symbol // ↓ f o o - 0x93, 0x66, 0x6F, 0x6F, + 0xA3, 0x66, 0x6F, 0x6F, // FlexUInt symbol ID 5 0x0B, // 3-byte symbol // ↓ b a r - 0x93, 0x62, 0x61, 0x72, + 0xA3, 0x62, 0x61, 0x72, // -------------------- // FlexUInt symbol ID 6 0x0D, // 3-byte symbol // ↓ b a z - 0x93, 0x62, 0x61, 0x7A, + 0xA3, 0x62, 0x61, 0x7A, // End delimited struct 0x01, 0xF0, ], @@ -2541,7 +2541,7 @@ mod tests { 0xFB, 0x66, 0x6F, 0x6F, // 3-byte symbol // ↓ b a r - 0x93, 0x62, 0x61, 0x72, + 0xA3, 0x62, 0x61, 0x72, // End delimited struct 0x01, 0xF0, ], @@ -2557,13 +2557,13 @@ mod tests { 0xFB, 0x66, 0x6F, 0x6F, // 3-byte symbol // ↓ b a r - 0x93, 0x62, 0x61, 0x72, + 0xA3, 0x62, 0x61, 0x72, // Inline 3-byte field name // ↓ b a z 0xFB, 0x62, 0x61, 0x7A, // 4-byte symbol // ↓ q u u x - 0x94, 0x71, 0x75, 0x75, 0x78, + 0xA4, 0x71, 0x75, 0x75, 0x78, // End delimited struct 0x01, 0xF0, ], @@ -2578,18 +2578,18 @@ mod tests { 0x09, // 3-byte symbol // ↓ f o o - 0x93, 0x66, 0x6F, 0x6F, + 0xA3, 0x66, 0x6F, 0x6F, // FlexUInt symbol ID 5 0x0B, // 3-byte symbol // ↓ b a r - 0x93, 0x62, 0x61, 0x72, + 0xA3, 0x62, 0x61, 0x72, // Inline 4-byte field name // ↓ q u u x 0xF9, 0x71, 0x75, 0x75, 0x78, // 4-byte symbol // ↓ q u u z - 0x94, 0x71, 0x75, 0x75, 0x7A, + 0xA4, 0x71, 0x75, 0x75, 0x7A, // End delimited struct 0x01, 0xF0, ], @@ -2637,7 +2637,7 @@ mod tests { 0.annotated_with(NO_ANNOTATIONS), &[ // Integer 0 - 0x50, + 0x60, ], )?; case( @@ -2645,7 +2645,7 @@ mod tests { &[ 0xE7, // One FlexSym annotation follows 0x09, // FlexSym $4 - 0x50, // Integer 0 + 0x60, // Integer 0 ], )?; case( @@ -2654,7 +2654,7 @@ mod tests { 0xE8, // Two FlexSym annotations follow 0x09, // FlexSym $4 0x0B, // FlexSym $5 - 0x50, // Integer 0 + 0x60, // Integer 0 ], )?; case( @@ -2665,7 +2665,7 @@ mod tests { 0x09, // FlexSym $4 0x0B, // FlexSym $5 0x0D, // FlexSym $6 - 0x50, // Integer 0 + 0x60, // Integer 0 ], )?; @@ -2676,7 +2676,7 @@ mod tests { 0xE7, // One FlexSym annotation follows 0xFB, // FlexSym: 3 UTF-8 bytes 0x66, 0x6F, 0x6F, // foo - 0x50, // Integer 0 + 0x60, // Integer 0 ], )?; case( @@ -2687,7 +2687,7 @@ mod tests { 0x66, 0x6F, 0x6F, // foo 0xFB, // FlexSym: 3 UTF-8 bytes 0x62, 0x61, 0x72, // bar - 0x50, // Integer 0 + 0x60, // Integer 0 ], )?; case( @@ -2701,7 +2701,7 @@ mod tests { 0x62, 0x61, 0x72, // bar 0xFB, // FlexSym: 3 UTF-8 bytes 0x62, 0x61, 0x7a, // baz - 0x50, // Integer 0 + 0x60, // Integer 0 ], )?; @@ -2714,7 +2714,7 @@ mod tests { 0x09, // FlexSym $4, 0xFB, // FlexSym: 3 UTF-8 bytes 0x66, 0x6F, 0x6F, // foo - 0x50, // Integer 0 + 0x60, // Integer 0 ], )?; case( @@ -2724,7 +2724,7 @@ mod tests { 0xFB, // FlexSym: 3 UTF-8 bytes 0x66, 0x6F, 0x6F, // foo 0x09, // FlexSym $4, - 0x50, // Integer 0 + 0x60, // Integer 0 ], )?; case( @@ -2741,7 +2741,7 @@ mod tests { 0x09, // FlexSym $4 0xFB, // FlexSym: 3 UTF-8 bytes 0x62, 0x61, 0x7a, // baz - 0x50, // Integer 0 + 0x60, // Integer 0 ], )?; case( @@ -2757,7 +2757,7 @@ mod tests { 0xFB, // FlexSym: 3 UTF-8 bytes 0x66, 0x6F, 0x6F, // foo 0x0B, // FlexSym $5 - 0x50, // Integer 0 + 0x60, // Integer 0 ], )?; @@ -2767,11 +2767,11 @@ mod tests { &[ 0xE8, // Two FlexSym annotations follow 0x01, // Opcode follows - 0x80, // String of length 0 + 0x90, // String of length 0 0x01, // Opcode follows 0xE1, // 1-byte FixedUInt symbol ID follows 0x00, // Symbol ID 0 - 0x50, // Integer 0 + 0x60, // Integer 0 ], )?; @@ -2790,9 +2790,9 @@ mod tests { }, &[ 0x00, // Invoke macro address 0 - 0x93, 0x66, 0x6f, 0x6f, // foo - 0x93, 0x62, 0x61, 0x72, // bar - 0x93, 0x62, 0x61, 0x7a, // baz + 0xA3, 0x66, 0x6f, 0x6f, // foo + 0xA3, 0x62, 0x61, 0x72, // bar + 0xA3, 0x62, 0x61, 0x7a, // baz ], )?; Ok(()) From eb7ec55592e962588a64cbf91e53ef7627a7ad6d Mon Sep 17 00:00:00 2001 From: Zack Slayton Date: Thu, 6 Jun 2024 17:50:40 -0400 Subject: [PATCH 2/2] Shift opcodes for binary 1.1 reader --- src/lazy/binary/raw/v1_1/reader.rs | 280 ++++++++++---------- src/lazy/binary/raw/v1_1/struct.rs | 4 +- src/lazy/binary/raw/v1_1/type_code.rs | 49 ++-- src/lazy/binary/raw/v1_1/type_descriptor.rs | 41 ++- src/lazy/binary/raw/v1_1/value.rs | 2 +- 5 files changed, 189 insertions(+), 187 deletions(-) diff --git a/src/lazy/binary/raw/v1_1/reader.rs b/src/lazy/binary/raw/v1_1/reader.rs index 173d440d..b157ffac 100644 --- a/src/lazy/binary/raw/v1_1/reader.rs +++ b/src/lazy/binary/raw/v1_1/reader.rs @@ -204,8 +204,8 @@ mod tests { fn bools() -> IonResult<()> { let data: Vec = vec![ 0xE0, 0x01, 0x01, 0xEA, // IVM - 0x5E, // true - 0x5F, // false + 0x6E, // true + 0x6F, // false ]; let mut reader = LazyRawBinaryReader_1_1::new(&data); @@ -226,19 +226,19 @@ mod tests { 0xE0, 0x01, 0x01, 0xEA, // Integer: 0 - 0x50, + 0x60, // Integer: 17 - 0x51, 0x11, + 0x61, 0x11, // Integer: -944 - 0x52, 0x50, 0xFC, + 0x62, 0x50, 0xFC, // Integer: 1 - 0xF5, 0x03, 0x01, + 0xF6, 0x03, 0x01, // Integer: 147573952589676412929 - 0xF5, 0x13, 0x01, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x08, + 0xF6, 0x13, 0x01, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x08, ]; let mut reader = LazyRawBinaryReader_1_1::new(&data); @@ -277,17 +277,17 @@ mod tests { 0xe0, 0x01, 0x01, 0xea, // String: "" - 0x80, + 0x90, // String: "hello" - 0x85, 0x68, 0x65, 0x6c, 0x6c, 0x6f, + 0x95, 0x68, 0x65, 0x6c, 0x6c, 0x6f, // String: "fourteen bytes" - 0x8E, 0x66, 0x6F, 0x75, 0x72, 0x74, 0x65, 0x65, 0x6E, 0x20, 0x62, 0x79, 0x74, 0x65, + 0x9E, 0x66, 0x6F, 0x75, 0x72, 0x74, 0x65, 0x65, 0x6E, 0x20, 0x62, 0x79, 0x74, 0x65, 0x73, // String: "variable length encoding" - 0xF8, 0x31, 0x76, 0x61, 0x72, 0x69, 0x61, 0x62, 0x6C, 0x65, 0x20, 0x6C, 0x65, + 0xF9, 0x31, 0x76, 0x61, 0x72, 0x69, 0x61, 0x62, 0x6C, 0x65, 0x20, 0x6C, 0x65, 0x6E, 0x67, 0x74, 0x68, 0x20, 0x65, 0x6E, 0x63, 0x6f, 0x64, 0x69, 0x6E, 0x67, ]; @@ -322,14 +322,14 @@ mod tests { 0xE0, 0x01, 0x01, 0xEA, // Symbol: '' - 0x90, + 0xA0, // Symbol: 'fourteen bytes' - 0x9E, 0x66, 0x6F, 0x75, 0x72, 0x74, 0x65, 0x65, 0x6E, 0x20, 0x62, 0x79, 0x74, 0x65, + 0xAE, 0x66, 0x6F, 0x75, 0x72, 0x74, 0x65, 0x65, 0x6E, 0x20, 0x62, 0x79, 0x74, 0x65, 0x73, // Symbol: 'variable length encoding' - 0xF9, 0x31, 0x76, 0x61, 0x72, 0x69, 0x61, 0x62, 0x6C, 0x65, 0x20, 0x6C, 0x65, 0x6E, + 0xFA, 0x31, 0x76, 0x61, 0x72, 0x69, 0x61, 0x62, 0x6C, 0x65, 0x20, 0x6C, 0x65, 0x6E, 0x67, 0x74, 0x68, 0x20, 0x65, 0x6E, 0x63, 0x6f, 0x64, 0x69, 0x6E, 0x67, // Symbol ID: 1 @@ -386,16 +386,16 @@ mod tests { // IVM 0xe0, 0x01, 0x01, 0xea, // 0e0 - 0x5A, + 0x6A, // 3.14 (half-precision) - // 0x5B, 0x42, 0x47, + // 0x6B, 0x42, 0x47, // 3.1415927 (single-precision) - 0x5C, 0xdb, 0x0F, 0x49, 0x40, + 0x6C, 0xdb, 0x0F, 0x49, 0x40, // 3.141592653589793 (double-precision) - 0x5D, 0x18, 0x2D, 0x44, 0x54, 0xFB, 0x21, 0x09, 0x40, + 0x6D, 0x18, 0x2D, 0x44, 0x54, 0xFB, 0x21, 0x09, 0x40, ]; let mut reader = LazyRawBinaryReader_1_1::new(&data); @@ -420,56 +420,56 @@ mod tests { } #[rstest] - #[case("0.", &[0x60])] - #[case("0d1", &[0x61, 0x03])] - #[case("0d63", &[0x61, 0x7F])] - #[case("0d64", &[0x62, 0x02, 0x01])] - #[case("0d99", &[0x62, 0x8E, 0x01])] - #[case("0.0", &[0x61, 0xFF])] - #[case("0.00", &[0x61, 0xFD])] - #[case("0.000", &[0x61, 0xFB])] - #[case("0d-64", &[0x61, 0x81])] - #[case("0d-99", &[0x62, 0x76, 0xFE])] - #[case("-0.", &[0x62, 0x01, 0x00])] - #[case("-0d1", &[0x62, 0x03, 0x00])] - #[case("-0d3", &[0x62, 0x07, 0x00])] - #[case("-0d63", &[0x62, 0x7F, 0x00])] - #[case("-0d199", &[0x63, 0x1E, 0x03, 0x00])] - #[case("-0d-1", &[0x62, 0xFF, 0x00])] - #[case("-0d-2", &[0x62, 0xFD, 0x00])] - #[case("-0d-3", &[0x62, 0xFB, 0x00])] - #[case("-0d-63", &[0x62, 0x83, 0x00])] - #[case("-0d-64", &[0x62, 0x81, 0x00])] - #[case("-0d-65", &[0x63, 0xFE, 0xFE, 0x00])] - #[case("-0d-199", &[0x63, 0xE6, 0xFC, 0x00])] - #[case("0.01", &[0x62, 0xFD, 0x01])] - #[case("0.1", &[0x62, 0xFF, 0x01])] - #[case("1d0", &[0x62, 0x01, 0x01])] - #[case("1d1", &[0x62, 0x03, 0x01])] - #[case("1d2", &[0x62, 0x05, 0x01])] - #[case("1d63", &[0x62, 0x7F, 0x01])] - #[case("1d64", &[0x63, 0x02, 0x01, 0x01])] - #[case("1d65536", &[0x64, 0x04, 0x00, 0x08, 0x01])] - #[case("2.", &[0x62, 0x01, 0x02])] - #[case("7.", &[0x62, 0x01, 0x07])] - #[case("14d0", &[0x62, 0x01, 0x0E])] - #[case("14d0", &[0x63, 0x02, 0x00, 0x0E])] // overpadded exponent - #[case("14d0", &[0x64, 0x01, 0x0E, 0x00, 0x00])] // Overpadded coefficient - #[case("14d0", &[0x65, 0x02, 0x00, 0x0E, 0x00, 0x00])] // Overpadded coefficient and exponent - #[case("1.0", &[0x62, 0xFF, 0x0A])] - #[case("1.00", &[0x62, 0xFD, 0x64])] - #[case("1.27", &[0x62, 0xFD, 0x7F])] - #[case("1.28", &[0x63, 0xFD, 0x80, 0x00])] - #[case("3.142", &[0x63, 0xFB, 0x46, 0x0C])] - #[case("3.14159", &[0x64, 0xF7, 0x2F, 0xCB, 0x04])] - #[case("3.1415927", &[0x65, 0xF3, 0x77, 0x5E, 0xDF, 0x01])] - #[case("3.141592653", &[0x66, 0xEF, 0x4D, 0xE6, 0x40, 0xBB, 0x00])] - #[case("3.141592653590", &[0x67, 0xE9, 0x16, 0x9F, 0x83, 0x75, 0xDB, 0x02])] - #[case("3.14159265358979323", &[0x69, 0xDF, 0xFB, 0xA0, 0x9E, 0xF6, 0x2F, 0x1E, 0x5C, 0x04])] - #[case("3.1415926535897932384626", &[0x6B, 0xD5, 0x72, 0x49, 0x64, 0xCC, 0xAF, 0xEF, 0x8F, 0x0F, 0xA7, 0x06])] - #[case("3.141592653589793238462643383", &[0x6D, 0xCB, 0xB7, 0x3C, 0x92, 0x86, 0x40, 0x9F, 0x1B, 0x01, 0x1F, 0xAA, 0x26, 0x0A])] - #[case("3.14159265358979323846264338327950", &[0x6F, 0xC1, 0x8E, 0x29, 0xE5, 0xE3, 0x56, 0xD5, 0xDF, 0xC5, 0x10, 0x8F, 0x55, 0x3F, 0x7D, 0x0F])] - #[case("3.141592653589793238462643383279503", &[0xF6, 0x21, 0xBF, 0x8F, 0x9F, 0xF3, 0xE6, 0x64, 0x55, 0xBE, 0xBA, 0xA7, 0x96, 0x57, 0x79, 0xE4, 0x9A, 0x00])] + #[case("0.", &[0x70])] + #[case("0d1", &[0x71, 0x03])] + #[case("0d63", &[0x71, 0x7F])] + #[case("0d64", &[0x72, 0x02, 0x01])] + #[case("0d99", &[0x72, 0x8E, 0x01])] + #[case("0.0", &[0x71, 0xFF])] + #[case("0.00", &[0x71, 0xFD])] + #[case("0.000", &[0x71, 0xFB])] + #[case("0d-64", &[0x71, 0x81])] + #[case("0d-99", &[0x72, 0x76, 0xFE])] + #[case("-0.", &[0x72, 0x01, 0x00])] + #[case("-0d1", &[0x72, 0x03, 0x00])] + #[case("-0d3", &[0x72, 0x07, 0x00])] + #[case("-0d63", &[0x72, 0x7F, 0x00])] + #[case("-0d199", &[0x73, 0x1E, 0x03, 0x00])] + #[case("-0d-1", &[0x72, 0xFF, 0x00])] + #[case("-0d-2", &[0x72, 0xFD, 0x00])] + #[case("-0d-3", &[0x72, 0xFB, 0x00])] + #[case("-0d-63", &[0x72, 0x83, 0x00])] + #[case("-0d-64", &[0x72, 0x81, 0x00])] + #[case("-0d-65", &[0x73, 0xFE, 0xFE, 0x00])] + #[case("-0d-199", &[0x73, 0xE6, 0xFC, 0x00])] + #[case("0.01", &[0x72, 0xFD, 0x01])] + #[case("0.1", &[0x72, 0xFF, 0x01])] + #[case("1d0", &[0x72, 0x01, 0x01])] + #[case("1d1", &[0x72, 0x03, 0x01])] + #[case("1d2", &[0x72, 0x05, 0x01])] + #[case("1d63", &[0x72, 0x7F, 0x01])] + #[case("1d64", &[0x73, 0x02, 0x01, 0x01])] + #[case("1d65536", &[0x74, 0x04, 0x00, 0x08, 0x01])] + #[case("2.", &[0x72, 0x01, 0x02])] + #[case("7.", &[0x72, 0x01, 0x07])] + #[case("14d0", &[0x72, 0x01, 0x0E])] + #[case("14d0", &[0x73, 0x02, 0x00, 0x0E])] // overpadded exponent + #[case("14d0", &[0x74, 0x01, 0x0E, 0x00, 0x00])] // Overpadded coefficient + #[case("14d0", &[0x75, 0x02, 0x00, 0x0E, 0x00, 0x00])] // Overpadded coefficient and exponent + #[case("1.0", &[0x72, 0xFF, 0x0A])] + #[case("1.00", &[0x72, 0xFD, 0x64])] + #[case("1.27", &[0x72, 0xFD, 0x7F])] + #[case("1.28", &[0x73, 0xFD, 0x80, 0x00])] + #[case("3.142", &[0x73, 0xFB, 0x46, 0x0C])] + #[case("3.14159", &[0x74, 0xF7, 0x2F, 0xCB, 0x04])] + #[case("3.1415927", &[0x75, 0xF3, 0x77, 0x5E, 0xDF, 0x01])] + #[case("3.141592653", &[0x76, 0xEF, 0x4D, 0xE6, 0x40, 0xBB, 0x00])] + #[case("3.141592653590", &[0x77, 0xE9, 0x16, 0x9F, 0x83, 0x75, 0xDB, 0x02])] + #[case("3.14159265358979323", &[0x79, 0xDF, 0xFB, 0xA0, 0x9E, 0xF6, 0x2F, 0x1E, 0x5C, 0x04])] + #[case("3.1415926535897932384626", &[0x7B, 0xD5, 0x72, 0x49, 0x64, 0xCC, 0xAF, 0xEF, 0x8F, 0x0F, 0xA7, 0x06])] + #[case("3.141592653589793238462643383", &[0x7D, 0xCB, 0xB7, 0x3C, 0x92, 0x86, 0x40, 0x9F, 0x1B, 0x01, 0x1F, 0xAA, 0x26, 0x0A])] + #[case("3.14159265358979323846264338327950", &[0x7F, 0xC1, 0x8E, 0x29, 0xE5, 0xE3, 0x56, 0xD5, 0xDF, 0xC5, 0x10, 0x8F, 0x55, 0x3F, 0x7D, 0x0F])] + #[case("3.141592653589793238462643383279503", &[0xF7, 0x21, 0xBF, 0x8F, 0x9F, 0xF3, 0xE6, 0x64, 0x55, 0xBE, 0xBA, 0xA7, 0x96, 0x57, 0x79, 0xE4, 0x9A, 0x00])] fn decimals(#[case] expected_txt: &str, #[case] ion_data: &[u8]) -> IonResult<()> { use crate::lazy::decoder::{LazyRawReader, LazyRawValue}; use crate::lazy::text::raw::v1_1::reader::LazyRawTextReader_1_1; @@ -494,25 +494,25 @@ mod tests { } #[rstest] - #[case("0.", &[0xF6, 0x01])] - #[case("0d99", &[0xF6, 0x05, 0x8E, 0x01])] - #[case("0.0", &[0xF6, 0x03, 0xFF])] - #[case("0.00", &[0xF6, 0x03, 0xFD])] - #[case("0d-99", &[0xF6, 0x05, 0x76, 0xFE])] - #[case("-0.", &[0xF6, 0x05, 0x01, 0x00])] - #[case("-0d199", &[0xF6, 0x07, 0x1E, 0x03, 0x00])] - #[case("-0d-1", &[0xF6, 0x05, 0xFF, 0x00])] - #[case("-0d-65", &[0xF6, 0x07, 0xFE, 0xFE, 0x00])] - #[case("0.01", &[0xF6, 0x05, 0xFD, 0x01])] - #[case("1.", &[0xF6, 0x05, 0x01, 0x01])] - #[case("1d65536", &[0xF6, 0x09, 0x04, 0x00, 0x08, 0x01])] - #[case("1.0", &[0xF6, 0x05, 0xFF, 0x0A])] - #[case("1.28", &[0xF6, 0x07, 0xFD, 0x80, 0x00])] - #[case("3.141592653590", &[0xF6, 0x0F, 0xE9, 0x16, 0x9F, 0x83, 0x75, 0xDB, 0x02])] - #[case("3.14159265358979323", &[0xF6, 0x13, 0xDF, 0xFB, 0xA0, 0x9E, 0xF6, 0x2F, 0x1E, 0x5C, 0x04])] - #[case("3.1415926535897932384626", &[0xF6, 0x17, 0xD5, 0x72, 0x49, 0x64, 0xCC, 0xAF, 0xEF, 0x8F, 0x0F, 0xA7, 0x06])] - #[case("3.141592653589793238462643383", &[0xF6, 0x1B, 0xCB, 0xB7, 0x3C, 0x92, 0x86, 0x40, 0x9F, 0x1B, 0x01, 0x1F, 0xAA, 0x26, 0x0A])] - #[case("3.14159265358979323846264338327950", &[0xF6, 0x1F, 0xC1, 0x8E, 0x29, 0xE5, 0xE3, 0x56, 0xD5, 0xDF, 0xC5, 0x10, 0x8F, 0x55, 0x3F, 0x7D, 0x0F])] + #[case("0.", &[0xF7, 0x01])] + #[case("0d99", &[0xF7, 0x05, 0x8E, 0x01])] + #[case("0.0", &[0xF7, 0x03, 0xFF])] + #[case("0.00", &[0xF7, 0x03, 0xFD])] + #[case("0d-99", &[0xF7, 0x05, 0x76, 0xFE])] + #[case("-0.", &[0xF7, 0x05, 0x01, 0x00])] + #[case("-0d199", &[0xF7, 0x07, 0x1E, 0x03, 0x00])] + #[case("-0d-1", &[0xF7, 0x05, 0xFF, 0x00])] + #[case("-0d-65", &[0xF7, 0x07, 0xFE, 0xFE, 0x00])] + #[case("0.01", &[0xF7, 0x05, 0xFD, 0x01])] + #[case("1.", &[0xF7, 0x05, 0x01, 0x01])] + #[case("1d65536", &[0xF7, 0x09, 0x04, 0x00, 0x08, 0x01])] + #[case("1.0", &[0xF7, 0x05, 0xFF, 0x0A])] + #[case("1.28", &[0xF7, 0x07, 0xFD, 0x80, 0x00])] + #[case("3.141592653590", &[0xF7, 0x0F, 0xE9, 0x16, 0x9F, 0x83, 0x75, 0xDB, 0x02])] + #[case("3.14159265358979323", &[0xF7, 0x13, 0xDF, 0xFB, 0xA0, 0x9E, 0xF6, 0x2F, 0x1E, 0x5C, 0x04])] + #[case("3.1415926535897932384626", &[0xF7, 0x17, 0xD5, 0x72, 0x49, 0x64, 0xCC, 0xAF, 0xEF, 0x8F, 0x0F, 0xA7, 0x06])] + #[case("3.141592653589793238462643383", &[0xF7, 0x1B, 0xCB, 0xB7, 0x3C, 0x92, 0x86, 0x40, 0x9F, 0x1B, 0x01, 0x1F, 0xAA, 0x26, 0x0A])] + #[case("3.14159265358979323846264338327950", &[0xF7, 0x1F, 0xC1, 0x8E, 0x29, 0xE5, 0xE3, 0x56, 0xD5, 0xDF, 0xC5, 0x10, 0x8F, 0x55, 0x3F, 0x7D, 0x0F])] fn decimals_long(#[case] expected_txt: &str, #[case] ion_data: &[u8]) -> IonResult<()> { use crate::ion_data::IonEq; use crate::lazy::decoder::{LazyRawReader, LazyRawValue}; @@ -533,20 +533,20 @@ mod tests { } #[rstest] - #[case("2024T", &[0x70, 0x36])] - #[case("2023-10T", &[0x71, 0x35, 0x05])] - #[case("2023-10-15T", &[0x72, 0x35, 0x7D])] - #[case("2023-10-15T05:04Z", &[0x73, 0x35, 0x7D, 0x85, 0x08])] - #[case("2023-10-15T05:04:03Z", &[0x74, 0x35, 0x7D, 0x85, 0x38, 0x00])] - #[case("2023-10-15T05:04:03.123-00:00", &[0x75, 0x35, 0x7D, 0x85, 0x30, 0xEC, 0x01])] - #[case("2023-10-15T05:04:03.000123-00:00", &[0x76, 0x35, 0x7D, 0x85, 0x30, 0xEC, 0x01, 0x00])] - #[case("2023-10-15T05:04:03.000000123-00:00", &[0x77, 0x35, 0x7D, 0x85, 0x30, 0xEC, 0x01, 0x00, 0x00])] - #[case("2023-10-15T05:04+01:00", &[0x78, 0x35, 0x7D, 0x85, 0x20, 0x00])] - #[case("2023-10-15T05:04-01:00", &[0x78, 0x35, 0x7D, 0x85, 0xE0, 0x03])] - #[case("2023-10-15T05:04:03+01:00", &[0x79, 0x35, 0x7D, 0x85, 0x20, 0x0C])] - #[case("2023-10-15T05:04:03.123+01:00", &[0x7A, 0x35, 0x7D, 0x85, 0x20, 0x0C, 0x7B, 0x00])] - #[case("2023-10-15T05:04:03.000123+01:00", &[0x7B, 0x35, 0x7D, 0x85, 0x20, 0x0C, 0x7B, 0x00, 0x00])] - #[case("2023-10-15T05:04:03.000000123+01:00", &[0x7C, 0x35, 0x7D, 0x85, 0x20, 0x0C, 0x7B, 0x00, 0x00, 0x00])] + #[case("2024T", &[0x80, 0x36])] + #[case("2023-10T", &[0x81, 0x35, 0x05])] + #[case("2023-10-15T", &[0x82, 0x35, 0x7D])] + #[case("2023-10-15T05:04Z", &[0x83, 0x35, 0x7D, 0x85, 0x08])] + #[case("2023-10-15T05:04:03Z", &[0x84, 0x35, 0x7D, 0x85, 0x38, 0x00])] + #[case("2023-10-15T05:04:03.123-00:00", &[0x85, 0x35, 0x7D, 0x85, 0x30, 0xEC, 0x01])] + #[case("2023-10-15T05:04:03.000123-00:00", &[0x86, 0x35, 0x7D, 0x85, 0x30, 0xEC, 0x01, 0x00])] + #[case("2023-10-15T05:04:03.000000123-00:00", &[0x87, 0x35, 0x7D, 0x85, 0x30, 0xEC, 0x01, 0x00, 0x00])] + #[case("2023-10-15T05:04+01:00", &[0x88, 0x35, 0x7D, 0x85, 0x20, 0x00])] + #[case("2023-10-15T05:04-01:00", &[0x88, 0x35, 0x7D, 0x85, 0xE0, 0x03])] + #[case("2023-10-15T05:04:03+01:00", &[0x89, 0x35, 0x7D, 0x85, 0x20, 0x0C])] + #[case("2023-10-15T05:04:03.123+01:00", &[0x8A, 0x35, 0x7D, 0x85, 0x20, 0x0C, 0x7B, 0x00])] + #[case("2023-10-15T05:04:03.000123+01:00", &[0x8B, 0x35, 0x7D, 0x85, 0x20, 0x0C, 0x7B, 0x00, 0x00])] + #[case("2023-10-15T05:04:03.000000123+01:00", &[0x8C, 0x35, 0x7D, 0x85, 0x20, 0x0C, 0x7B, 0x00, 0x00, 0x00])] fn timestamps_short(#[case] expected_txt: &str, #[case] ion_data: &[u8]) -> IonResult<()> { use crate::lazy::decoder::{LazyRawReader, LazyRawValue}; use crate::lazy::text::raw::v1_1::reader::LazyRawTextReader_1_1; @@ -572,13 +572,13 @@ mod tests { } #[rstest] - #[case("1947T", &[0xF7, 0x05, 0x9B, 0x07])] - #[case("1947-12T", &[0xF7, 0x07, 0x9B, 0x07, 0x03])] - #[case("1947-12-23T", &[0xF7, 0x07, 0x9B, 0x07, 0x5F])] - #[case("1947-12-23T11:22-00:00", &[0xF7, 0x0D, 0x9B, 0x07, 0xDF, 0x65, 0xFD, 0x3F])] - #[case("1947-12-23T11:22:33+01:00", &[0xF7, 0x0F, 0x9B, 0x07, 0xDF, 0x65, 0x71, 0x57, 0x08])] - #[case("1947-12-23T11:22:33.127+01:15", &[0xF7, 0x13, 0x9B, 0x07, 0xDF, 0x65, 0xAD, 0x57, 0x08, 0x07, 0x7F])] - #[case("1947-12-23T11:22:33-01:00", &[0xF7, 0x0F, 0x9B, 0x07, 0xDF, 0x65, 0x91, 0x55, 0x08])] + #[case("1947T", &[0xF8, 0x05, 0x9B, 0x07])] + #[case("1947-12T", &[0xF8, 0x07, 0x9B, 0x07, 0x03])] + #[case("1947-12-23T", &[0xF8, 0x07, 0x9B, 0x07, 0x5F])] + #[case("1947-12-23T11:22-00:00", &[0xF8, 0x0D, 0x9B, 0x07, 0xDF, 0x65, 0xFD, 0x3F])] + #[case("1947-12-23T11:22:33+01:00", &[0xF8, 0x0F, 0x9B, 0x07, 0xDF, 0x65, 0x71, 0x57, 0x08])] + #[case("1947-12-23T11:22:33.127+01:15", &[0xF8, 0x13, 0x9B, 0x07, 0xDF, 0x65, 0xAD, 0x57, 0x08, 0x07, 0x7F])] + #[case("1947-12-23T11:22:33-01:00", &[0xF8, 0x0F, 0x9B, 0x07, 0xDF, 0x65, 0x91, 0x55, 0x08])] fn timestamps_long(#[case] expected_txt: &str, #[case] ion_data: &[u8]) -> IonResult<()> { use crate::lazy::decoder::{LazyRawReader, LazyRawValue}; use crate::lazy::text::raw::v1_1::reader::LazyRawTextReader_1_1; @@ -650,48 +650,48 @@ mod tests { #[rustfmt::skip] let tests: &[(&[u8], &[IonType])] = &[ // [] - (&[0xA0], &[]), + (&[0xB0], &[]), // [null.null] - (&[0xA1, 0xEA], &[IonType::Null]), + (&[0xB1, 0xEA], &[IonType::Null]), // [''] - (&[0xA1, 0x90], &[IonType::Symbol]), + (&[0xB1, 0xA0], &[IonType::Symbol]), // ["hello"] ( - &[0xA6, 0x85, 0x68, 0x65, 0x6C, 0x6C, 0x6F], + &[0xB6, 0x95, 0x68, 0x65, 0x6C, 0x6C, 0x6F], &[IonType::String], ), // [null.null, '', "hello"] ( - &[0xA8, 0xEA, 0x90, 0x85, 0x68, 0x65, 0x6C, 0x6c, 0x6F], + &[0xB8, 0xEA, 0xA0, 0x95, 0x68, 0x65, 0x6C, 0x6c, 0x6F], &[IonType::Null, IonType::Symbol, IonType::String], ), // [3.1415927e0 3.1415927e0] ( - &[0xAA, 0x5C, 0xDB, 0x0F, 0x49, 0x40, 0x5C, 0xDB, 0x0F, 0x49, 0x40], + &[0xBA, 0x6C, 0xDB, 0x0F, 0x49, 0x40, 0x6C, 0xDB, 0x0F, 0x49, 0x40], &[IonType::Float, IonType::Float] ), // Long List Encoding // [] - (&[0xFA, 0x01], &[]), + (&[0xFB, 0x01], &[]), // ["variable length list"] ( &[ - 0xFA, 0x2D, 0xF8, 0x29, 0x76, 0x61, 0x72, 0x69, 0x61, 0x62, 0x6C, 0x65, + 0xFB, 0x2D, 0xF9, 0x29, 0x76, 0x61, 0x72, 0x69, 0x61, 0x62, 0x6C, 0x65, 0x20, 0x6C, 0x65, 0x6E, 0x67, 0x74, 0x68, 0x20, 0x6C, 0x69, 0x73, 0x74, ], &[IonType::String] ), // [] - (&[0xFA, 0x03, 0xEC], &[]), + (&[0xFB, 0x03, 0xEC], &[]), ]; for (ion_data, expected_types) in tests { @@ -716,33 +716,33 @@ mod tests { #[rustfmt::skip] let tests: &[(&[u8], &[IonType])] = &[ // () - (&[0xB0], &[]), + (&[0xC0], &[]), // (1 2 3) ( - &[0xB6, 0x51, 0x01, 0x51, 0x02, 0x51, 0x03], + &[0xC6, 0x61, 0x01, 0x61, 0x02, 0x61, 0x03], &[IonType::Int, IonType::Int, IonType::Int], ), // Long S-Expression Encoding // () - (&[0xFB, 0x01], &[]), + (&[0xFC, 0x01], &[]), // ("variable length sexp") ( &[ - 0xFB, 0x2D, 0xF8, 0x29, 0x76, 0x61, 0x72, 0x69, 0x61, 0x62, 0x6C, 0x65, 0x20, + 0xFC, 0x2D, 0xF9, 0x29, 0x76, 0x61, 0x72, 0x69, 0x61, 0x62, 0x6C, 0x65, 0x20, 0x6C, 0x65, 0x6E, 0x67, 0x74, 0x68, 0x20, 0x73, 0x65, 0x78, 0x70 ], &[IonType::String] ), // ( () () [] ) - (&[0xFB, 0x09, 0xFB, 0x01, 0xB0, 0xA0], &[IonType::SExp, IonType::SExp, IonType::List]), + (&[0xFC, 0x09, 0xFC, 0x01, 0xC0, 0xB0], &[IonType::SExp, IonType::SExp, IonType::List]), // ( $257 ) - (&[0xFB, 0x07, 0xE2, 0x01, 0x00], &[IonType::Symbol]), + (&[0xFC, 0x07, 0xE2, 0x01, 0x00], &[IonType::Symbol]), ]; for (ion_data, expected_types) in tests { @@ -795,12 +795,12 @@ mod tests { // Symbol Address ( // {} - &[0xC0], + &[0xD0], &[], ), ( // { $10: 1, $11: 2 } - &[0xC6, 0x15, 0x51, 0x01, 0x17, 0x51, 0x02], + &[0xD6, 0x15, 0x61, 0x01, 0x17, 0x61, 0x02], &[ (10usize.into(), IonType::Int), (11usize.into(), IonType::Int), @@ -808,7 +808,7 @@ mod tests { ), ( // { $10: '', $11: 0e0 } - &[0xC4, 0x15, 0x90, 0x17, 0x5A], + &[0xD4, 0x15, 0xA0, 0x17, 0x6A], &[ (10usize.into(), IonType::Symbol), (11usize.into(), IonType::Float), @@ -816,21 +816,21 @@ mod tests { ), ( // { $10: , $11: 0e0 } - with nops, skip the NOP'd fields. - &[ 0xC4, 0x15, 0xEC, 0x17, 0x5A ], + &[ 0xD4, 0x15, 0xEC, 0x17, 0x6A ], &[ (11usize.into(), IonType::Float), ], ), ( // { $10: 1, $11: } - with nops at end of struct. - &[ 0xC5, 0x15, 0x51, 0x01, 0x17, 0xEC ], + &[ 0xD5, 0x15, 0x61, 0x01, 0x17, 0xEC ], &[ (10usize.into(), IonType::Int), ], ), ( // { $10: { $11: "foo" }, $11: 2 } - &[ 0xC6, 0x15, 0xC4, 0x83, 0x66, 0x6F, 0x6F, 0x17, 0x51, 0x02 ], + &[ 0xD6, 0x15, 0xC4, 0x93, 0x66, 0x6F, 0x6F, 0x17, 0x61, 0x02 ], &[ (10usize.into(), IonType::Struct), (11usize.into(), IonType::Int), @@ -838,13 +838,13 @@ mod tests { ), ( // {} - &[ 0xFC, 0x01 ], + &[ 0xFD, 0x01 ], &[], ), ( // { $10: "variable length struct" } &[ - 0xFC, 0x33, 0x15, 0xF8, 0x2D, 0x76, 0x61, 0x72, 0x69, 0x61, + 0xFD, 0x33, 0x15, 0xF9, 0x2D, 0x76, 0x61, 0x72, 0x69, 0x61, 0x62, 0x6C, 0x65, 0x20, 0x6c, 0x65, 0x6E, 0x67, 0x74, 0x68, 0x20, 0x73, 0x74, 0x72, 0x75, 0x63, 0x74 ], @@ -853,29 +853,29 @@ mod tests { // FlexSym ( // { "foo": 1, $11: 2 } - &[ 0xD9, 0xFB, 0x66, 0x6F, 0x6F, 0x51, 0x01, 0x17, 0x91, 0x02], - &[ ("foo".into(), IonType::Int), (11usize.into(), IonType::Symbol)], + &[ 0xD9, 0xFB, 0x66, 0x6F, 0x6F, 0x61, 0x01, 0x17, 0x61, 0x02], + &[ ("foo".into(), IonType::Int), (11usize.into(), IonType::Int)], ), ( // { "foo": 1, $11: 2 } - &[ 0xFD, 0x13, 0xFB, 0x66, 0x6F, 0x6F, 0x51, 0x01, 0x17, 0x91, 0x02], - &[ ("foo".into(), IonType::Int), (11usize.into(), IonType::Symbol)], + &[ 0xFD, 0x13, 0xFB, 0x66, 0x6F, 0x6F, 0x61, 0x01, 0x17, 0x61, 0x02], + &[ ("foo".into(), IonType::Int), (11usize.into(), IonType::Int)], ), ( // { "foo": , $11: 2 } - &[ 0xFD, 0x11, 0xFB, 0x66, 0x6F, 0x6F, 0xEC, 0x17, 0x91, 0x02], - &[ (11usize.into(), IonType::Symbol) ], + &[ 0xFD, 0x11, 0xFB, 0x66, 0x6F, 0x6F, 0xEC, 0x17, 0x61, 0x02], + &[ (11usize.into(), IonType::Int) ], ), ( // { "foo": 2, $11: } - &[ 0xFD, 0x11, 0xFB, 0x66, 0x6F, 0x6F, 0x51, 0x02, 0x17, 0xEC], + &[ 0xFD, 0x11, 0xFB, 0x66, 0x6F, 0x6F, 0x61, 0x02, 0x17, 0xEC], &[ ("foo".into(), IonType::Int) ], ), ( // { "foo": { $10: 2 }, "bar": 2 } &[ - 0xFD, 0x1D, 0xFB, 0x66, 0x6F, 0x6F, 0xC3, 0x15, 0x51, 0x02, - 0xFB, 0x62, 0x61, 0x72, 0x51, 0x02, + 0xFD, 0x1D, 0xFB, 0x66, 0x6F, 0x6F, 0xD3, 0x15, 0x61, 0x02, + 0xFB, 0x62, 0x61, 0x72, 0x61, 0x02, ], &[ ("foo".into(), IonType::Struct), diff --git a/src/lazy/binary/raw/v1_1/struct.rs b/src/lazy/binary/raw/v1_1/struct.rs index 5a84374f..8e7dec19 100644 --- a/src/lazy/binary/raw/v1_1/struct.rs +++ b/src/lazy/binary/raw/v1_1/struct.rs @@ -139,8 +139,8 @@ impl<'top> RawBinaryStructIterator_1_1<'top> { source: input, bytes_to_skip: 0, struct_type: match opcode_type { - OpcodeType::StructSymAddress => StructType::SymbolAddress, - OpcodeType::StructFlexSym => StructType::FlexSym, + // TODO: Delimited struct handling + OpcodeType::Struct => StructType::FlexSym, _ => unreachable!("Unexpected opcode for structure"), }, } diff --git a/src/lazy/binary/raw/v1_1/type_code.rs b/src/lazy/binary/raw/v1_1/type_code.rs index b238bf46..41c44a2c 100644 --- a/src/lazy/binary/raw/v1_1/type_code.rs +++ b/src/lazy/binary/raw/v1_1/type_code.rs @@ -15,20 +15,18 @@ use crate::IonType; pub enum OpcodeType { EExpressionWithAddress, // 0x00-0x4F - EExpressionAddressFollows, // 0x40-0x4F - - Integer, // 0x50-0x58 - Integer up to 8 bytes wide - Float, // 0x5A-0x5D - - Boolean, // 0x5E-0x5F - - Decimal, // 0x60-0x6F - - TimestampShort, // 0x70-0x7F - - String, // 0x80-0x80 - - InlineSymbol, // 0x90-0x9F - - List, // 0xA0-0xAF - - SExpression, // 0xB0-0xBF - - StructEmpty, // 0xC0 - - // reserved - StructSymAddress, // 0xC2-0xCF - - // reserved - StructFlexSym, // 0xD2-0xDF - + Integer, // 0x60-0x68 - Integer up to 8 bytes wide + Float, // 0x6A-0x6D - + Boolean, // 0x6E-0x6F - + Decimal, // 0x70-0x7F - + TimestampShort, // 0x80-0x8F - + String, // 0x90-0x9F - + InlineSymbol, // 0xA0-0xAF - + List, // 0xB0-0xBF - + SExpression, // 0xC0-0xCF - + StructEmpty, // 0xD0 - + // 0xD1 reserved + Struct, // 0xD2-0xDF - IonVersionMarker, // 0xE0 - SymbolAddress, // 0xE1-0xE3 - @@ -39,14 +37,21 @@ pub enum OpcodeType { Nop, // 0xEC-0xED - // Reserved SystemMacroInvoke, // 0xEF - - // delimited container end - // delimited list start - // delimited s-expression start - LargeInteger, // 0xF5 - Integer preceeded by FlexUInt length - Blob, // 0xFE - - Clob, // 0xFF - - TimestampLong, // 0xF7 - Long-form Timestamp - Invalid, // Represents an encoded value that does not match a defined opcode. + // 0xF0 delimited container end + // 0xF1 delimited list start + // 0xF2 delimited s-expression start + // 0xF3 delimited struct start + LargeInteger, // 0xF6 - Integer preceded by FlexUInt length + Blob, // 0xFE - + Clob, // 0xFF - + // 0xF8 Long decimal + TimestampLong, // 0xF8 - Long-form Timestamp + // 0xF9 - Long string + // 0xFA - FlexSym symbol + // 0xFB - Long list + // 0xFC - Long sexp + // 0xFD - Long struct + Invalid, // Represents an encoded value that does not match a defined opcode. } impl TryFrom for IonType { diff --git a/src/lazy/binary/raw/v1_1/type_descriptor.rs b/src/lazy/binary/raw/v1_1/type_descriptor.rs index f8aa6f26..3e2fec3a 100644 --- a/src/lazy/binary/raw/v1_1/type_descriptor.rs +++ b/src/lazy/binary/raw/v1_1/type_descriptor.rs @@ -56,33 +56,31 @@ impl Opcode { use OpcodeType::*; let (opcode_type, length_code, ion_type) = match (high_nibble, low_nibble) { - (0x5, 0x0..=0x8) => (Integer, low_nibble, Some(IonType::Int)), - (0x5, 0xA..=0xD) => (Float, low_nibble, Some(IonType::Float)), - (0x5, 0xE..=0xF) => (Boolean, low_nibble, Some(IonType::Bool)), - (0x6, _) => (Decimal, low_nibble, Some(IonType::Decimal)), - (0x7, 0x0..=0xC) => (TimestampShort, low_nibble, Some(IonType::Timestamp)), - (0x8, _) => (String, low_nibble, Some(IonType::String)), - (0x9, _) => (InlineSymbol, low_nibble, Some(IonType::Symbol)), - (0xA, _) => (List, low_nibble, Some(IonType::List)), - (0xB, _) => (SExpression, low_nibble, Some(IonType::SExp)), - (0xC, _) => (StructSymAddress, low_nibble, Some(IonType::Struct)), - (0xD, _) => (StructFlexSym, low_nibble, Some(IonType::Struct)), + (0x6, 0x0..=0x8) => (Integer, low_nibble, Some(IonType::Int)), + (0x6, 0xA..=0xD) => (Float, low_nibble, Some(IonType::Float)), + (0x6, 0xE..=0xF) => (Boolean, low_nibble, Some(IonType::Bool)), + (0x7, _) => (Decimal, low_nibble, Some(IonType::Decimal)), + (0x8, 0x0..=0xC) => (TimestampShort, low_nibble, Some(IonType::Timestamp)), + (0x9, _) => (String, low_nibble, Some(IonType::String)), + (0xA, _) => (InlineSymbol, low_nibble, Some(IonType::Symbol)), + (0xB, _) => (List, low_nibble, Some(IonType::List)), + (0xC, _) => (SExpression, low_nibble, Some(IonType::SExp)), + (0xD, _) => (Struct, low_nibble, Some(IonType::Struct)), (0xE, 0x0) => (IonVersionMarker, low_nibble, None), (0xE, 0x1..=0x3) => (SymbolAddress, low_nibble, Some(IonType::Symbol)), (0xE, 0xA) => (NullNull, low_nibble, Some(IonType::Null)), (0xE, 0xB) => (TypedNull, low_nibble, Some(IonType::Null)), (0xE, 0xC..=0xD) => (Nop, low_nibble, None), - (0xF, 0x5) => (LargeInteger, low_nibble, Some(IonType::Int)), - (0xF, 0x6) => (Decimal, 0xFF, Some(IonType::Decimal)), - (0xF, 0x8) => (String, 0xFF, Some(IonType::String)), // 0xFF indicates >15 byte string. - (0xF, 0x9) => (InlineSymbol, 0xFF, Some(IonType::Symbol)), - (0xF, 0xA) => (List, 0xFF, Some(IonType::List)), - (0xF, 0xB) => (SExpression, 0xFF, Some(IonType::SExp)), - (0xF, 0xC) => (StructSymAddress, 0xFF, Some(IonType::Struct)), - (0xF, 0xD) => (StructFlexSym, 0xFF, Some(IonType::Struct)), + (0xF, 0x6) => (LargeInteger, low_nibble, Some(IonType::Int)), + (0xF, 0x7) => (Decimal, 0xFF, Some(IonType::Decimal)), + (0xF, 0x8) => (TimestampLong, low_nibble, Some(IonType::Timestamp)), + (0xF, 0x9) => (String, 0xFF, Some(IonType::String)), // 0xFF indicates >15 byte string. + (0xF, 0xA) => (InlineSymbol, 0xFF, Some(IonType::Symbol)), + (0xF, 0xB) => (List, 0xFF, Some(IonType::List)), + (0xF, 0xC) => (SExpression, 0xFF, Some(IonType::SExp)), + (0xF, 0xD) => (Struct, 0xFF, Some(IonType::Struct)), (0xF, 0xE) => (Blob, low_nibble, Some(IonType::Blob)), (0xF, 0xF) => (Clob, low_nibble, Some(IonType::Clob)), - (0xF, 0x7) => (TimestampLong, low_nibble, Some(IonType::Timestamp)), _ => (Invalid, low_nibble, None), }; Opcode { @@ -159,8 +157,7 @@ impl Header { InOpcode(ION_1_1_TIMESTAMP_SHORT_SIZE[self.length_code as usize]) } (OpcodeType::TypedNull, _) => InOpcode(1), - (OpcodeType::StructSymAddress, n) if n < 16 => InOpcode(n), - (OpcodeType::StructFlexSym, n) if n < 16 => InOpcode(n), + (OpcodeType::Struct, n) if n < 16 => InOpcode(n), _ => FlexUIntFollows, } } diff --git a/src/lazy/binary/raw/v1_1/value.rs b/src/lazy/binary/raw/v1_1/value.rs index 9b6e38ff..bde44125 100644 --- a/src/lazy/binary/raw/v1_1/value.rs +++ b/src/lazy/binary/raw/v1_1/value.rs @@ -268,7 +268,7 @@ impl<'top> LazyRawBinaryValue_1_1<'top> { // We have n bytes following that make up our integer. self.input.consume(1).read_fixed_int(n)?.0.into() } - (OpcodeType::LargeInteger, 0x5) => { + (OpcodeType::LargeInteger, 0x6) => { // We have a FlexUInt size, then big int. let value_bytes = self.value_body()?; FixedInt::read(value_bytes, value_bytes.len(), 0)?.into()