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
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
121
122
123
124
125
126
127
128

use crate::{WasmtimeStoreContextMut, wasmtime_anyref_t, wasmtime_array_type_t, wasmtime_eqref_t};
use std::mem::MaybeUninit;
use wasmtime::{ArrayRef, ArrayRefPre, OwnedRooted, RootScope};

crate::anyref::ref_wrapper!({
    wasmtime: ArrayRef,
    capi: wasmtime_arrayref_t,
    clone: wasmtime_arrayref_clone,
    unroot: wasmtime_arrayref_unroot,
});

pub struct wasmtime_array_ref_pre_t {
    pre: ArrayRefPre,
}
wasmtime_c_api_macros::declare_own!(wasmtime_array_ref_pre_t);

#[unsafe(no_mangle)]
pub extern "C" fn wasmtime_array_ref_pre_new(
    cx: WasmtimeStoreContextMut<'_>,
    ty: &wasmtime_array_type_t,
) -> Box<wasmtime_array_ref_pre_t> {
    let pre = ArrayRefPre::new(cx, ty.ty.clone());
    Box::new(wasmtime_array_ref_pre_t { pre })
}

#[unsafe(no_mangle)]
pub unsafe extern "C" fn wasmtime_arrayref_new(
    mut cx: WasmtimeStoreContextMut<'_>,
    pre: &wasmtime_array_ref_pre_t,
    elem: &crate::wasmtime_val_t,
    len: u32,
    out: &mut MaybeUninit<wasmtime_arrayref_t>,
) -> Option<Box<crate::wasmtime_error_t>> {
    let mut scope = RootScope::new(&mut cx);
    let val = elem.to_val(&mut scope);
    match ArrayRef::new(&mut scope, &pre.pre, &val, len) {
        Ok(arrayref) => {
            let owned = arrayref
                .to_owned_rooted(&mut scope)
                .expect("just allocated");
            crate::initialize(out, Some(owned).into());
            None
        }
        Err(e) => {
            crate::initialize(out, None::<OwnedRooted<ArrayRef>>.into());
            Some(Box::new(e.into()))
        }
    }
}

#[unsafe(no_mangle)]
pub unsafe extern "C" fn wasmtime_arrayref_to_anyref(
    arrayref: Option<&wasmtime_arrayref_t>,
    out: &mut MaybeUninit<wasmtime_anyref_t>,
) {
    let anyref = arrayref
        .and_then(|a| a.as_wasmtime())
        .map(|a| a.to_anyref());
    crate::initialize(out, anyref.into());
}

#[unsafe(no_mangle)]
pub unsafe extern "C" fn wasmtime_arrayref_to_eqref(
    arrayref: Option<&wasmtime_arrayref_t>,
    out: &mut MaybeUninit<wasmtime_eqref_t>,
) {
    let eqref = arrayref.and_then(|a| a.as_wasmtime()).map(|a| a.to_eqref());
    crate::initialize(out, eqref.into());
}

#[unsafe(no_mangle)]
pub unsafe extern "C" fn wasmtime_arrayref_len(
    cx: WasmtimeStoreContextMut<'_>,
    arrayref: Option<&wasmtime_arrayref_t>,
    out: &mut MaybeUninit<u32>,
) -> Option<Box<crate::wasmtime_error_t>> {
    let arrayref = arrayref
        .and_then(|a| a.as_wasmtime())
        .expect("non-null arrayref required");
    match arrayref.len(&cx) {
        Ok(len) => {
            crate::initialize(out, len);
            None
        }
        Err(e) => Some(Box::new(e.into())),
    }
}

#[unsafe(no_mangle)]
pub unsafe extern "C" fn wasmtime_arrayref_get(
    mut cx: WasmtimeStoreContextMut<'_>,
    arrayref: Option<&wasmtime_arrayref_t>,
    index: u32,
    out: &mut MaybeUninit<crate::wasmtime_val_t>,
) -> Option<Box<crate::wasmtime_error_t>> {
    let arrayref = arrayref
        .and_then(|a| a.as_wasmtime())
        .expect("non-null arrayref required");
    let mut scope = RootScope::new(&mut cx);
    let rooted = arrayref.to_rooted(&mut scope);
    match rooted.get(&mut scope, index) {
        Ok(val) => {
            let c_val = crate::wasmtime_val_t::from_val(&mut scope, val);
            crate::initialize(out, c_val);
            None
        }
        Err(e) => Some(Box::new(e.into())),
    }
}

#[unsafe(no_mangle)]
pub unsafe extern "C" fn wasmtime_arrayref_set(
    mut cx: WasmtimeStoreContextMut<'_>,
    arrayref: Option<&wasmtime_arrayref_t>,
    index: u32,
    val: &crate::wasmtime_val_t,
) -> Option<Box<crate::wasmtime_error_t>> {
    let arrayref = arrayref
        .and_then(|a| a.as_wasmtime())
        .expect("non-null arrayref required");
    let mut scope = RootScope::new(&mut cx);
    let rooted = arrayref.to_rooted(&mut scope);
    let rust_val = val.to_val(&mut scope);
    match rooted.set(&mut scope, index, rust_val) {
        Ok(()) => None,
        Err(e) => Some(Box::new(e.into())),
    }
}