Method call_untyped

crates/tinywasm/src/func.rs:323–359

Call a function from within the current host-function invocation. This is the safe way for host functions to perform blocking reentrant calls into Wasm. Unlike [`Function::call`], it preserves the active invocation's stacks and resumes the host caller after the nested call completes. Nested calls are currently blocking only. If the surrounding invocation is resumed with fuel or a time budget, th

(&mut self, func: &Function, args: &[WasmValue])

    /// is resumed with fuel or a time budget, this method does not suspend and
    /// later continue the host function in the middle of the nested call.
    pub fn call_untyped(&mut self, func: &Function, args: &[WasmValue]) -> Result<Vec<WasmValue>> {
        if !self.store.execution_active {
            return Err(Error::other("FuncContext::call requires an active host-function invocation"));
        }

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

        let func_instance = self.store.state.get_func(func.addr).clone();
        match func_instance {
            FunctionInstance::Host(host_func) => {
                host_func.call(FuncContext { store: &mut *self.store, module_addr: func.module_addr }, args)
            }
            FunctionInstance::Wasm(wasm_func) => {
                let call_stack_base = self.store.call_stack.len();
                let value_stack_base = self.store.value_stack.base();

                self.store.value_stack.extend_from_wasmvalues(args).inspect_err(|_| {
                    self.store.value_stack.truncate_to_base(value_stack_base);
                })?;

                let locals_base = self
                    .store
                    .value_stack
                    .enter_locals(&wasm_func.func.params, &wasm_func.func.locals)
                    .inspect_err(|_| self.store.value_stack.truncate_to_base(value_stack_base))?;

                let callframe = CallFrame::new(func.addr, locals_base, wasm_func.func.locals);
                InterpreterRuntime::exec(self.store, callframe, call_stack_base).inspect_err(|_| {
                    self.store.call_stack.truncate_to(call_stack_base);
                    self.store.value_stack.truncate_to_base(value_stack_base);
                })?;

                collect_call_results(&mut self.store.value_stack, &func.ty)
            }
        }
    }

    /// Call a typed function from within the current host-function invocation.
    ///