use alloc::string::{String, ToString};
use core::fmt::{Debug, Display};
use wasmparser::Encoding;
#[derive(Debug, PartialEq, Eq)]
/// Errors that can occur when parsing a WebAssembly module
pub enum ParseError {
/// An invalid type was encountered
InvalidType,
/// An unsupported section was encountered
UnsupportedSection(String),
/// A duplicate section was encountered
DuplicateSection(String),
/// An empty section was encountered
EmptySection(String),
/// An unsupported operator was encountered
UnsupportedOperator(String),
/// An error occurred while parsing the module
ParseError {
/// The error message
message: String,
/// The offset in the module where the error occurred
offset: usize,
},
/// An invalid encoding was encountered
InvalidEncoding(Encoding),
/// An invalid local count was encountered
InvalidLocalCount {
/// The expected local count
expected: u32,
/// The actual local count
actual: u32,
},
/// The end of the module was not reached
EndNotReached,
/// An unknown error occurred
Other(String),
}
impl Display for ParseError {
fn fmt(&self, f: &mut core::fmt::Formatter<'_>) -> core::fmt::Result {
match self {
Self::InvalidType => write!(f, "invalid type"),
Self::UnsupportedSection(section) => write!(f, "unsupported section: {section}"),
Self::DuplicateSection(section) => write!(f, "duplicate section: {section}"),
Self::EmptySection(section) => write!(f, "empty section: {section}"),
Self::UnsupportedOperator(operator) => write!(f, "unsupported operator: {operator}"),
Self::ParseError { message, offset } => {
write!(f, "error parsing module: {message} at offset {offset}")
}
Self::InvalidEncoding(encoding) => write!(f, "invalid encoding: {encoding:?}"),
Self::InvalidLocalCount { expected, actual } => {
write!(f, "invalid local count: expected {expected}, actual {actual}")
}
Self::EndNotReached => write!(f, "end of module not reached"),
Self::Other(message) => write!(f, "unknown error: {message}"),
}
}
}
impl core::error::Error for ParseError {}
impl From<wasmparser::Error> for ParseError {
fn from(value: wasmparser::Error) -> Self {
Self::ParseError { message: value.message().to_string(), offset: value.offset() }
}
}
pub(crate) type Result<T, E = ParseError> = core::result::Result<T, E>;
|
