wasmtime-c-api-impl 45.0.0

C API to expose the Wasmtime runtime
Documentation 
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
70
71
72
73
74
75

use super::wasmtime_component_val_t;
use crate::{WasmtimeStoreContextMut, wasmtime_component_func_type_t, wasmtime_error_t};
use wasmtime::component::{Func, Val};

#[unsafe(no_mangle)]
pub unsafe extern "C" fn wasmtime_component_func_call(
    func: &Func,
    mut context: WasmtimeStoreContextMut<'_>,
    args: *const wasmtime_component_val_t,
    args_len: usize,
    results: *mut wasmtime_component_val_t,
    results_len: usize,
) -> Option<Box<wasmtime_error_t>> {
    let c_args = unsafe { crate::slice_from_raw_parts(args, args_len) };
    let c_results = unsafe { crate::slice_from_raw_parts_mut(results, results_len) };

    let args = c_args.iter().map(Val::from).collect::<Vec<_>>();
    let mut results = vec![Val::Bool(false); results_len];

    let result = func.call(&mut context, &args, &mut results);

    crate::handle_result(result, |_| {
        for (c_val, rust_val) in std::iter::zip(c_results, results) {
            *c_val = wasmtime_component_val_t::from(&rust_val);
        }
    })
}

#[unsafe(no_mangle)]
#[cfg(feature = "component-model-async")]
pub unsafe extern "C" fn wasmtime_component_func_call_async<'a>(
    func: &'a Func,
    mut context: WasmtimeStoreContextMut<'a>,
    args: *const wasmtime_component_val_t,
    args_len: usize,
    results: *mut wasmtime_component_val_t,
    results_len: usize,
    err_ret: &'a mut *mut wasmtime_error_t,
) -> Box<crate::wasmtime_call_future_t<'a>> {
    let c_args = unsafe { crate::slice_from_raw_parts(args, args_len) };
    let c_results = unsafe { crate::slice_from_raw_parts_mut(results, results_len) };
    let fut = Box::pin(async move {
        let args = c_args.iter().map(Val::from).collect::<Vec<_>>();
        let mut results = vec![Val::Bool(false); c_results.len()];

        match func.call_async(&mut context, &args, &mut results).await {
            Ok(()) => {
                for (c_val, rust_val) in std::iter::zip(c_results.iter_mut(), results) {
                    *c_val = wasmtime_component_val_t::from(&rust_val);
                }
            }
            Err(err) => {
                *err_ret = Box::into_raw(Box::new(wasmtime_error_t::from(err)));
            }
        }
    });
    Box::new(crate::wasmtime_call_future_t::new(fut))
}

#[deprecated(note = "no longer has any effect")]
#[unsafe(no_mangle)]
pub unsafe extern "C" fn wasmtime_component_func_post_return(
    _func: &Func,
    _context: WasmtimeStoreContextMut<'_>,
) -> Option<Box<wasmtime_error_t>> {
    None
}

#[unsafe(no_mangle)]
pub extern "C" fn wasmtime_component_func_type(
    func: &Func,
    context: WasmtimeStoreContextMut<'_>,
) -> Box<wasmtime_component_func_type_t> {
    Box::new(func.ty(context).into())
}