Method call_resumable

crates/tinywasm/src/func.rs:50–90

Call a function and return a resumable execution handle. The returned handle keeps a mutable borrow of the [`Store`] until it completes. Use [`FuncExecution::resume_with_fuel`] (or [`FuncExecution::resume_with_time_budget`] with `std`) to continue.

(
        &self,
        store: &'store mut Store,
        params: &[WasmValue],
    )

    /// completes. Use [`FuncExecution::resume_with_fuel`] (or
    /// [`FuncExecution::resume_with_time_budget`] with `std`) to continue.
    pub fn call_resumable<'store>(
        &self,
        store: &'store mut Store,
        params: &[WasmValue],
    ) -> Result<FuncExecution<'store>> {
        #[inline]
        fn call_resumable_inner(
            func: &Function,
            store: &mut Store,
            params: &[WasmValue],
        ) -> Result<FuncExecutionState> {
            let func_instance = store.state.get_func(func.addr);
            match func_instance {
                FunctionInstance::Host(host_func) => host_func
                    .clone()
                    .call(FuncContext { store, module_addr: func.module_addr }, params)
                    .map(|result| FuncExecutionState::Completed { result: Some(result) }),
                FunctionInstance::Wasm(wasm_func) => {
                    store.call_stack.clear();
                    store.value_stack.clear();
                    store.value_stack.extend_from_wasmvalues(params)?;
                    let locals_base = store.value_stack.enter_locals(&wasm_func.func.params, &wasm_func.func.locals)?;
                    let callframe = CallFrame::new(func.addr, locals_base, wasm_func.func.locals);

                    Ok(FuncExecutionState::Running {
                        exec_state: ExecutionState { callframe },
                        root_func_addr: func.addr,
                    })
                }
            }
        }

        self.item.validate_store(store)?;
        validate_call_params(&self.ty, params)?;

        store.enter_execution()?;
        let result = call_resumable_inner(self, store, params);
        store.exit_execution();

        Ok(FuncExecution { store, state: result? })
    }
}

#[derive(Clone, PartialEq, Eq)]