vendor/wasmparser-0.219.0/src/readers.rs - toolchain/rustc - Git at Google

 /* Copyright 2018 Mozilla Foundation
  *
  * Licensed under the Apache License, Version 2.0 (the "License");
  * you may not use this file except in compliance with the License.
  * You may obtain a copy of the License at
  *
  *     http://www.apache.org/licenses/LICENSE-2.0
  *
  * Unless required by applicable law or agreed to in writing, software
  * distributed under the License is distributed on an "AS IS" BASIS,
  * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
  * See the License for the specific language governing permissions and
  * limitations under the License.
  */

 use crate::{BinaryReader, BinaryReaderError, Result};
 use ::core::fmt;
 use ::core::marker;
 use ::core::ops::Range;

 #[cfg(feature = "component-model")]
 mod component;
 mod core;

 #[cfg(feature = "component-model")]
 pub use self::component::*;
 pub use self::core::*;

 /// A trait implemented for items that can be decoded directly from a
 /// `BinaryReader`, or that which can be parsed from the WebAssembly binary
 /// format.
 ///
 /// Note that this is also accessible as a [`BinaryReader::read`] method.
 pub trait FromReader<'a>: Sized {
     /// Attempts to read `Self` from the provided binary reader, returning an
     /// error if it is unable to do so.
     fn from_reader(reader: &mut BinaryReader<'a>) -> Result<Self>;
 }

 impl<'a> FromReader<'a> for u32 {
     fn from_reader(reader: &mut BinaryReader<'a>) -> Result<Self> {
         reader.read_var_u32()
     }
 }

 impl<'a> FromReader<'a> for &'a str {
     fn from_reader(reader: &mut BinaryReader<'a>) -> Result<Self> {
         reader.read_string()
     }
 }

 impl<'a, T, U> FromReader<'a> for (T, U)
 where
     T: FromReader<'a>,
     U: FromReader<'a>,
 {
     fn from_reader(reader: &mut BinaryReader<'a>) -> Result<Self> {
         Ok((reader.read()?, reader.read()?))
     }
 }

 /// A generic structure for reading a section of a WebAssembly binary which has
 /// a limited number of items within it.
 ///
 /// Many WebAssembly sections are a count of items followed by that many items.
 /// This helper structure can be used to parse these sections and provides
 /// an iteration-based API for reading the contents.
 ///
 /// Note that this always implements the [`Clone`] trait to represent the
 /// ability to parse the section multiple times.
 pub struct SectionLimited<'a, T> {
     reader: BinaryReader<'a>,
     count: u32,
     _marker: marker::PhantomData<T>,
 }

 impl<'a, T> SectionLimited<'a, T> {
     /// Creates a new section reader from the provided contents.
     ///
     /// The `data` provided here is the data of the section itself that will be
     /// parsed. The `offset` argument is the byte offset, in the original wasm
     /// binary, that the section was found. The `offset` argument is used
     /// for error reporting.
     ///
     /// # Errors
     ///
     /// Returns an error if a 32-bit count couldn't be read from the `data`.
     pub fn new(mut reader: BinaryReader<'a>) -> Result<Self> {
         let count = reader.read_var_u32()?;
         Ok(SectionLimited {
             reader,
             count,
             _marker: marker::PhantomData,
         })
     }

     /// Returns the count of total items within this section.
     pub fn count(&self) -> u32 {
         self.count
     }

     /// Returns whether the original byte offset of this section.
     pub fn original_position(&self) -> usize {
         self.reader.original_position()
     }

     /// Returns the range, as byte offsets, of this section within the original
     /// wasm binary.
     pub fn range(&self) -> Range<usize> {
         self.reader.range()
     }

     /// Returns an iterator which yields not only each item in this section but
     /// additionally the offset of each item within the section.
     pub fn into_iter_with_offsets(self) -> SectionLimitedIntoIterWithOffsets<'a, T>
     where
         T: FromReader<'a>,
     {
         SectionLimitedIntoIterWithOffsets {
             iter: self.into_iter(),
         }
     }
 }

 impl<T> Clone for SectionLimited<'_, T> {
     fn clone(&self) -> Self {
         SectionLimited {
             reader: self.reader.clone(),
             count: self.count,
             _marker: self._marker,
         }
     }
 }

 impl<T> fmt::Debug for SectionLimited<'_, T> {
     fn fmt(&self, f: &mut fmt::Formatter<'_>) -> fmt::Result {
         f.debug_struct("SectionLimited")
             .field("count", &self.count)
             .field("range", &self.range())
             .finish()
     }
 }

 impl<'a, T> IntoIterator for SectionLimited<'a, T>
 where
     T: FromReader<'a>,
 {
     type Item = Result<T>;
     type IntoIter = SectionLimitedIntoIter<'a, T>;

     fn into_iter(self) -> Self::IntoIter {
         SectionLimitedIntoIter {
             remaining: self.count,
             section: self,
             end: false,
         }
     }
 }

 /// A consuming iterator of a [`SectionLimited`].
 ///
 /// This is created via the [`IntoIterator`] `impl` for the [`SectionLimited`]
 /// type.
 pub struct SectionLimitedIntoIter<'a, T> {
     section: SectionLimited<'a, T>,
     remaining: u32,
     end: bool,
 }

 impl<T> SectionLimitedIntoIter<'_, T> {
     /// Returns the current byte offset of the section within this iterator.
     pub fn original_position(&self) -> usize {
         self.section.reader.original_position()
     }
 }

 impl<'a, T> Iterator for SectionLimitedIntoIter<'a, T>
 where
     T: FromReader<'a>,
 {
     type Item = Result<T>;

     fn next(&mut self) -> Option<Result<T>> {
         if self.end {
             return None;
         }
         if self.remaining == 0 {
             self.end = true;
             if self.section.reader.eof() {
                 return None;
             }
             return Some(Err(BinaryReaderError::new(
                 "section size mismatch: unexpected data at the end of the section",
                 self.section.reader.original_position(),
             )));
         }
         let result = self.section.reader.read();
         self.end = result.is_err();
         self.remaining -= 1;
         Some(result)
     }

     fn size_hint(&self) -> (usize, Option<usize>) {
         let remaining = self.remaining as usize;
         (remaining, Some(remaining))
     }
 }

 impl<'a, T> ExactSizeIterator for SectionLimitedIntoIter<'a, T> where T: FromReader<'a> {}

 /// An iterator over a limited section iterator.
 pub struct SectionLimitedIntoIterWithOffsets<'a, T> {
     iter: SectionLimitedIntoIter<'a, T>,
 }

 impl<'a, T> Iterator for SectionLimitedIntoIterWithOffsets<'a, T>
 where
     T: FromReader<'a>,
 {
     type Item = Result<(usize, T)>;

     fn next(&mut self) -> Option<Self::Item> {
         let pos = self.iter.section.reader.original_position();
         Some(self.iter.next()?.map(|item| (pos, item)))
     }

     fn size_hint(&self) -> (usize, Option<usize>) {
         self.iter.size_hint()
     }
 }

 impl<'a, T> ExactSizeIterator for SectionLimitedIntoIterWithOffsets<'a, T> where T: FromReader<'a> {}

 /// A trait implemented for subsections of another outer section.
 ///
 /// This is currently only used for subsections within custom sections, such as
 /// the `name` section of core wasm.
 ///
 /// This is used in conjunction with [`Subsections`].
 pub trait Subsection<'a>: Sized {
     /// Converts the section identifier provided with the section contents into
     /// a typed section
     fn from_reader(id: u8, reader: BinaryReader<'a>) -> Result<Self>;
 }

 /// Iterator/reader over the contents of a section which is composed of
 /// subsections.
 ///
 /// This reader is used for the core `name` section, for example. This type
 /// primarily implements [`Iterator`] for advancing through the sections.
 pub struct Subsections<'a, T> {
     reader: BinaryReader<'a>,
     _marker: marker::PhantomData<T>,
 }

 impl<'a, T> Subsections<'a, T> {
     /// Creates a new reader for the specified section contents starting at
     /// `offset` within the original wasm file.
     pub fn new(reader: BinaryReader<'a>) -> Self {
         Subsections {
             reader,
             _marker: marker::PhantomData,
         }
     }

     /// Returns whether the original byte offset of this section.
     pub fn original_position(&self) -> usize {
         self.reader.original_position()
     }

     /// Returns the range, as byte offsets, of this section within the original
     /// wasm binary.
     pub fn range(&self) -> Range<usize> {
         self.reader.range()
     }

     fn read(&mut self) -> Result<T>
     where
         T: Subsection<'a>,
     {
         let subsection_id = self.reader.read_u7()?;
         let reader = self.reader.read_reader()?;
         T::from_reader(subsection_id, reader)
     }
 }

 impl<T> Clone for Subsections<'_, T> {
     fn clone(&self) -> Self {
         Subsections {
             reader: self.reader.clone(),
             _marker: self._marker,
         }
     }
 }

 impl<T> fmt::Debug for Subsections<'_, T> {
     fn fmt(&self, f: &mut fmt::Formatter<'_>) -> fmt::Result {
         f.debug_struct("Subsections")
             .field("range", &self.range())
             .finish()
     }
 }

 impl<'a, T> Iterator for Subsections<'a, T>
 where
     T: Subsection<'a>,
 {
     type Item = Result<T>;

     fn next(&mut self) -> Option<Result<T>> {
         if self.reader.eof() {
             None
         } else {
             Some(self.read())
         }
     }
 }
	/* Copyright 2018 Mozilla Foundation
	*
	* Licensed under the Apache License, Version 2.0 (the "License");
	* you may not use this file except in compliance with the License.
	* You may obtain a copy of the License at
	*
	* http://www.apache.org/licenses/LICENSE-2.0
	*
	* Unless required by applicable law or agreed to in writing, software
	* distributed under the License is distributed on an "AS IS" BASIS,
	* WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
	* See the License for the specific language governing permissions and
	* limitations under the License.
	*/

	use crate::{BinaryReader, BinaryReaderError, Result};
	use ::core::fmt;
	use ::core::marker;
	use ::core::ops::Range;

	#[cfg(feature = "component-model")]
	mod component;
	mod core;

	#[cfg(feature = "component-model")]
	pub use self::component::*;
	pub use self::core::*;

	/// A trait implemented for items that can be decoded directly from a
	/// `BinaryReader`, or that which can be parsed from the WebAssembly binary
	/// format.
	///
	/// Note that this is also accessible as a [`BinaryReader::read`] method.
	pub trait FromReader<'a>: Sized {
	/// Attempts to read `Self` from the provided binary reader, returning an
	/// error if it is unable to do so.
	fn from_reader(reader: &mut BinaryReader<'a>) -> Result<Self>;
	}

	impl<'a> FromReader<'a> for u32 {
	fn from_reader(reader: &mut BinaryReader<'a>) -> Result<Self> {
	reader.read_var_u32()
	}
	}

	impl<'a> FromReader<'a> for &'a str {
	fn from_reader(reader: &mut BinaryReader<'a>) -> Result<Self> {
	reader.read_string()
	}
	}

	impl<'a, T, U> FromReader<'a> for (T, U)
	where
	T: FromReader<'a>,
	U: FromReader<'a>,
	{
	fn from_reader(reader: &mut BinaryReader<'a>) -> Result<Self> {
	Ok((reader.read()?, reader.read()?))
	}
	}

	/// A generic structure for reading a section of a WebAssembly binary which has
	/// a limited number of items within it.
	///
	/// Many WebAssembly sections are a count of items followed by that many items.
	/// This helper structure can be used to parse these sections and provides
	/// an iteration-based API for reading the contents.
	///
	/// Note that this always implements the [`Clone`] trait to represent the
	/// ability to parse the section multiple times.
	pub struct SectionLimited<'a, T> {
	reader: BinaryReader<'a>,
	count: u32,
	_marker: marker::PhantomData<T>,
	}

	impl<'a, T> SectionLimited<'a, T> {
	/// Creates a new section reader from the provided contents.
	///
	/// The `data` provided here is the data of the section itself that will be
	/// parsed. The `offset` argument is the byte offset, in the original wasm
	/// binary, that the section was found. The `offset` argument is used
	/// for error reporting.
	///
	/// # Errors
	///
	/// Returns an error if a 32-bit count couldn't be read from the `data`.
	pub fn new(mut reader: BinaryReader<'a>) -> Result<Self> {
	let count = reader.read_var_u32()?;
	Ok(SectionLimited {
	reader,
	count,
	_marker: marker::PhantomData,
	})
	}

	/// Returns the count of total items within this section.
	pub fn count(&self) -> u32 {
	self.count
	}

	/// Returns whether the original byte offset of this section.
	pub fn original_position(&self) -> usize {
	self.reader.original_position()
	}

	/// Returns the range, as byte offsets, of this section within the original
	/// wasm binary.
	pub fn range(&self) -> Range<usize> {
	self.reader.range()
	}

	/// Returns an iterator which yields not only each item in this section but
	/// additionally the offset of each item within the section.
	pub fn into_iter_with_offsets(self) -> SectionLimitedIntoIterWithOffsets<'a, T>
	where
	T: FromReader<'a>,
	{
	SectionLimitedIntoIterWithOffsets {
	iter: self.into_iter(),
	}
	}
	}

	impl<T> Clone for SectionLimited<'_, T> {
	fn clone(&self) -> Self {
	SectionLimited {
	reader: self.reader.clone(),
	count: self.count,
	_marker: self._marker,
	}
	}
	}

	impl<T> fmt::Debug for SectionLimited<'_, T> {
	fn fmt(&self, f: &mut fmt::Formatter<'_>) -> fmt::Result {
	f.debug_struct("SectionLimited")
	.field("count", &self.count)
	.field("range", &self.range())
	.finish()
	}
	}

	impl<'a, T> IntoIterator for SectionLimited<'a, T>
	where
	T: FromReader<'a>,
	{
	type Item = Result<T>;
	type IntoIter = SectionLimitedIntoIter<'a, T>;

	fn into_iter(self) -> Self::IntoIter {
	SectionLimitedIntoIter {
	remaining: self.count,
	section: self,
	end: false,
	}
	}
	}

	/// A consuming iterator of a [`SectionLimited`].
	///
	/// This is created via the [`IntoIterator`] `impl` for the [`SectionLimited`]
	/// type.
	pub struct SectionLimitedIntoIter<'a, T> {
	section: SectionLimited<'a, T>,
	remaining: u32,
	end: bool,
	}

	impl<T> SectionLimitedIntoIter<'_, T> {
	/// Returns the current byte offset of the section within this iterator.
	pub fn original_position(&self) -> usize {
	self.section.reader.original_position()
	}
	}

	impl<'a, T> Iterator for SectionLimitedIntoIter<'a, T>
	where
	T: FromReader<'a>,
	{
	type Item = Result<T>;

	fn next(&mut self) -> Option<Result<T>> {
	if self.end {
	return None;
	}
	if self.remaining == 0 {
	self.end = true;
	if self.section.reader.eof() {
	return None;
	}
	return Some(Err(BinaryReaderError::new(
	"section size mismatch: unexpected data at the end of the section",
	self.section.reader.original_position(),
	)));
	}
	let result = self.section.reader.read();
	self.end = result.is_err();
	self.remaining -= 1;
	Some(result)
	}

	fn size_hint(&self) -> (usize, Option<usize>) {
	let remaining = self.remaining as usize;
	(remaining, Some(remaining))
	}
	}

	impl<'a, T> ExactSizeIterator for SectionLimitedIntoIter<'a, T> where T: FromReader<'a> {}

	/// An iterator over a limited section iterator.
	pub struct SectionLimitedIntoIterWithOffsets<'a, T> {
	iter: SectionLimitedIntoIter<'a, T>,
	}

	impl<'a, T> Iterator for SectionLimitedIntoIterWithOffsets<'a, T>
	where
	T: FromReader<'a>,
	{
	type Item = Result<(usize, T)>;

	fn next(&mut self) -> Option<Self::Item> {
	let pos = self.iter.section.reader.original_position();
	Some(self.iter.next()?.map(\|item\| (pos, item)))
	}

	fn size_hint(&self) -> (usize, Option<usize>) {
	self.iter.size_hint()
	}
	}

	impl<'a, T> ExactSizeIterator for SectionLimitedIntoIterWithOffsets<'a, T> where T: FromReader<'a> {}

	/// A trait implemented for subsections of another outer section.
	///
	/// This is currently only used for subsections within custom sections, such as
	/// the `name` section of core wasm.
	///
	/// This is used in conjunction with [`Subsections`].
	pub trait Subsection<'a>: Sized {
	/// Converts the section identifier provided with the section contents into
	/// a typed section
	fn from_reader(id: u8, reader: BinaryReader<'a>) -> Result<Self>;
	}

	/// Iterator/reader over the contents of a section which is composed of
	/// subsections.
	///
	/// This reader is used for the core `name` section, for example. This type
	/// primarily implements [`Iterator`] for advancing through the sections.
	pub struct Subsections<'a, T> {
	reader: BinaryReader<'a>,
	_marker: marker::PhantomData<T>,
	}

	impl<'a, T> Subsections<'a, T> {
	/// Creates a new reader for the specified section contents starting at
	/// `offset` within the original wasm file.
	pub fn new(reader: BinaryReader<'a>) -> Self {
	Subsections {
	reader,
	_marker: marker::PhantomData,
	}
	}

	/// Returns whether the original byte offset of this section.
	pub fn original_position(&self) -> usize {
	self.reader.original_position()
	}

	/// Returns the range, as byte offsets, of this section within the original
	/// wasm binary.
	pub fn range(&self) -> Range<usize> {
	self.reader.range()
	}

	fn read(&mut self) -> Result<T>
	where
	T: Subsection<'a>,
	{
	let subsection_id = self.reader.read_u7()?;
	let reader = self.reader.read_reader()?;
	T::from_reader(subsection_id, reader)
	}
	}

	impl<T> Clone for Subsections<'_, T> {
	fn clone(&self) -> Self {
	Subsections {
	reader: self.reader.clone(),
	_marker: self._marker,
	}
	}
	}

	impl<T> fmt::Debug for Subsections<'_, T> {
	fn fmt(&self, f: &mut fmt::Formatter<'_>) -> fmt::Result {
	f.debug_struct("Subsections")
	.field("range", &self.range())
	.finish()
	}
	}

	impl<'a, T> Iterator for Subsections<'a, T>
	where
	T: Subsection<'a>,
	{
	type Item = Result<T>;

	fn next(&mut self) -> Option<Result<T>> {
	if self.reader.eof() {
	None
	} else {
	Some(self.read())
	}
	}
	}