Struct wasm_encoder::Function

pub struct Function { /* private fields */ }

An encoder for a function body within the code section.

Example

use wasm_encoder::{CodeSection, Function, Instruction};

// Define the function body for:
//
//     (func (param i32 i32) (result i32)
//       local.get 0
//       local.get 1
//       i32.add)
let locals = vec![];
let mut func = Function::new(locals);
func.instruction(&Instruction::LocalGet(0));
func.instruction(&Instruction::LocalGet(1));
func.instruction(&Instruction::I32Add);

// Add our function to the code section.
let mut code = CodeSection::new();
code.function(&func);

Implementations

impl Function

pub fn new<L>(locals: L) -> Self

where L: IntoIterator<Item = (u32, ValType)>, L::IntoIter: ExactSizeIterator,

Create a new function body with the given locals.

The argument is an iterator over (N, Ty), which defines that the next N locals will be of type Ty.

For example, a function with locals 0 and 1 of type I32 and local 2 of type F32 would be created as:

let f = Function::new([(2, ValType::I32), (1, ValType::F32)]);

For more information about the code section (and function definition) in the WASM binary format see the WebAssembly spec

pub fn new_with_locals_types<L>(locals: L) -> Self

where L: IntoIterator<Item = ValType>,

Create a function from a list of locals’ types.

Unlike Function::new, this constructor simply takes a list of types which are in order associated with locals.

For example:

let f = Function::new([(2, ValType::I32), (1, ValType::F32)]);
let g = Function::new_with_locals_types([
   ValType::I32, ValType::I32, ValType::F32
]);

assert_eq!(f, g)

pub fn instruction(&mut self, instruction: &Instruction<'_>) -> &mut Self

Write an instruction into this function body.

pub fn raw<B>(&mut self, bytes: B) -> &mut Self

where B: IntoIterator<Item = u8>,

Add raw bytes to this function’s body.

pub fn byte_len(&self) -> usize

The number of bytes already added to this function.

This number doesn’t include the variable-width size field that encode will write before the added bytes, since the size of that field isn’t known until all the instructions are added to this function.

Trait Implementations

impl Clone for Function

fn clone(&self) -> Function

Returns a copy of the value.

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

Performs copy-assignment from source.

impl Debug for Function

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

Formats the value using the given formatter.

impl Encode for Function

fn encode(&self, sink: &mut Vec<u8>)

Encode the type into the given byte sink.

impl PartialEq for Function

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

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

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

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

impl Eq for Function

impl StructuralPartialEq for Function