use eyre::Result;

use tinywasm::{types::FuncRef, Extern, FuncContext, Imports, Module, Store};

use wat;

fn main() -> Result<()> {

by_func_ref_passed()?;

by_func_ref_returned()?;

Ok(())

fn by_func_ref_passed() -> Result<()> {

// a module with:

// imported function "host.call_this" that accepts a callback

// exported wasm function "tell_host_to_call" that calls "host.call_this" with wasm functions $add and $sub

// wasm functions $add and $sub and imported function $mul used as callbacks

// (just to show that imported functions can be referenced too)

// exported wasm function "call_binop_by_ref" is a proxy used by host to call func-references of type (i32, i32)->i32

const WASM: &str = r#"

let wasm = wat::parse_str(WASM).expect("failed to parse wat");

let module = Module::parse_bytes(&wasm)?;

let mut store = Store::default();

let mut imports = Imports::new();

// import host function that takes callbacks and calls them

imports.define(

"host",

"call_this",

Extern::typed_func(|mut ctx: FuncContext<'_>, fn_ref: FuncRef| -> tinywasm::Result<()> {

let proxy_caller =

ctx.module().exported_func::<(FuncRef, i32, i32), i32>(ctx.store(), "call_binop_by_ref")?;

// call callback we got as argument using call_binop_by_ref

let res = proxy_caller.call(ctx.store_mut(), (fn_ref, 5, 3))?;

println!("(funcref {fn_ref:?})(5,3) results in {res}");

Ok(())

}),

)?;

// import host.mul function (one of the functions whose references are taken)

imports.define(

"host",

"mul",

Extern::typed_func(|_, args: (i32, i32)| -> tinywasm::Result<i32> { Ok(args.0 * args.1) }),

)?;

let instance = module.instantiate(&mut store, Some(imports))?;

let caller = instance.exported_func::<(), ()>(&mut store, "tell_host_to_call")?;

// call the tell_host_to_call

caller.call(&mut store, ())?;

// interesting detail is that neither $add $sub $mul were exported,

// but with a little help from proxy "call_binop_by_ref" references to them host was able to call them

Ok(())

fn by_func_ref_returned() -> Result<()> {

// a module with:

// an exported function "what_should_host_call" that returns 3 funcrefs

// wasm functions $add and $sub and imported function $mul used as callbacks

// (just to show that imported functions can be referenced too)

// exported wasm function "call_binop_by_ref" is a proxy used by host to call func-references of type (i32, i32)->i32

const WASM: &str = r#"

let wasm = wat::parse_str(WASM).expect("failed to parse wat");

let module = Module::parse_bytes(&wasm)?;

let mut store = Store::default();

let mut imports = Imports::new();

// import host.mul function (one of the possible operations)

imports.define(

"host",

"mul",

Extern::typed_func(|_, args: (i32, i32)| -> tinywasm::Result<i32> { Ok(args.0 * args.1) }),

)?;

let instance = module.instantiate(&mut store, Some(imports))?;

{

// ask module what should we call

let funcrefs = {

let address_getter =

instance.exported_func::<(), (FuncRef, FuncRef, FuncRef)>(&mut store, "what_should_host_call")?;

address_getter.call(&mut store, ())?

};

let proxy_caller = instance.exported_func::<(FuncRef, i32, i32), i32>(&mut store, "call_binop_by_ref")?;

for (idx, func_ref) in [funcrefs.0, funcrefs.1, funcrefs.2].iter().enumerate() {

// call those funcrefs via "call_binop_by_ref"

let res = proxy_caller.call(&mut store, (*func_ref, 5, 3))?;

println!("at idx: {idx} funcref {func_ref:?}(5,3) results in {res}");

}

}

Ok(())