1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69

// Copyright (c) Zefchain Labs, Inc.
// SPDX-License-Identifier: Apache-2.0

//! Wasmtime support for host functions exported to guests Wasm instances.

#![allow(clippy::let_unit_value)]

use wasmtime::{Caller, Linker, WasmRet, WasmTy};

use crate::{primitive_types::MaybeFlatType, ExportFunction, RuntimeError};

/// Implements [`ExportFunction`] for Wasmtime's [`Linker`] using the supported function
/// signatures.
macro_rules! export_function {
    ($( $names:ident: $types:ident ),*) => {
        impl<Handler, $( $types, )* FlatResult, Data>
            ExportFunction<Handler, ($( $types, )*), FlatResult> for Linker<Data>
        where
            $( $types: WasmTy, )*
            FlatResult: MaybeFlatType + WasmRet,
            Handler:
                Fn(Caller<'_, Data>, ($( $types, )*)) -> Result<FlatResult, RuntimeError>
                + Send
                + Sync
                + 'static,
        {
            fn export(
                &mut self,
                module_name: &str,
                function_name: &str,
                handler: Handler,
            ) -> Result<(), RuntimeError> {
                self.func_wrap(
                    module_name,
                    function_name,
                    move |
                        caller: Caller<'_, Data>,
                        $( $names: $types ),*
                    | -> anyhow::Result<FlatResult> {
                        let response = handler(caller, ($( $names, )*))?;
                        Ok(response)
                    },
                )
                .map_err(RuntimeError::Wasmtime)?;
                Ok(())
            }
        }
    };
}

repeat_macro!(export_function =>
    a: A,
    b: B,
    c: C,
    d: D,
    e: E,
    f: F,
    g: G,
    h: H,
    i: I,
    j: J,
    k: K,
    l: L,
    m: M,
    n: N,
    o: O,
    p: P,
    q: Q,
);