Enum wasmer_interface_types::interpreter::Instruction

pub enum Instruction<'input> {
    ArgumentGet {
        index: u32,
    },
    Call {
        function_index: usize,
    },
    CallExport {
        export_name: &'input str,
    },
    ReadUtf8,
    WriteUtf8 {
        allocator_name: &'input str,
    },
    I32ToS8,
    I32ToS8X,
    I32ToU8,
    I32ToS16,
    I32ToS16X,
    I32ToU16,
    I32ToS32,
    I32ToU32,
    I32ToS64,
    I32ToU64,
    I64ToS8,
    I64ToS8X,
    I64ToU8,
    I64ToS16,
    I64ToS16X,
    I64ToU16,
    I64ToS32,
    I64ToS32X,
    I64ToU32,
    I64ToS64,
    I64ToU64,
    S8ToI32,
    U8ToI32,
    S16ToI32,
    U16ToI32,
    S32ToI32,
    U32ToI32,
    S64ToI32,
    S64ToI32X,
    U64ToI32,
    U64ToI32X,
    S8ToI64,
    U8ToI64,
    S16ToI64,
    U16ToI64,
    S32ToI64,
    U32ToI64,
    S64ToI64,
    U64ToI64,
}

Represents all the possible WIT instructions.

Variants

ArgumentGet

The arg.get instruction.

Fields of ArgumentGet

index: u32

The argument index.

Call

The call instruction.

Fields of Call

function_index: usize

The function index.

CallExport

The call-export instruction.

Fields of CallExport

export_name: &'input str

The exported function name.

ReadUtf8

The read-utf8 instruction.

WriteUtf8

The write-utf8 instruction.

Fields of WriteUtf8

allocator_name: &'input str

The allocator function name.

I32ToS8

The i32-to-s8, instruction.

I32ToS8X

The i32-to-s8x, instruction.

I32ToU8

The i32-to-u8, instruction.

I32ToS16

The i32-to-s16, instruction.

I32ToS16X

The i32-to-s16x, instruction.

I32ToU16

The i32-to-u16, instruction.

I32ToS32

The i32-to-s32, instruction.

I32ToU32

The i32-to-u32, instruction.

I32ToS64

The i32-to-s64, instruction.

I32ToU64

The i32-to-u64, instruction.

I64ToS8

The i64-to-s8, instruction.

I64ToS8X

The i64-to-s8x, instruction.

I64ToU8

The i64-to-u8, instruction.

I64ToS16

The i64-to-s16, instruction.

I64ToS16X

The i64-to-s16x, instruction.

I64ToU16

The i64-to-u16, instruction.

I64ToS32

The i64-to-s32, instruction.

I64ToS32X

The i64-to-s32x, instruction.

I64ToU32

The i64-to-u32, instruction.

I64ToS64

The i64-to-s64, instruction.

I64ToU64

The i64-to-u64, instruction.

S8ToI32

The s8-to-i32, instruction.

U8ToI32

The u8-to-i32, instruction.

S16ToI32

The s16-to-i32, instruction.

U16ToI32

The u16-to-i32, instruction.

S32ToI32

The s32-to-i32, instruction.

U32ToI32

The u32-to-i32, instruction.

S64ToI32

The s64-to-i32, instruction.

S64ToI32X

The s64-to-i32x, instruction.

U64ToI32

The u64-to-i32, instruction.

U64ToI32X

The u64-to-i32x, instruction.

S8ToI64

The s8-to-i64, instruction.

U8ToI64

The u8-to-i64, instruction.

S16ToI64

The s16-to-i64, instruction.

U16ToI64

The u16-to-i64, instruction.

S32ToI64

The s32-to-i64, instruction.

U32ToI64

The u32-to-i64, instruction.

S64ToI64

The s64-to-i64, instruction.

U64ToI64

The u64-to-i64, instruction.

Trait Implementations

impl<'input> Debug for Instruction<'input>

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

Formats the value using the given formatter.

impl<'a> Parse<'a> for Instruction<'a>

fn parse(parser: Parser<'a>) -> Result<Self>

Attempts to parse Self from parser, returning an error if it could not be parsed.

impl<'input> PartialEq<Instruction<'input>> for Instruction<'input>

fn eq(&self, other: &Instruction<'input>) -> bool

This method tests for self and other values to be equal, and is used by ==.

fn ne(&self, other: &Instruction<'input>) -> bool

This method tests for !=.

impl<'input> StructuralPartialEq for Instruction<'input>

impl<'_, W> ToBytes<W> for Instruction<'_> where
    W: Write, 

Encode an Instruction into bytes.

Decoder is decoders::binary::instruction.

fn to_bytes(&self, writer: &mut W) -> Result<()>

Converts the given value into &[u8] in the given writer.

impl<'input, '_> ToString for &'_ Instruction<'input>

Encode an Instruction into a string.

fn to_string(&self) -> String

Converts the given value to a String.