Enum WasmTrap 

pub enum WasmTrap {
    Unreachable,
    IncorrectCallIndirectSignature,
    MemoryOutOfBounds,
    CallIndirectOOB,
    IllegalArithmetic,
    MisalignedAtomicAccess,
    IndirectCallToNull,
    StackOverflow,
    GenericTrap,
}

A kind of a trap happened during execution of a binary

Variants

Unreachable

An unreachable opcode was executed.

IncorrectCallIndirectSignature

Call indirect incorrect signature trap.

MemoryOutOfBounds

Memory out of bounds trap.

CallIndirectOOB

Call indirect out of bounds trap.

IllegalArithmetic

An arithmetic exception, e.g. divided by zero.

MisalignedAtomicAccess

Misaligned atomic access trap.

IndirectCallToNull

Indirect call to null.

StackOverflow

Stack overflow.

GenericTrap

Generic trap.

Implementations

impl WasmTrap

pub fn __hash__(&self) -> u64

Trait Implementations

impl Clone for WasmTrap

fn clone(&self) -> WasmTrap

Returns a duplicate of the value.

fn clone_from(&mut self, source: &Self)

Performs copy-assignment from source.

impl Debug for WasmTrap

fn fmt(&self, f: &mut Formatter<'_>) -> Result

Formats the value using the given formatter.

impl<'de> Deserialize<'de> for WasmTrap

fn deserialize<__D>(__deserializer: __D) -> Result<Self, __D::Error>

where __D: Deserializer<'de>,

Deserialize this value from the given Serde deserializer.

impl Display for WasmTrap

fn fmt(&self, f: &mut Formatter<'_>) -> Result<(), Error>

Formats the value using the given formatter.

impl From<WasmTrap> for WasmTrap

fn from(left: WasmTrapOriginal) -> Self

Converts to this type from the input type.

impl From<WasmTrap> for WasmTrap

fn from(left: WasmTrap) -> Self

Converts to this type from the input type.

impl Hash for WasmTrap

fn hash<__H: Hasher>(&self, state: &mut __H)

Feeds this value into the given Hasher.

fn hash_slice<H>(data: &[Self], state: &mut H)

where H: Hasher, Self: Sized,

Feeds a slice of this type into the given Hasher.

impl IntoPy<Py<PyAny>> for WasmTrap

fn into_py(self, py: Python<'_>) -> PyObject

Performs the conversion.

impl PartialEq for WasmTrap

fn eq(&self, other: &WasmTrap) -> bool

Tests for self and other values to be equal, and is used by ==.

fn ne(&self, other: &Rhs) -> bool

Tests for !=. The default implementation is almost always sufficient, and should not be overridden without very good reason.

impl PyClass for WasmTrap

type Frozen = False

Whether the pyclass is frozen.

impl PyClassImpl for WasmTrap

const DOC: &'static str = "A kind of a trap happened during execution of a binary\u{0}"

Class doc string

const IS_BASETYPE: bool = false

#[pyclass(subclass)]

const IS_SUBCLASS: bool = false

#[pyclass(extends=…)]

const IS_MAPPING: bool = false

#[pyclass(mapping)]

const IS_SEQUENCE: bool = false

#[pyclass(sequence)]

type Layout = PyCell<WasmTrap>

Layout

type BaseType = PyAny

Base class

type ThreadChecker = ThreadCheckerStub<WasmTrap>

This handles following two situations:

type PyClassMutability = <<PyAny as PyClassBaseType>::PyClassMutability as PyClassMutability>::MutableChild

Immutable or mutable

type Dict = PyClassDummySlot

Specify this class has #[pyclass(dict)] or not.

type WeakRef = PyClassDummySlot

Specify this class has #[pyclass(weakref)] or not.

type BaseNativeType = PyAny

The closest native ancestor. This is PyAny by default, and when you declare #[pyclass(extends=PyDict)], it’s PyDict.

fn items_iter() -> PyClassItemsIter

fn lazy_type_object() -> &'static LazyTypeObject<Self>

fn dict_offset() -> Option<isize>

fn weaklist_offset() -> Option<isize>

impl<'a, 'py> PyFunctionArgument<'a, 'py> for &'a WasmTrap

type Holder = Option<PyRef<'py, WasmTrap>>

fn extract(obj: &'py PyAny, holder: &'a mut Self::Holder) -> PyResult<Self>

impl<'a, 'py> PyFunctionArgument<'a, 'py> for &'a mut WasmTrap

type Holder = Option<PyRefMut<'py, WasmTrap>>

fn extract(obj: &'py PyAny, holder: &'a mut Self::Holder) -> PyResult<Self>

impl PyHash for WasmTrap

fn pyhash(&self) -> u64

impl PyMethods<WasmTrap> for PyClassImplCollector<WasmTrap>

fn py_methods(self) -> &'static PyClassItems

impl PyTypeInfo for WasmTrap

const NAME: &'static str = "WasmTrap"

Class name.

const MODULE: Option<&'static str>

Module name, if any.

type AsRefTarget = PyCell<WasmTrap>

Utility type to make Py::as_ref work.

fn type_object_raw(py: Python<'_>) -> *mut PyTypeObject

Returns the PyTypeObject instance for this type.

fn type_object(py: Python<'_>) -> &PyType

Returns the safe abstraction over the type object.

fn is_type_of(object: &PyAny) -> bool

Checks if object is an instance of this type or a subclass of this type.

fn is_exact_type_of(object: &PyAny) -> bool

Checks if object is an instance of this type.

impl Serialize for WasmTrap

fn serialize<__S>(&self, __serializer: __S) -> Result<__S::Ok, __S::Error>

where __S: Serializer,

Serialize this value into the given Serde serializer.

impl Copy for WasmTrap

impl Eq for WasmTrap

impl StructuralPartialEq for WasmTrap