makepad_stitch/
error.rs

1use {
2    crate::{
3        decode::DecodeError, func::FuncError, global::GlobalError, linker::InstantiateError,
4        mem::MemError, table::TableError, trap::Trap,
5    },
6    std::{error, fmt},
7};
8
9/// An error that can occur when operating on a [`Module`](crate::Module) or [`Func`](crate::Func).
10#[derive(Debug)]
11pub enum Error {
12    Decode(DecodeError),
13    Instantiate(InstantiateError),
14    Func(FuncError),
15    Table(TableError),
16    Memory(MemError),
17    Global(GlobalError),
18    Trap(Trap),
19}
20
21impl error::Error for Error {
22    fn source(&self) -> Option<&(dyn error::Error + 'static)> {
23        match self {
24            Error::Decode(error) => Some(error),
25            Error::Instantiate(error) => Some(error),
26            Error::Func(error) => Some(error),
27            Error::Table(error) => Some(error),
28            Error::Memory(error) => Some(error),
29            Error::Global(error) => Some(error),
30            Error::Trap(error) => Some(error),
31        }
32    }
33}
34
35impl fmt::Display for Error {
36    fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result {
37        match self {
38            Error::Decode(_) => write!(f, "decode error"),
39            Error::Instantiate(_) => write!(f, "instantiate error"),
40            Error::Func(_) => write!(f, "function error"),
41            Error::Table(_) => write!(f, "table error"),
42            Error::Memory(_) => write!(f, "memory error"),
43            Error::Global(_) => write!(f, "global error"),
44            Error::Trap(_) => write!(f, "trap"),
45        }
46    }
47}
48
49impl From<DecodeError> for Error {
50    fn from(error: DecodeError) -> Self {
51        Error::Decode(error)
52    }
53}
54
55impl From<InstantiateError> for Error {
56    fn from(error: InstantiateError) -> Self {
57        Error::Instantiate(error)
58    }
59}
60
61impl From<FuncError> for Error {
62    fn from(error: FuncError) -> Self {
63        Error::Func(error)
64    }
65}
66
67impl From<TableError> for Error {
68    fn from(error: TableError) -> Self {
69        Error::Table(error)
70    }
71}
72
73impl From<MemError> for Error {
74    fn from(error: MemError) -> Self {
75        Error::Memory(error)
76    }
77}
78
79impl From<GlobalError> for Error {
80    fn from(error: GlobalError) -> Self {
81        Error::Global(error)
82    }
83}
84
85impl From<Trap> for Error {
86    fn from(trap: Trap) -> Self {
87        Error::Trap(trap)
88    }
89}