Skip to main content

wasmtime_c_api/types/
structref.rs

1use crate::{wasm_valtype_t, wasmtime_error_t};
2use std::mem::{ManuallyDrop, MaybeUninit};
3use wasmtime::{FieldType, Mutability, StorageType, StructType};
4
5#[repr(C, u8)]
6#[derive(Clone)]
7pub enum wasmtime_storage_type_t {
8    I8,
9    I16,
10    Val(Box<wasm_valtype_t>),
11}
12
13impl From<StorageType> for wasmtime_storage_type_t {
14    fn from(ty: StorageType) -> Self {
15        match ty {
16            StorageType::I8 => Self::I8,
17            StorageType::I16 => Self::I16,
18            StorageType::ValType(ty) => Self::Val(Box::new(ty)),
19        }
20    }
21}
22
23#[unsafe(no_mangle)]
24pub extern "C" fn wasmtime_storage_type_clone(
25    storage: &wasmtime_storage_type_t,
26    out: &mut MaybeUninit<wasmtime_storage_type_t>,
27) {
28    out.write(storage.clone());
29}
30
31#[unsafe(no_mangle)]
32pub unsafe extern "C" fn wasmtime_storage_type_delete(
33    out: Option<&mut ManuallyDrop<wasmtime_storage_type_t>>,
34) {
35    if let Some(out) = out {
36        unsafe {
37            ManuallyDrop::drop(out);
38        }
39    }
40}
41
42#[repr(C)]
43#[derive(Clone)]
44pub struct wasmtime_field_type_t {
45    pub mutable_: bool,
46    pub storage: wasmtime_storage_type_t,
47}
48
49impl From<FieldType> for wasmtime_field_type_t {
50    fn from(field: FieldType) -> Self {
51        let mutable_ = field.mutability() == Mutability::Var;
52        let storage = field.element_type().clone().into();
53        Self { mutable_, storage }
54    }
55}
56
57impl wasmtime_field_type_t {
58    pub(crate) fn to_wasmtime(&self) -> FieldType {
59        let mutability = if self.mutable_ {
60            Mutability::Var
61        } else {
62            Mutability::Const
63        };
64        let storage = match &self.storage {
65            wasmtime_storage_type_t::I8 => StorageType::I8,
66            wasmtime_storage_type_t::I16 => StorageType::I16,
67            wasmtime_storage_type_t::Val(ty) => StorageType::ValType((**ty).clone()),
68        };
69        FieldType::new(mutability, storage)
70    }
71}
72
73#[unsafe(no_mangle)]
74pub extern "C" fn wasmtime_field_type_clone(
75    field: &wasmtime_field_type_t,
76    out: &mut MaybeUninit<wasmtime_field_type_t>,
77) {
78    out.write(field.clone());
79}
80
81#[unsafe(no_mangle)]
82pub unsafe extern "C" fn wasmtime_field_type_delete(
83    out: Option<&mut ManuallyDrop<wasmtime_field_type_t>>,
84) {
85    if let Some(out) = out {
86        unsafe {
87            ManuallyDrop::drop(out);
88        }
89    }
90}
91
92#[derive(Clone)]
93pub struct wasmtime_struct_type_t {
94    pub(crate) ty: StructType,
95}
96wasmtime_c_api_macros::declare_ty!(wasmtime_struct_type_t);
97
98impl From<StructType> for wasmtime_struct_type_t {
99    fn from(ty: StructType) -> Self {
100        Self { ty }
101    }
102}
103
104#[unsafe(no_mangle)]
105pub extern "C" fn wasmtime_struct_type_new(
106    engine: &crate::wasm_engine_t,
107    fields: *const wasmtime_field_type_t,
108    nfields: usize,
109    out: &mut MaybeUninit<Box<wasmtime_struct_type_t>>,
110) -> Option<Box<wasmtime_error_t>> {
111    let fields = unsafe { crate::slice_from_raw_parts(fields, nfields) };
112    let field_types: Vec<FieldType> = fields.iter().map(|f| f.to_wasmtime()).collect();
113    crate::handle_result(StructType::new(&engine.engine, field_types), |ty| {
114        out.write(Box::new(wasmtime_struct_type_t { ty }));
115    })
116}
117
118#[unsafe(no_mangle)]
119pub extern "C" fn wasmtime_struct_type_num_fields(ty: &wasmtime_struct_type_t) -> usize {
120    ty.ty.fields().len()
121}
122
123#[unsafe(no_mangle)]
124pub extern "C" fn wasmtime_struct_type_field(
125    ty: &wasmtime_struct_type_t,
126    index: usize,
127    out: &mut MaybeUninit<wasmtime_field_type_t>,
128) -> bool {
129    match ty.ty.field(index) {
130        Some(field) => {
131            out.write(field.into());
132            true
133        }
134        None => false,
135    }
136}