summaryrefslogtreecommitdiffstats
path: root/vendor/serde_json/src/read.rs
diff options
context:
space:
mode:
Diffstat (limited to 'vendor/serde_json/src/read.rs')
-rw-r--r--vendor/serde_json/src/read.rs1004
1 files changed, 1004 insertions, 0 deletions
diff --git a/vendor/serde_json/src/read.rs b/vendor/serde_json/src/read.rs
new file mode 100644
index 0000000..fc3a3ca
--- /dev/null
+++ b/vendor/serde_json/src/read.rs
@@ -0,0 +1,1004 @@
+use crate::error::{Error, ErrorCode, Result};
+use alloc::vec::Vec;
+use core::char;
+use core::cmp;
+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(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 sequnce ('\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 !ESCAPE[ch as usize] {
+ 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 !ESCAPE[ch as usize] {
+ 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 mut position = Position { line: 1, column: 0 };
+ for ch in &self.slice[..i] {
+ match *ch {
+ b'\n' => {
+ position.line += 1;
+ position.column = 0;
+ }
+ _ => {
+ position.column += 1;
+ }
+ }
+ }
+ position
+ }
+
+ /// 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 {
+ while self.index < self.slice.len() && !ESCAPE[self.slice[self.index] as usize] {
+ self.index += 1;
+ }
+ 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;
+ if validate {
+ 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 {
+ while self.index < self.slice.len() && !ESCAPE[self.slice[self.index] as usize] {
+ self.index += 1;
+ }
+ 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> {}
+
+// Lookup table of bytes that must be escaped. A value of true at index i means
+// that byte i requires an escape sequence in the input.
+static ESCAPE: [bool; 256] = {
+ const CT: bool = true; // control character \x00..=\x1F
+ const QU: bool = true; // quote \x22
+ const BS: bool = true; // backslash \x5C
+ const __: bool = false; // allow unescaped
+ [
+ // 1 2 3 4 5 6 7 8 9 A B C D E F
+ CT, CT, CT, CT, CT, CT, CT, CT, CT, CT, CT, CT, CT, CT, CT, CT, // 0
+ CT, CT, CT, CT, CT, CT, CT, CT, CT, CT, CT, CT, CT, CT, CT, CT, // 1
+ __, __, QU, __, __, __, __, __, __, __, __, __, __, __, __, __, // 2
+ __, __, __, __, __, __, __, __, __, __, __, __, __, __, __, __, // 3
+ __, __, __, __, __, __, __, __, __, __, __, __, __, __, __, __, // 4
+ __, __, __, __, __, __, __, __, __, __, __, __, BS, __, __, __, // 5
+ __, __, __, __, __, __, __, __, __, __, __, __, __, __, __, __, // 6
+ __, __, __, __, __, __, __, __, __, __, __, __, __, __, __, __, // 7
+ __, __, __, __, __, __, __, __, __, __, __, __, __, __, __, __, // 8
+ __, __, __, __, __, __, __, __, __, __, __, __, __, __, __, __, // 9
+ __, __, __, __, __, __, __, __, __, __, __, __, __, __, __, __, // A
+ __, __, __, __, __, __, __, __, __, __, __, __, __, __, __, __, // B
+ __, __, __, __, __, __, __, __, __, __, __, __, __, __, __, __, // C
+ __, __, __, __, __, __, __, __, __, __, __, __, __, __, __, __, // D
+ __, __, __, __, __, __, __, __, __, __, __, __, __, __, __, __, // E
+ __, __, __, __, __, __, __, __, __, __, __, __, __, __, __, __, // F
+ ]
+};
+
+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)
+ }
+}
generated by cgit v1.2.3 (git 2.39.1) at 2024-12-02 01:03:02 +0000