| use crate::error::{Error, ErrorCode, Result}; |
| use alloc::vec::Vec; |
| use core::char; |
| use core::cmp; |
| use core::mem; |
| use core::ops::Deref; |
| use core::str; |
| |
| #[cfg(feature = "std")] |
| use crate::io; |
| #[cfg(feature = "std")] |
| use crate::iter::LineColIterator; |
| |
| #[cfg(feature = "raw_value")] |
| use crate::raw::BorrowedRawDeserializer; |
| #[cfg(all(feature = "raw_value", feature = "std"))] |
| use crate::raw::OwnedRawDeserializer; |
| #[cfg(all(feature = "raw_value", feature = "std"))] |
| use alloc::string::String; |
| #[cfg(feature = "raw_value")] |
| use serde::de::Visitor; |
| |
| /// Trait used by the deserializer for iterating over input. This is manually |
| /// "specialized" for iterating over `&[u8]`. Once feature(specialization) is |
| /// stable we can use actual specialization. |
| /// |
| /// This trait is sealed and cannot be implemented for types outside of |
| /// `serde_json`. |
| pub trait Read<'de>: private::Sealed { |
| #[doc(hidden)] |
| fn next(&mut self) -> Result<Option<u8>>; |
| #[doc(hidden)] |
| fn peek(&mut self) -> Result<Option<u8>>; |
| |
| /// Only valid after a call to peek(). Discards the peeked byte. |
| #[doc(hidden)] |
| fn discard(&mut self); |
| |
| /// Position of the most recent call to next(). |
| /// |
| /// The most recent call was probably next() and not peek(), but this method |
| /// should try to return a sensible result if the most recent call was |
| /// actually peek() because we don't always know. |
| /// |
| /// Only called in case of an error, so performance is not important. |
| #[doc(hidden)] |
| fn position(&self) -> Position; |
| |
| /// Position of the most recent call to peek(). |
| /// |
| /// The most recent call was probably peek() and not next(), but this method |
| /// should try to return a sensible result if the most recent call was |
| /// actually next() because we don't always know. |
| /// |
| /// Only called in case of an error, so performance is not important. |
| #[doc(hidden)] |
| fn peek_position(&self) -> Position; |
| |
| /// Offset from the beginning of the input to the next byte that would be |
| /// returned by next() or peek(). |
| #[doc(hidden)] |
| fn byte_offset(&self) -> usize; |
| |
| /// Assumes the previous byte was a quotation mark. Parses a JSON-escaped |
| /// string until the next quotation mark using the given scratch space if |
| /// necessary. The scratch space is initially empty. |
| #[doc(hidden)] |
| fn parse_str<'s>(&'s mut self, scratch: &'s mut Vec<u8>) -> Result<Reference<'de, 's, str>>; |
| |
| /// Assumes the previous byte was a quotation mark. Parses a JSON-escaped |
| /// string until the next quotation mark using the given scratch space if |
| /// necessary. The scratch space is initially empty. |
| /// |
| /// This function returns the raw bytes in the string with escape sequences |
| /// expanded but without performing unicode validation. |
| #[doc(hidden)] |
| fn parse_str_raw<'s>( |
| &'s mut self, |
| scratch: &'s mut Vec<u8>, |
| ) -> Result<Reference<'de, 's, [u8]>>; |
| |
| /// Assumes the previous byte was a quotation mark. Parses a JSON-escaped |
| /// string until the next quotation mark but discards the data. |
| #[doc(hidden)] |
| fn ignore_str(&mut self) -> Result<()>; |
| |
| /// Assumes the previous byte was a hex escape sequence ('\u') in a string. |
| /// Parses next hexadecimal sequence. |
| #[doc(hidden)] |
| fn decode_hex_escape(&mut self) -> Result<u16>; |
| |
| /// Switch raw buffering mode on. |
| /// |
| /// This is used when deserializing `RawValue`. |
| #[cfg(feature = "raw_value")] |
| #[doc(hidden)] |
| fn begin_raw_buffering(&mut self); |
| |
| /// Switch raw buffering mode off and provides the raw buffered data to the |
| /// given visitor. |
| #[cfg(feature = "raw_value")] |
| #[doc(hidden)] |
| fn end_raw_buffering<V>(&mut self, visitor: V) -> Result<V::Value> |
| where |
| V: Visitor<'de>; |
| |
| /// Whether StreamDeserializer::next needs to check the failed flag. True |
| /// for IoRead, false for StrRead and SliceRead which can track failure by |
| /// truncating their input slice to avoid the extra check on every next |
| /// call. |
| #[doc(hidden)] |
| const should_early_return_if_failed: bool; |
| |
| /// Mark a persistent failure of StreamDeserializer, either by setting the |
| /// flag or by truncating the input data. |
| #[doc(hidden)] |
| fn set_failed(&mut self, failed: &mut bool); |
| } |
| |
| pub struct Position { |
| pub line: usize, |
| pub column: usize, |
| } |
| |
| pub enum Reference<'b, 'c, T> |
| where |
| T: ?Sized + 'static, |
| { |
| Borrowed(&'b T), |
| Copied(&'c T), |
| } |
| |
| impl<'b, 'c, T> Deref for Reference<'b, 'c, T> |
| where |
| T: ?Sized + 'static, |
| { |
| type Target = T; |
| |
| fn deref(&self) -> &Self::Target { |
| match *self { |
| Reference::Borrowed(b) => b, |
| Reference::Copied(c) => c, |
| } |
| } |
| } |
| |
| /// JSON input source that reads from a std::io input stream. |
| #[cfg(feature = "std")] |
| #[cfg_attr(docsrs, doc(cfg(feature = "std")))] |
| pub struct IoRead<R> |
| where |
| R: io::Read, |
| { |
| iter: LineColIterator<io::Bytes<R>>, |
| /// Temporary storage of peeked byte. |
| ch: Option<u8>, |
| #[cfg(feature = "raw_value")] |
| raw_buffer: Option<Vec<u8>>, |
| } |
| |
| /// JSON input source that reads from a slice of bytes. |
| // |
| // This is more efficient than other iterators because peek() can be read-only |
| // and we can compute line/col position only if an error happens. |
| pub struct SliceRead<'a> { |
| slice: &'a [u8], |
| /// Index of the *next* byte that will be returned by next() or peek(). |
| index: usize, |
| #[cfg(feature = "raw_value")] |
| raw_buffering_start_index: usize, |
| } |
| |
| /// JSON input source that reads from a UTF-8 string. |
| // |
| // Able to elide UTF-8 checks by assuming that the input is valid UTF-8. |
| pub struct StrRead<'a> { |
| delegate: SliceRead<'a>, |
| #[cfg(feature = "raw_value")] |
| data: &'a str, |
| } |
| |
| // Prevent users from implementing the Read trait. |
| mod private { |
| pub trait Sealed {} |
| } |
| |
| ////////////////////////////////////////////////////////////////////////////// |
| |
| #[cfg(feature = "std")] |
| impl<R> IoRead<R> |
| where |
| R: io::Read, |
| { |
| /// Create a JSON input source to read from a std::io input stream. |
| pub fn new(reader: R) -> Self { |
| IoRead { |
| iter: LineColIterator::new(reader.bytes()), |
| ch: None, |
| #[cfg(feature = "raw_value")] |
| raw_buffer: None, |
| } |
| } |
| } |
| |
| #[cfg(feature = "std")] |
| impl<R> private::Sealed for IoRead<R> where R: io::Read {} |
| |
| #[cfg(feature = "std")] |
| impl<R> IoRead<R> |
| where |
| R: io::Read, |
| { |
| fn parse_str_bytes<'s, T, F>( |
| &'s mut self, |
| scratch: &'s mut Vec<u8>, |
| validate: bool, |
| result: F, |
| ) -> Result<T> |
| where |
| T: 's, |
| F: FnOnce(&'s Self, &'s [u8]) -> Result<T>, |
| { |
| loop { |
| let ch = tri!(next_or_eof(self)); |
| if !is_escape(ch, true) { |
| scratch.push(ch); |
| continue; |
| } |
| match ch { |
| b'"' => { |
| return result(self, scratch); |
| } |
| b'\\' => { |
| tri!(parse_escape(self, validate, scratch)); |
| } |
| _ => { |
| if validate { |
| return error(self, ErrorCode::ControlCharacterWhileParsingString); |
| } |
| scratch.push(ch); |
| } |
| } |
| } |
| } |
| } |
| |
| #[cfg(feature = "std")] |
| impl<'de, R> Read<'de> for IoRead<R> |
| where |
| R: io::Read, |
| { |
| #[inline] |
| fn next(&mut self) -> Result<Option<u8>> { |
| match self.ch.take() { |
| Some(ch) => { |
| #[cfg(feature = "raw_value")] |
| { |
| if let Some(buf) = &mut self.raw_buffer { |
| buf.push(ch); |
| } |
| } |
| Ok(Some(ch)) |
| } |
| None => match self.iter.next() { |
| Some(Err(err)) => Err(Error::io(err)), |
| Some(Ok(ch)) => { |
| #[cfg(feature = "raw_value")] |
| { |
| if let Some(buf) = &mut self.raw_buffer { |
| buf.push(ch); |
| } |
| } |
| Ok(Some(ch)) |
| } |
| None => Ok(None), |
| }, |
| } |
| } |
| |
| #[inline] |
| fn peek(&mut self) -> Result<Option<u8>> { |
| match self.ch { |
| Some(ch) => Ok(Some(ch)), |
| None => match self.iter.next() { |
| Some(Err(err)) => Err(Error::io(err)), |
| Some(Ok(ch)) => { |
| self.ch = Some(ch); |
| Ok(self.ch) |
| } |
| None => Ok(None), |
| }, |
| } |
| } |
| |
| #[cfg(not(feature = "raw_value"))] |
| #[inline] |
| fn discard(&mut self) { |
| self.ch = None; |
| } |
| |
| #[cfg(feature = "raw_value")] |
| fn discard(&mut self) { |
| if let Some(ch) = self.ch.take() { |
| if let Some(buf) = &mut self.raw_buffer { |
| buf.push(ch); |
| } |
| } |
| } |
| |
| fn position(&self) -> Position { |
| Position { |
| line: self.iter.line(), |
| column: self.iter.col(), |
| } |
| } |
| |
| fn peek_position(&self) -> Position { |
| // The LineColIterator updates its position during peek() so it has the |
| // right one here. |
| self.position() |
| } |
| |
| fn byte_offset(&self) -> usize { |
| match self.ch { |
| Some(_) => self.iter.byte_offset() - 1, |
| None => self.iter.byte_offset(), |
| } |
| } |
| |
| fn parse_str<'s>(&'s mut self, scratch: &'s mut Vec<u8>) -> Result<Reference<'de, 's, str>> { |
| self.parse_str_bytes(scratch, true, as_str) |
| .map(Reference::Copied) |
| } |
| |
| fn parse_str_raw<'s>( |
| &'s mut self, |
| scratch: &'s mut Vec<u8>, |
| ) -> Result<Reference<'de, 's, [u8]>> { |
| self.parse_str_bytes(scratch, false, |_, bytes| Ok(bytes)) |
| .map(Reference::Copied) |
| } |
| |
| fn ignore_str(&mut self) -> Result<()> { |
| loop { |
| let ch = tri!(next_or_eof(self)); |
| if !is_escape(ch, true) { |
| continue; |
| } |
| match ch { |
| b'"' => { |
| return Ok(()); |
| } |
| b'\\' => { |
| tri!(ignore_escape(self)); |
| } |
| _ => { |
| return error(self, ErrorCode::ControlCharacterWhileParsingString); |
| } |
| } |
| } |
| } |
| |
| fn decode_hex_escape(&mut self) -> Result<u16> { |
| let mut n = 0; |
| for _ in 0..4 { |
| match decode_hex_val(tri!(next_or_eof(self))) { |
| None => return error(self, ErrorCode::InvalidEscape), |
| Some(val) => { |
| n = (n << 4) + val; |
| } |
| } |
| } |
| Ok(n) |
| } |
| |
| #[cfg(feature = "raw_value")] |
| fn begin_raw_buffering(&mut self) { |
| self.raw_buffer = Some(Vec::new()); |
| } |
| |
| #[cfg(feature = "raw_value")] |
| fn end_raw_buffering<V>(&mut self, visitor: V) -> Result<V::Value> |
| where |
| V: Visitor<'de>, |
| { |
| let raw = self.raw_buffer.take().unwrap(); |
| let raw = match String::from_utf8(raw) { |
| Ok(raw) => raw, |
| Err(_) => return error(self, ErrorCode::InvalidUnicodeCodePoint), |
| }; |
| visitor.visit_map(OwnedRawDeserializer { |
| raw_value: Some(raw), |
| }) |
| } |
| |
| const should_early_return_if_failed: bool = true; |
| |
| #[inline] |
| #[cold] |
| fn set_failed(&mut self, failed: &mut bool) { |
| *failed = true; |
| } |
| } |
| |
| ////////////////////////////////////////////////////////////////////////////// |
| |
| impl<'a> SliceRead<'a> { |
| /// Create a JSON input source to read from a slice of bytes. |
| pub fn new(slice: &'a [u8]) -> Self { |
| SliceRead { |
| slice, |
| index: 0, |
| #[cfg(feature = "raw_value")] |
| raw_buffering_start_index: 0, |
| } |
| } |
| |
| fn position_of_index(&self, i: usize) -> Position { |
| let start_of_line = match memchr::memrchr(b'\n', &self.slice[..i]) { |
| Some(position) => position + 1, |
| None => 0, |
| }; |
| Position { |
| line: 1 + memchr::memchr_iter(b'\n', &self.slice[..start_of_line]).count(), |
| column: i - start_of_line, |
| } |
| } |
| |
| fn skip_to_escape(&mut self, forbid_control_characters: bool) { |
| // Immediately bail-out on empty strings and consecutive escapes (e.g. \u041b\u0435) |
| if self.index == self.slice.len() |
| || is_escape(self.slice[self.index], forbid_control_characters) |
| { |
| return; |
| } |
| self.index += 1; |
| |
| let rest = &self.slice[self.index..]; |
| |
| if !forbid_control_characters { |
| self.index += memchr::memchr2(b'"', b'\\', rest).unwrap_or(rest.len()); |
| return; |
| } |
| |
| // We wish to find the first byte in range 0x00..=0x1F or " or \. Ideally, we'd use |
| // something akin to memchr3, but the memchr crate does not support this at the moment. |
| // Therefore, we use a variation on Mycroft's algorithm [1] to provide performance better |
| // than a naive loop. It runs faster than equivalent two-pass memchr2+SWAR code on |
| // benchmarks and it's cross-platform, so probably the right fit. |
| // [1]: https://groups.google.com/forum/#!original/comp.lang.c/2HtQXvg7iKc/xOJeipH6KLMJ |
| type Chunk = usize; |
| const STEP: usize = mem::size_of::<Chunk>(); |
| const ONE_BYTES: Chunk = Chunk::MAX / 255; // 0x0101...01 |
| |
| for chunk in rest.chunks_exact(STEP) { |
| let chars = Chunk::from_le_bytes(chunk.try_into().unwrap()); |
| let contains_ctrl = chars.wrapping_sub(ONE_BYTES * 0x20) & !chars; |
| let chars_quote = chars ^ (ONE_BYTES * Chunk::from(b'"')); |
| let contains_quote = chars_quote.wrapping_sub(ONE_BYTES) & !chars_quote; |
| let chars_backslash = chars ^ (ONE_BYTES * Chunk::from(b'\\')); |
| let contains_backslash = chars_backslash.wrapping_sub(ONE_BYTES) & !chars_backslash; |
| let masked = (contains_ctrl | contains_quote | contains_backslash) & (ONE_BYTES << 7); |
| if masked != 0 { |
| // SAFETY: chunk is in-bounds for slice |
| self.index = unsafe { chunk.as_ptr().offset_from(self.slice.as_ptr()) } as usize |
| + masked.trailing_zeros() as usize / 8; |
| return; |
| } |
| } |
| |
| self.index += rest.len() / STEP * STEP; |
| self.skip_to_escape_slow(); |
| } |
| |
| #[cold] |
| #[inline(never)] |
| fn skip_to_escape_slow(&mut self) { |
| while self.index < self.slice.len() && !is_escape(self.slice[self.index], true) { |
| self.index += 1; |
| } |
| } |
| |
| /// The big optimization here over IoRead is that if the string contains no |
| /// backslash escape sequences, the returned &str is a slice of the raw JSON |
| /// data so we avoid copying into the scratch space. |
| fn parse_str_bytes<'s, T, F>( |
| &'s mut self, |
| scratch: &'s mut Vec<u8>, |
| validate: bool, |
| result: F, |
| ) -> Result<Reference<'a, 's, T>> |
| where |
| T: ?Sized + 's, |
| F: for<'f> FnOnce(&'s Self, &'f [u8]) -> Result<&'f T>, |
| { |
| // Index of the first byte not yet copied into the scratch space. |
| let mut start = self.index; |
| |
| loop { |
| self.skip_to_escape(validate); |
| if self.index == self.slice.len() { |
| return error(self, ErrorCode::EofWhileParsingString); |
| } |
| match self.slice[self.index] { |
| b'"' => { |
| if scratch.is_empty() { |
| // Fast path: return a slice of the raw JSON without any |
| // copying. |
| let borrowed = &self.slice[start..self.index]; |
| self.index += 1; |
| return result(self, borrowed).map(Reference::Borrowed); |
| } else { |
| scratch.extend_from_slice(&self.slice[start..self.index]); |
| self.index += 1; |
| return result(self, scratch).map(Reference::Copied); |
| } |
| } |
| b'\\' => { |
| scratch.extend_from_slice(&self.slice[start..self.index]); |
| self.index += 1; |
| tri!(parse_escape(self, validate, scratch)); |
| start = self.index; |
| } |
| _ => { |
| self.index += 1; |
| return error(self, ErrorCode::ControlCharacterWhileParsingString); |
| } |
| } |
| } |
| } |
| } |
| |
| impl<'a> private::Sealed for SliceRead<'a> {} |
| |
| impl<'a> Read<'a> for SliceRead<'a> { |
| #[inline] |
| fn next(&mut self) -> Result<Option<u8>> { |
| // `Ok(self.slice.get(self.index).map(|ch| { self.index += 1; *ch }))` |
| // is about 10% slower. |
| Ok(if self.index < self.slice.len() { |
| let ch = self.slice[self.index]; |
| self.index += 1; |
| Some(ch) |
| } else { |
| None |
| }) |
| } |
| |
| #[inline] |
| fn peek(&mut self) -> Result<Option<u8>> { |
| // `Ok(self.slice.get(self.index).map(|ch| *ch))` is about 10% slower |
| // for some reason. |
| Ok(if self.index < self.slice.len() { |
| Some(self.slice[self.index]) |
| } else { |
| None |
| }) |
| } |
| |
| #[inline] |
| fn discard(&mut self) { |
| self.index += 1; |
| } |
| |
| fn position(&self) -> Position { |
| self.position_of_index(self.index) |
| } |
| |
| fn peek_position(&self) -> Position { |
| // Cap it at slice.len() just in case the most recent call was next() |
| // and it returned the last byte. |
| self.position_of_index(cmp::min(self.slice.len(), self.index + 1)) |
| } |
| |
| fn byte_offset(&self) -> usize { |
| self.index |
| } |
| |
| fn parse_str<'s>(&'s mut self, scratch: &'s mut Vec<u8>) -> Result<Reference<'a, 's, str>> { |
| self.parse_str_bytes(scratch, true, as_str) |
| } |
| |
| fn parse_str_raw<'s>( |
| &'s mut self, |
| scratch: &'s mut Vec<u8>, |
| ) -> Result<Reference<'a, 's, [u8]>> { |
| self.parse_str_bytes(scratch, false, |_, bytes| Ok(bytes)) |
| } |
| |
| fn ignore_str(&mut self) -> Result<()> { |
| loop { |
| self.skip_to_escape(true); |
| if self.index == self.slice.len() { |
| return error(self, ErrorCode::EofWhileParsingString); |
| } |
| match self.slice[self.index] { |
| b'"' => { |
| self.index += 1; |
| return Ok(()); |
| } |
| b'\\' => { |
| self.index += 1; |
| tri!(ignore_escape(self)); |
| } |
| _ => { |
| return error(self, ErrorCode::ControlCharacterWhileParsingString); |
| } |
| } |
| } |
| } |
| |
| fn decode_hex_escape(&mut self) -> Result<u16> { |
| if self.index + 4 > self.slice.len() { |
| self.index = self.slice.len(); |
| return error(self, ErrorCode::EofWhileParsingString); |
| } |
| |
| let mut n = 0; |
| for _ in 0..4 { |
| let ch = decode_hex_val(self.slice[self.index]); |
| self.index += 1; |
| match ch { |
| None => return error(self, ErrorCode::InvalidEscape), |
| Some(val) => { |
| n = (n << 4) + val; |
| } |
| } |
| } |
| Ok(n) |
| } |
| |
| #[cfg(feature = "raw_value")] |
| fn begin_raw_buffering(&mut self) { |
| self.raw_buffering_start_index = self.index; |
| } |
| |
| #[cfg(feature = "raw_value")] |
| fn end_raw_buffering<V>(&mut self, visitor: V) -> Result<V::Value> |
| where |
| V: Visitor<'a>, |
| { |
| let raw = &self.slice[self.raw_buffering_start_index..self.index]; |
| let raw = match str::from_utf8(raw) { |
| Ok(raw) => raw, |
| Err(_) => return error(self, ErrorCode::InvalidUnicodeCodePoint), |
| }; |
| visitor.visit_map(BorrowedRawDeserializer { |
| raw_value: Some(raw), |
| }) |
| } |
| |
| const should_early_return_if_failed: bool = false; |
| |
| #[inline] |
| #[cold] |
| fn set_failed(&mut self, _failed: &mut bool) { |
| self.slice = &self.slice[..self.index]; |
| } |
| } |
| |
| ////////////////////////////////////////////////////////////////////////////// |
| |
| impl<'a> StrRead<'a> { |
| /// Create a JSON input source to read from a UTF-8 string. |
| pub fn new(s: &'a str) -> Self { |
| StrRead { |
| delegate: SliceRead::new(s.as_bytes()), |
| #[cfg(feature = "raw_value")] |
| data: s, |
| } |
| } |
| } |
| |
| impl<'a> private::Sealed for StrRead<'a> {} |
| |
| impl<'a> Read<'a> for StrRead<'a> { |
| #[inline] |
| fn next(&mut self) -> Result<Option<u8>> { |
| self.delegate.next() |
| } |
| |
| #[inline] |
| fn peek(&mut self) -> Result<Option<u8>> { |
| self.delegate.peek() |
| } |
| |
| #[inline] |
| fn discard(&mut self) { |
| self.delegate.discard(); |
| } |
| |
| fn position(&self) -> Position { |
| self.delegate.position() |
| } |
| |
| fn peek_position(&self) -> Position { |
| self.delegate.peek_position() |
| } |
| |
| fn byte_offset(&self) -> usize { |
| self.delegate.byte_offset() |
| } |
| |
| fn parse_str<'s>(&'s mut self, scratch: &'s mut Vec<u8>) -> Result<Reference<'a, 's, str>> { |
| self.delegate.parse_str_bytes(scratch, true, |_, bytes| { |
| // The deserialization input came in as &str with a UTF-8 guarantee, |
| // and the \u-escapes are checked along the way, so don't need to |
| // check here. |
| Ok(unsafe { str::from_utf8_unchecked(bytes) }) |
| }) |
| } |
| |
| fn parse_str_raw<'s>( |
| &'s mut self, |
| scratch: &'s mut Vec<u8>, |
| ) -> Result<Reference<'a, 's, [u8]>> { |
| self.delegate.parse_str_raw(scratch) |
| } |
| |
| fn ignore_str(&mut self) -> Result<()> { |
| self.delegate.ignore_str() |
| } |
| |
| fn decode_hex_escape(&mut self) -> Result<u16> { |
| self.delegate.decode_hex_escape() |
| } |
| |
| #[cfg(feature = "raw_value")] |
| fn begin_raw_buffering(&mut self) { |
| self.delegate.begin_raw_buffering(); |
| } |
| |
| #[cfg(feature = "raw_value")] |
| fn end_raw_buffering<V>(&mut self, visitor: V) -> Result<V::Value> |
| where |
| V: Visitor<'a>, |
| { |
| let raw = &self.data[self.delegate.raw_buffering_start_index..self.delegate.index]; |
| visitor.visit_map(BorrowedRawDeserializer { |
| raw_value: Some(raw), |
| }) |
| } |
| |
| const should_early_return_if_failed: bool = false; |
| |
| #[inline] |
| #[cold] |
| fn set_failed(&mut self, failed: &mut bool) { |
| self.delegate.set_failed(failed); |
| } |
| } |
| |
| ////////////////////////////////////////////////////////////////////////////// |
| |
| impl<'a, 'de, R> private::Sealed for &'a mut R where R: Read<'de> {} |
| |
| impl<'a, 'de, R> Read<'de> for &'a mut R |
| where |
| R: Read<'de>, |
| { |
| fn next(&mut self) -> Result<Option<u8>> { |
| R::next(self) |
| } |
| |
| fn peek(&mut self) -> Result<Option<u8>> { |
| R::peek(self) |
| } |
| |
| fn discard(&mut self) { |
| R::discard(self); |
| } |
| |
| fn position(&self) -> Position { |
| R::position(self) |
| } |
| |
| fn peek_position(&self) -> Position { |
| R::peek_position(self) |
| } |
| |
| fn byte_offset(&self) -> usize { |
| R::byte_offset(self) |
| } |
| |
| fn parse_str<'s>(&'s mut self, scratch: &'s mut Vec<u8>) -> Result<Reference<'de, 's, str>> { |
| R::parse_str(self, scratch) |
| } |
| |
| fn parse_str_raw<'s>( |
| &'s mut self, |
| scratch: &'s mut Vec<u8>, |
| ) -> Result<Reference<'de, 's, [u8]>> { |
| R::parse_str_raw(self, scratch) |
| } |
| |
| fn ignore_str(&mut self) -> Result<()> { |
| R::ignore_str(self) |
| } |
| |
| fn decode_hex_escape(&mut self) -> Result<u16> { |
| R::decode_hex_escape(self) |
| } |
| |
| #[cfg(feature = "raw_value")] |
| fn begin_raw_buffering(&mut self) { |
| R::begin_raw_buffering(self); |
| } |
| |
| #[cfg(feature = "raw_value")] |
| fn end_raw_buffering<V>(&mut self, visitor: V) -> Result<V::Value> |
| where |
| V: Visitor<'de>, |
| { |
| R::end_raw_buffering(self, visitor) |
| } |
| |
| const should_early_return_if_failed: bool = R::should_early_return_if_failed; |
| |
| fn set_failed(&mut self, failed: &mut bool) { |
| R::set_failed(self, failed); |
| } |
| } |
| |
| ////////////////////////////////////////////////////////////////////////////// |
| |
| /// Marker for whether StreamDeserializer can implement FusedIterator. |
| pub trait Fused: private::Sealed {} |
| impl<'a> Fused for SliceRead<'a> {} |
| impl<'a> Fused for StrRead<'a> {} |
| |
| fn is_escape(ch: u8, including_control_characters: bool) -> bool { |
| ch == b'"' || ch == b'\\' || (including_control_characters && ch < 0x20) |
| } |
| |
| fn next_or_eof<'de, R>(read: &mut R) -> Result<u8> |
| where |
| R: ?Sized + Read<'de>, |
| { |
| match tri!(read.next()) { |
| Some(b) => Ok(b), |
| None => error(read, ErrorCode::EofWhileParsingString), |
| } |
| } |
| |
| fn peek_or_eof<'de, R>(read: &mut R) -> Result<u8> |
| where |
| R: ?Sized + Read<'de>, |
| { |
| match tri!(read.peek()) { |
| Some(b) => Ok(b), |
| None => error(read, ErrorCode::EofWhileParsingString), |
| } |
| } |
| |
| fn error<'de, R, T>(read: &R, reason: ErrorCode) -> Result<T> |
| where |
| R: ?Sized + Read<'de>, |
| { |
| let position = read.position(); |
| Err(Error::syntax(reason, position.line, position.column)) |
| } |
| |
| fn as_str<'de, 's, R: Read<'de>>(read: &R, slice: &'s [u8]) -> Result<&'s str> { |
| str::from_utf8(slice).or_else(|_| error(read, ErrorCode::InvalidUnicodeCodePoint)) |
| } |
| |
| /// Parses a JSON escape sequence and appends it into the scratch space. Assumes |
| /// the previous byte read was a backslash. |
| fn parse_escape<'de, R: Read<'de>>( |
| read: &mut R, |
| validate: bool, |
| scratch: &mut Vec<u8>, |
| ) -> Result<()> { |
| let ch = tri!(next_or_eof(read)); |
| |
| match ch { |
| b'"' => scratch.push(b'"'), |
| b'\\' => scratch.push(b'\\'), |
| b'/' => scratch.push(b'/'), |
| b'b' => scratch.push(b'\x08'), |
| b'f' => scratch.push(b'\x0c'), |
| b'n' => scratch.push(b'\n'), |
| b'r' => scratch.push(b'\r'), |
| b't' => scratch.push(b'\t'), |
| b'u' => { |
| fn encode_surrogate(scratch: &mut Vec<u8>, n: u16) { |
| scratch.extend_from_slice(&[ |
| (n >> 12 & 0b0000_1111) as u8 | 0b1110_0000, |
| (n >> 6 & 0b0011_1111) as u8 | 0b1000_0000, |
| (n & 0b0011_1111) as u8 | 0b1000_0000, |
| ]); |
| } |
| |
| let c = match tri!(read.decode_hex_escape()) { |
| n @ 0xDC00..=0xDFFF => { |
| return if validate { |
| error(read, ErrorCode::LoneLeadingSurrogateInHexEscape) |
| } else { |
| encode_surrogate(scratch, n); |
| Ok(()) |
| }; |
| } |
| |
| // Non-BMP characters are encoded as a sequence of two hex |
| // escapes, representing UTF-16 surrogates. If deserializing a |
| // utf-8 string the surrogates are required to be paired, |
| // whereas deserializing a byte string accepts lone surrogates. |
| n1 @ 0xD800..=0xDBFF => { |
| if tri!(peek_or_eof(read)) == b'\\' { |
| read.discard(); |
| } else { |
| return if validate { |
| read.discard(); |
| error(read, ErrorCode::UnexpectedEndOfHexEscape) |
| } else { |
| encode_surrogate(scratch, n1); |
| Ok(()) |
| }; |
| } |
| |
| if tri!(peek_or_eof(read)) == b'u' { |
| read.discard(); |
| } else { |
| return if validate { |
| read.discard(); |
| error(read, ErrorCode::UnexpectedEndOfHexEscape) |
| } else { |
| encode_surrogate(scratch, n1); |
| // The \ prior to this byte started an escape sequence, |
| // so we need to parse that now. This recursive call |
| // does not blow the stack on malicious input because |
| // the escape is not \u, so it will be handled by one |
| // of the easy nonrecursive cases. |
| parse_escape(read, validate, scratch) |
| }; |
| } |
| |
| let n2 = tri!(read.decode_hex_escape()); |
| |
| if n2 < 0xDC00 || n2 > 0xDFFF { |
| return error(read, ErrorCode::LoneLeadingSurrogateInHexEscape); |
| } |
| |
| let n = (((n1 - 0xD800) as u32) << 10 | (n2 - 0xDC00) as u32) + 0x1_0000; |
| |
| match char::from_u32(n) { |
| Some(c) => c, |
| None => { |
| return error(read, ErrorCode::InvalidUnicodeCodePoint); |
| } |
| } |
| } |
| |
| // Every u16 outside of the surrogate ranges above is guaranteed |
| // to be a legal char. |
| n => char::from_u32(n as u32).unwrap(), |
| }; |
| |
| scratch.extend_from_slice(c.encode_utf8(&mut [0_u8; 4]).as_bytes()); |
| } |
| _ => { |
| return error(read, ErrorCode::InvalidEscape); |
| } |
| } |
| |
| Ok(()) |
| } |
| |
| /// Parses a JSON escape sequence and discards the value. Assumes the previous |
| /// byte read was a backslash. |
| fn ignore_escape<'de, R>(read: &mut R) -> Result<()> |
| where |
| R: ?Sized + Read<'de>, |
| { |
| let ch = tri!(next_or_eof(read)); |
| |
| match ch { |
| b'"' | b'\\' | b'/' | b'b' | b'f' | b'n' | b'r' | b't' => {} |
| b'u' => { |
| // At this point we don't care if the codepoint is valid. We just |
| // want to consume it. We don't actually know what is valid or not |
| // at this point, because that depends on if this string will |
| // ultimately be parsed into a string or a byte buffer in the "real" |
| // parse. |
| |
| tri!(read.decode_hex_escape()); |
| } |
| _ => { |
| return error(read, ErrorCode::InvalidEscape); |
| } |
| } |
| |
| Ok(()) |
| } |
| |
| static HEX: [u8; 256] = { |
| const __: u8 = 255; // not a hex digit |
| [ |
| // 1 2 3 4 5 6 7 8 9 A B C D E F |
| __, __, __, __, __, __, __, __, __, __, __, __, __, __, __, __, // 0 |
| __, __, __, __, __, __, __, __, __, __, __, __, __, __, __, __, // 1 |
| __, __, __, __, __, __, __, __, __, __, __, __, __, __, __, __, // 2 |
| 00, 01, 02, 03, 04, 05, 06, 07, 08, 09, __, __, __, __, __, __, // 3 |
| __, 10, 11, 12, 13, 14, 15, __, __, __, __, __, __, __, __, __, // 4 |
| __, __, __, __, __, __, __, __, __, __, __, __, __, __, __, __, // 5 |
| __, 10, 11, 12, 13, 14, 15, __, __, __, __, __, __, __, __, __, // 6 |
| __, __, __, __, __, __, __, __, __, __, __, __, __, __, __, __, // 7 |
| __, __, __, __, __, __, __, __, __, __, __, __, __, __, __, __, // 8 |
| __, __, __, __, __, __, __, __, __, __, __, __, __, __, __, __, // 9 |
| __, __, __, __, __, __, __, __, __, __, __, __, __, __, __, __, // A |
| __, __, __, __, __, __, __, __, __, __, __, __, __, __, __, __, // B |
| __, __, __, __, __, __, __, __, __, __, __, __, __, __, __, __, // C |
| __, __, __, __, __, __, __, __, __, __, __, __, __, __, __, __, // D |
| __, __, __, __, __, __, __, __, __, __, __, __, __, __, __, __, // E |
| __, __, __, __, __, __, __, __, __, __, __, __, __, __, __, __, // F |
| ] |
| }; |
| |
| fn decode_hex_val(val: u8) -> Option<u16> { |
| let n = HEX[val as usize] as u16; |
| if n == 255 { |
| None |
| } else { |
| Some(n) |
| } |
| } |
