wasmer 7.1.0

High-performance WebAssembly runtime
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
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
121
122
123
124
125
126
127
128
129
130
131
132
133
134
135
136
137
138
139
140
141
142
143
144
145
146
147

use std::{any::Any, error::Error, fmt::Debug};

#[cfg(feature = "sys")]
use crate::BackendException;
use crate::{Exception, RuntimeError, macros::backend::match_rt};

/// An enumeration of all the trap kinds supported by the runtimes.
#[derive(Debug, derive_more::From)]
pub enum BackendTrap {
    #[cfg(feature = "sys")]
    /// The trap from the `sys` runtime.
    Sys(crate::backend::sys::vm::Trap),

    #[cfg(feature = "wamr")]
    /// The trap from the `wamr` runtime.
    Wamr(crate::backend::wamr::vm::Trap),

    #[cfg(feature = "wasmi")]
    /// The trap from the `wasmi` runtime.
    Wasmi(crate::backend::wasmi::vm::Trap),

    #[cfg(feature = "v8")]
    /// The trap from the `v8` runtime.
    V8(crate::backend::v8::vm::Trap),

    #[cfg(feature = "js")]
    /// The trap from the `js` runtime.
    Js(crate::backend::js::vm::Trap),

    #[cfg(feature = "jsc")]
    /// The trap from the `jsc` runtime.
    Jsc(crate::backend::jsc::vm::Trap),
}

impl BackendTrap {
    /// Construct a new Error with the given a user error.
    ///
    /// Internally saves a backtrace when constructed.
    pub fn user(err: Box<dyn Error + Send + Sync>) -> RuntimeError {
        #[cfg(feature = "sys")]
        {
            return crate::backend::sys::vm::Trap::user(err).into();
        }
        #[cfg(feature = "wamr")]
        {
            return crate::backend::wamr::vm::Trap::user(err).into();
        }

        #[cfg(feature = "wasmi")]
        {
            return crate::backend::wasmi::vm::Trap::user(err).into();
        }

        #[cfg(feature = "v8")]
        {
            return crate::backend::v8::vm::Trap::user(err).into();
        }
        #[cfg(feature = "js")]
        {
            return crate::backend::js::vm::Trap::user(err).into();
        }
        #[cfg(feature = "jsc")]
        {
            return crate::backend::jsc::vm::Trap::user(err).into();
        }

        panic!("No runtime enabled!")
    }
    /// Attempts to downcast the `Trap` to a concrete type.
    #[inline]
    pub fn downcast<T: Error + 'static>(self) -> Result<T, Self> {
        match_rt!(on self => s {
            s.downcast::<T>().map_err(Into::into)
        })
    }

    /// Attempts to downcast the `Trap` to a concrete type.
    #[inline]
    pub fn downcast_ref<T: Error + 'static>(&self) -> Option<&T> {
        match_rt!(on self => s {
            s.downcast_ref::<T>()
        })
    }

    /// Returns true if the `Trap` is the same as T
    #[inline]
    pub fn is<T: Error + 'static>(&self) -> bool {
        match_rt!(on self => s {
            s.is::<T>()
        })
    }

    /// Returns true if the trap is an exception
    #[inline]
    pub fn is_exception(&self) -> bool {
        match_rt!(on self => s {
            s.is_exception()
        })
    }

    /// If the `Trap` is an uncaught exception, returns it.
    #[inline]
    pub fn to_exception(&self) -> Option<Exception> {
        match self {
            #[cfg(feature = "sys")]
            Self::Sys(s) => s
                .to_exception_ref()
                .map(|e| Exception::from_vm_exceptionref(crate::vm::VMExceptionRef::Sys(e))),
            #[cfg(feature = "wamr")]
            Self::Wamr(s) => s
                .to_exception_ref()
                .map(|e| Exception::from_vm_exceptionref(crate::vm::VMExceptionRef::Wamr(e))),
            #[cfg(feature = "wasmi")]
            Self::Wasmi(s) => s
                .to_exception_ref()
                .map(|e| Exception::from_vm_exceptionref(crate::vm::VMExceptionRef::Wasmi(e))),
            #[cfg(feature = "v8")]
            Self::V8(s) => s
                .to_exception_ref()
                .map(|e| Exception::from_vm_exceptionref(crate::vm::VMExceptionRef::V8(e))),
            #[cfg(feature = "js")]
            Self::Js(s) => s
                .to_exception_ref()
                .map(|e| Exception::from_vm_exceptionref(crate::vm::VMExceptionRef::Js(e))),
            #[cfg(feature = "jsc")]
            Self::Jsc(s) => s
                .to_exception_ref()
                .map(|e| Exception::from_vm_exceptionref(crate::vm::VMExceptionRef::Jsc(e))),
        }
    }
}

impl std::fmt::Display for BackendTrap {
    fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
        match_rt!(on self => s {
            (s as &dyn std::fmt::Display).fmt(f)
        })
    }
}

impl std::error::Error for BackendTrap {
    fn source(&self) -> Option<&(dyn std::error::Error + 'static)> {
        match_rt!(on self => s {
            s.source()
        })
    }
}