1 use crate::{
2     wasm_extern_t, wasm_extern_vec_t, wasm_module_t, wasm_store_t, wasm_trap_t, wasmtime_error_t,
3     wasmtime_extern_t, wasmtime_module_t, CStoreContextMut, StoreRef,
4 };
5 use std::mem::MaybeUninit;
6 use wasmtime::{Instance, Trap};
7 
8 #[derive(Clone)]
9 pub struct wasm_instance_t {
10     store: StoreRef,
11     instance: Instance,
12 }
13 
14 wasmtime_c_api_macros::declare_ref!(wasm_instance_t);
15 
16 impl wasm_instance_t {
17     pub(crate) fn new(store: StoreRef, instance: Instance) -> wasm_instance_t {
18         wasm_instance_t { store, instance }
19     }
20 }
21 
22 #[no_mangle]
23 pub unsafe extern "C" fn wasm_instance_new(
24     store: &mut wasm_store_t,
25     wasm_module: &wasm_module_t,
26     imports: *const wasm_extern_vec_t,
27     result: Option<&mut *mut wasm_trap_t>,
28 ) -> Option<Box<wasm_instance_t>> {
29     let imports = (*imports)
30         .as_slice()
31         .iter()
32         .filter_map(|import| match import {
33             Some(i) => Some(i.which.clone()),
34             None => None,
35         })
36         .collect::<Vec<_>>();
37     match Instance::new(store.store.context_mut(), &wasm_module.module, &imports) {
38         Ok(instance) => Some(Box::new(wasm_instance_t::new(
39             store.store.clone(),
40             instance,
41         ))),
42         Err(e) => {
43             if let Some(ptr) = result {
44                 *ptr = Box::into_raw(Box::new(wasm_trap_t::new(e)));
45             }
46             None
47         }
48     }
49 }
50 
51 #[no_mangle]
52 pub unsafe extern "C" fn wasm_instance_exports(
53     instance: &mut wasm_instance_t,
54     out: &mut wasm_extern_vec_t,
55 ) {
56     let store = instance.store.clone();
57     out.set_buffer(
58         instance
59             .instance
60             .exports(instance.store.context_mut())
61             .map(|e| {
62                 Some(Box::new(wasm_extern_t {
63                     which: e.into_extern(),
64                     store: store.clone(),
65                 }))
66             })
67             .collect(),
68     );
69 }
70 
71 #[no_mangle]
72 pub unsafe extern "C" fn wasmtime_instance_new(
73     store: CStoreContextMut<'_>,
74     module: &wasmtime_module_t,
75     imports: *const wasmtime_extern_t,
76     nimports: usize,
77     instance: &mut Instance,
78     trap_ptr: &mut *mut wasm_trap_t,
79 ) -> Option<Box<wasmtime_error_t>> {
80     let imports = crate::slice_from_raw_parts(imports, nimports)
81         .iter()
82         .map(|i| i.to_extern())
83         .collect::<Vec<_>>();
84     handle_instantiate(
85         Instance::new(store, &module.module, &imports),
86         instance,
87         trap_ptr,
88     )
89 }
90 
91 pub(crate) fn handle_instantiate(
92     instance: anyhow::Result<Instance>,
93     instance_ptr: &mut Instance,
94     trap_ptr: &mut *mut wasm_trap_t,
95 ) -> Option<Box<wasmtime_error_t>> {
96     match instance {
97         Ok(i) => {
98             *instance_ptr = i;
99             None
100         }
101         Err(e) => match e.downcast::<Trap>() {
102             Ok(trap) => {
103                 *trap_ptr = Box::into_raw(Box::new(wasm_trap_t::new(trap.into())));
104                 None
105             }
106             Err(e) => Some(Box::new(e.into())),
107         },
108     }
109 }
110 
111 #[no_mangle]
112 pub unsafe extern "C" fn wasmtime_instance_export_get(
113     store: CStoreContextMut<'_>,
114     instance: &Instance,
115     name: *const u8,
116     name_len: usize,
117     item: &mut MaybeUninit<wasmtime_extern_t>,
118 ) -> bool {
119     let name = crate::slice_from_raw_parts(name, name_len);
120     let name = match std::str::from_utf8(name) {
121         Ok(name) => name,
122         Err(_) => return false,
123     };
124     match instance.get_export(store, name) {
125         Some(e) => {
126             crate::initialize(item, e.into());
127             true
128         }
129         None => false,
130     }
131 }
132 
133 #[no_mangle]
134 pub unsafe extern "C" fn wasmtime_instance_export_nth(
135     store: CStoreContextMut<'_>,
136     instance: &Instance,
137     index: usize,
138     name_ptr: &mut *const u8,
139     name_len: &mut usize,
140     item: &mut MaybeUninit<wasmtime_extern_t>,
141 ) -> bool {
142     match instance.exports(store).nth(index) {
143         Some(e) => {
144             *name_ptr = e.name().as_ptr();
145             *name_len = e.name().len();
146             crate::initialize(item, e.into_extern().into());
147             true
148         }
149         None => false,
150     }
151 }
152