Struct patract_wasmi::Module

pub struct Module { /* fields omitted */ }

Deserialized module prepared for instantiation.

Implementations

impl Module

pub fn from_parity_wasm_module(module: Module) -> Result<Module, Error>

Create Module from parity_wasm::elements::Module.

This function will load, validate and prepare a parity_wasm’s Module.

Errors

Returns Err if provided Module is not valid.

Examples

extern crate parity_wasm;
extern crate patract_wasmi;

use parity_wasm::builder;
use parity_wasm::elements;

fn main() {
    let parity_module =
        builder::module()
            .function()
                .signature().with_param(elements::ValueType::I32).build()
                .body().build()
            .build()
        .build();

    let module = patract_wasmi::Module::from_parity_wasm_module(parity_module)
        .expect("parity-wasm builder generated invalid module!");

    // Instantiate `module`, etc...
}

pub fn deny_floating_point(&self) -> Result<(), Error>

Fail if the module contains any floating-point operations

Errors

Returns Err if provided Module is not valid.

Examples

let wasm_binary: Vec<u8> =
    wabt::wat2wasm(
        r#"
        (module
         (func $add (param $lhs i32) (param $rhs i32) (result i32)
               get_local $lhs
               get_local $rhs
               i32.add))
        "#,
    )
    .expect("failed to parse wat");

// Load wasm binary and prepare it for instantiation.
let module = patract_wasmi::Module::from_buffer(&wasm_binary).expect("Parsing failed");
assert!(module.deny_floating_point().is_ok());

let wasm_binary: Vec<u8> =
    wabt::wat2wasm(
        r#"
        (module
         (func $add (param $lhs f32) (param $rhs f32) (result f32)
               get_local $lhs
               get_local $rhs
               f32.add))
        "#,
    )
    .expect("failed to parse wat");

let module = patract_wasmi::Module::from_buffer(&wasm_binary).expect("Parsing failed");
assert!(module.deny_floating_point().is_err());

let wasm_binary: Vec<u8> =
    wabt::wat2wasm(
        r#"
        (module
         (func $add (param $lhs f32) (param $rhs f32) (result f32)
               get_local $lhs))
        "#,
    )
    .expect("failed to parse wat");

let module = patract_wasmi::Module::from_buffer(&wasm_binary).expect("Parsing failed");
assert!(module.deny_floating_point().is_err());

pub fn from_buffer<B: AsRef<[u8]>>(buffer: B) -> Result<Module, Error>

Create Module from a given buffer.

This function will deserialize wasm module from a given module, validate and prepare it for instantiation.

Errors

Returns Err if wasm binary in provided buffer is not valid wasm binary.

Examples

extern crate patract_wasmi;

fn main() {
    let module =
        patract_wasmi::Module::from_buffer(
            // Minimal module:
            //   \0asm - magic
            //    0x01 - version (in little-endian)
            &[0x00, 0x61, 0x73, 0x6d, 0x01, 0x00, 0x00, 0x00]
        ).expect("Failed to load minimal module");

    // Instantiate `module`, etc...
}

pub fn parse_names(self) -> Result<Module, Error>

Try to parse name section in place.

Corresponding custom section with proper header will convert to name sections If some of them will fail to be decoded, Err variant is returned with the list of (index, Error) tuples of failed sections.

pub fn try_parse_names(self) -> Module

Same as parse_names, but without error returns.