Struct wasmer_ruby::Wasmer::ImportObject

pub struct ImportObject;

An ImportObject represents all of the import data used when instantiating a WebAssembly module.

Example

Importing a function, math.sum, and call it through the exported add_one function:

def sum(x, y)
  x + y
end

store = Wasmer::Store.new
module_ = Wasmer::Module.new(
  store,
  (<<~WAST)
  (module
    (import "math" "sum" (func $sum (param i32 i32) (result i32)))
    (func (export "add_one") (param i32) (result i32)
      local.get 0
      i32.const 1
      call $sum))
  WAST
)

import_object = Wasmer::ImportObject.new
import_object.register(
  "math",
  {
    :sum => Wasmer::Function.new(
      store,
      method(:sum),
      Wasmer::FunctionType.new([Wasmer::Type::I32, Wasmer::Type::I32], [Wasmer::Type::I32])
    )
  }
)

instance = Wasmer::Instance.new module_, import_object

assert { instance.exports.add_one.(1) == 2 }

Importing a memory:

store = Wasmer::Store.new
module_ = Wasmer::Module.new(
  store,
  (<<~WAST)
  (module
    (import "env" "memory" (memory $memory 1))
    (func (export "increment")
      i32.const 0
      i32.const 0
      i32.load    ;; load 0
      i32.const 1
      i32.add     ;; add 1
      i32.store   ;; store at 0
      ))
  WAST
)

memory = Wasmer::Memory.new store, Wasmer::MemoryType.new(1, nil, false)
view = memory.uint8_view(0)

import_object = Wasmer::ImportObject.new
import_object.register(
  "env",
  {
    :memory => memory,
  }
)

instance = Wasmer::Instance.new module_, import_object

assert { view[0] == 0 }

instance.exports.increment.()
assert { view[0] == 1 }

instance.exports.increment.()
assert { view[0] == 2 }

Importing a global:

store = Wasmer::Store.new
module_ = Wasmer::Module.new(
  store,
  (<<~WAST)
    (module
      (import "env" "global" (global $global (mut i32)))
      (func (export "read_g") (result i32)
        global.get $global)
      (func (export "write_g") (param i32)
        local.get 0
        global.set $global))
  WAST
)

global = Wasmer::Global.new store, Wasmer::Value.i32(7), true

import_object = Wasmer::ImportObject.new
import_object.register(
  "env",
  {
    :global => global
  }
)

instance = Wasmer::Instance.new module_, import_object

assert { instance.exports.read_g.() == 7 }

global.value = 153
assert { instance.exports.read_g.() == 153 }

instance.exports.write_g.(11)
assert { global.value == 11 }

etc.

Implementations

impl ImportObject

pub fn new() -> Self

Creates a new ImportObject.

pub fn contains_namespace(&self, namespace_name: String) -> Boolean

Checks whether the import object contains a specific namespace.

pub fn register(&self, namespace_name: String, namespace: Hash<String, Any>)

Registers a set of Function, Memory, Global or Table to a particular namespace.

See the ImportObject’s documentation to see more examples.