Mercurial > core / rust/lib/sxp/src/read.rs

 //! read.rs --- sxp reader
 use crate::{err::ErrorCode, Error, Result};
 use alloc::vec::Vec;
 use core::{char, cmp, ops::Deref, str};
 
 #[cfg(feature = "std")]
 use crate::io;
 #[cfg(feature = "std")]
 use crate::iter::LineColIterator;
 
 /// 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.
 //  TODO 2023-07-14: should we use specialization anyways? we are on
 //  nightly 99% of the time for better or worse
 pub trait Read<'de> {
   #[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 an 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 an 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
   /// 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>;
 
   /// 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,
     }
   }
 }
 
 /// SXP 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>,
 }
 
 /// SXP 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,
 }
 
 /// SXP 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 = "std")]
 impl<R> IoRead<R>
 where
   R: io::Read,
 {
   /// Create a SXP 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 = "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 = e!(next_or_eof(self));
       if !ESCAPE[ch as usize] {
         scratch.push(ch);
         continue;
       }
       match ch {
         b'"' => {
           return result(self, scratch);
         }
         b'\\' => {
           e!(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) => Ok(Some(ch)),
       None => match self.iter.next() {
         Some(Err(err)) => Err(Error::io(err)),
         Some(Ok(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),
       },
     }
   }
 
   #[inline]
   fn discard(&mut self) {
     self.ch = None;
   }
 
   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 = e!(next_or_eof(self));
       if !ESCAPE[ch as usize] {
         continue;
       }
       match ch {
         b'"' => {
           return Ok(());
         }
         b'\\' => {
           e!(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(e!(next_or_eof(self))) {
         None => return error(self, ErrorCode::InvalidEscape),
         Some(val) => {
           n = (n << 4) + val;
         }
       }
     }
     Ok(n)
   }
 
   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 SXP input source to read from a slice of bytes.
   pub fn new(slice: &'a [u8]) -> Self {
     SliceRead { slice, 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 SXP
   /// 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 SXP 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;
           e!(parse_escape(self, validate, scratch));
           start = self.index;
         }
         _ => {
           self.index += 1;
           if validate {
             return error(self, ErrorCode::ControlCharacterWhileParsingString);
           }
         }
       }
     }
   }
 }
 
 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;
           e!(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)
   }
 
   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 SXP input source to read from a UTF-8 string.
   pub fn new(s: &'a str) -> Self {
     StrRead {
       delegate: SliceRead::new(s.as_bytes()),
     }
   }
 }
 
 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()
   }
 
   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> 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)
   }
 
   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 {}
 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 e!(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 e!(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 SXP 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 = e!(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 e!(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 e!(peek_or_eof(read)) == b'\\' {
             read.discard();
           } else {
             return if validate {
               read.discard();
               error(read, ErrorCode::UnexpectedEndOfHexEscape)
             } else {
               encode_surrogate(scratch, n1);
               Ok(())
             };
           }
 
           if e!(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 = e!(read.decode_hex_escape());
 
           if !(0xDC00..=0xDFFF).contains(&n2) {
             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 SXP 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 = e!(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.
 
       e!(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
     0, 1, 2, 3, 4, 5, 6, 7, 8, 9, __, __, __, __, __, __, // 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)
   }
 }