makepad-stitch 0.1.0

An experimental Wasm interpreter written in Rust that is designed to be very fast and lightweight.
Documentation 
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89

use {
    crate::{
        decode::DecodeError, func::FuncError, global::GlobalError, linker::InstantiateError,
        mem::MemError, table::TableError, trap::Trap,
    },
    std::{error, fmt},
};

/// An error that can occur when operating on a [`Module`](crate::Module) or [`Func`](crate::Func).
#[derive(Debug)]
pub enum Error {
    Decode(DecodeError),
    Instantiate(InstantiateError),
    Func(FuncError),
    Table(TableError),
    Memory(MemError),
    Global(GlobalError),
    Trap(Trap),
}

impl error::Error for Error {
    fn source(&self) -> Option<&(dyn error::Error + 'static)> {
        match self {
            Error::Decode(error) => Some(error),
            Error::Instantiate(error) => Some(error),
            Error::Func(error) => Some(error),
            Error::Table(error) => Some(error),
            Error::Memory(error) => Some(error),
            Error::Global(error) => Some(error),
            Error::Trap(error) => Some(error),
        }
    }
}

impl fmt::Display for Error {
    fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result {
        match self {
            Error::Decode(_) => write!(f, "decode error"),
            Error::Instantiate(_) => write!(f, "instantiate error"),
            Error::Func(_) => write!(f, "function error"),
            Error::Table(_) => write!(f, "table error"),
            Error::Memory(_) => write!(f, "memory error"),
            Error::Global(_) => write!(f, "global error"),
            Error::Trap(_) => write!(f, "trap"),
        }
    }
}

impl From<DecodeError> for Error {
    fn from(error: DecodeError) -> Self {
        Error::Decode(error)
    }
}

impl From<InstantiateError> for Error {
    fn from(error: InstantiateError) -> Self {
        Error::Instantiate(error)
    }
}

impl From<FuncError> for Error {
    fn from(error: FuncError) -> Self {
        Error::Func(error)
    }
}

impl From<TableError> for Error {
    fn from(error: TableError) -> Self {
        Error::Table(error)
    }
}

impl From<MemError> for Error {
    fn from(error: MemError) -> Self {
        Error::Memory(error)
    }
}

impl From<GlobalError> for Error {
    fn from(error: GlobalError) -> Self {
        Error::Global(error)
    }
}

impl From<Trap> for Error {
    fn from(trap: Trap) -> Self {
        Error::Trap(trap)
    }
}