Skip to main content

wasmtime_c_api/component/
component.rs

1#[cfg(any(feature = "cranelift", feature = "winch"))]
2use crate::wasm_byte_vec_t;
3use crate::{wasm_config_t, wasm_engine_t, wasmtime_component_type_t, wasmtime_error_t};
4use std::ffi::{CStr, c_char};
5use wasmtime::component::{Component, ComponentExportIndex};
6use wasmtime::error::Context;
7
8#[unsafe(no_mangle)]
9pub extern "C" fn wasmtime_config_wasm_component_model_set(c: &mut wasm_config_t, enable: bool) {
10    c.config.wasm_component_model(enable);
11}
12
13#[unsafe(no_mangle)]
14pub extern "C" fn wasmtime_config_wasm_component_model_map_set(
15    c: &mut wasm_config_t,
16    enable: bool,
17) {
18    c.config.wasm_component_model_map(enable);
19}
20
21#[unsafe(no_mangle)]
22pub extern "C" fn wasmtime_config_wasm_component_model_implements_set(
23    c: &mut wasm_config_t,
24    enable: bool,
25) {
26    c.config.wasm_component_model_implements(enable);
27}
28
29#[unsafe(no_mangle)]
30pub extern "C" fn wasmtime_config_wasm_component_model_canonical_names_set(
31    c: &mut wasm_config_t,
32    enable: bool,
33) {
34    c.config.wasm_component_model_canonical_names(enable);
35}
36
37#[unsafe(no_mangle)]
38#[cfg(feature = "component-model-async")]
39pub extern "C" fn wasmtime_config_wasm_component_model_async_set(
40    c: &mut wasm_config_t,
41    enable: bool,
42) {
43    c.config.wasm_component_model_async(enable);
44}
45
46#[unsafe(no_mangle)]
47#[cfg(feature = "component-model-async")]
48pub extern "C" fn wasmtime_config_wasm_component_model_more_async_builtins_set(
49    c: &mut wasm_config_t,
50    enable: bool,
51) {
52    c.config.wasm_component_model_more_async_builtins(enable);
53}
54
55#[unsafe(no_mangle)]
56#[cfg(feature = "component-model-async")]
57pub extern "C" fn wasmtime_config_wasm_component_model_async_stackful_set(
58    c: &mut wasm_config_t,
59    enable: bool,
60) {
61    c.config.wasm_component_model_async_stackful(enable);
62}
63
64#[derive(Clone)]
65#[repr(transparent)]
66pub struct wasmtime_component_t {
67    pub(crate) component: Component,
68}
69
70#[unsafe(no_mangle)]
71#[cfg(any(feature = "cranelift", feature = "winch"))]
72pub unsafe extern "C" fn wasmtime_component_new(
73    engine: &wasm_engine_t,
74    buf: *const u8,
75    len: usize,
76    component_out: &mut *mut wasmtime_component_t,
77) -> Option<Box<wasmtime_error_t>> {
78    let bytes = unsafe { crate::slice_from_raw_parts(buf, len) };
79    crate::handle_result(Component::new(&engine.engine, bytes), |component| {
80        *component_out = Box::into_raw(Box::new(wasmtime_component_t { component }));
81    })
82}
83
84#[unsafe(no_mangle)]
85#[cfg(any(feature = "cranelift", feature = "winch"))]
86pub extern "C" fn wasmtime_component_serialize(
87    component: &wasmtime_component_t,
88    ret: &mut wasm_byte_vec_t,
89) -> Option<Box<wasmtime_error_t>> {
90    crate::handle_result(component.component.serialize(), |buffer| {
91        ret.set_buffer(buffer);
92    })
93}
94
95#[unsafe(no_mangle)]
96pub unsafe extern "C" fn wasmtime_component_deserialize(
97    engine: &wasm_engine_t,
98    buf: *const u8,
99    len: usize,
100    component_out: &mut *mut wasmtime_component_t,
101) -> Option<Box<wasmtime_error_t>> {
102    let binary = unsafe { crate::slice_from_raw_parts(buf, len) };
103    crate::handle_result(
104        unsafe { Component::deserialize(&engine.engine, binary) },
105        |component| {
106            *component_out = Box::into_raw(Box::new(wasmtime_component_t { component }));
107        },
108    )
109}
110
111#[unsafe(no_mangle)]
112pub unsafe extern "C" fn wasmtime_component_deserialize_file(
113    engine: &wasm_engine_t,
114    path: *const c_char,
115    component_out: &mut *mut wasmtime_component_t,
116) -> Option<Box<wasmtime_error_t>> {
117    let path = unsafe { CStr::from_ptr(path) };
118    let result = path
119        .to_str()
120        .context("input path is not valid utf-8")
121        .and_then(|path| unsafe { Component::deserialize_file(&engine.engine, path) });
122    crate::handle_result(result, |component| {
123        *component_out = Box::into_raw(Box::new(wasmtime_component_t { component }));
124    })
125}
126
127#[unsafe(no_mangle)]
128pub extern "C" fn wasmtime_component_type(
129    component: &wasmtime_component_t,
130) -> Box<wasmtime_component_type_t> {
131    Box::new(component.component.component_type().into())
132}
133
134#[unsafe(no_mangle)]
135pub extern "C" fn wasmtime_component_clone(
136    component: &wasmtime_component_t,
137) -> Box<wasmtime_component_t> {
138    Box::new(component.clone())
139}
140
141#[unsafe(no_mangle)]
142pub extern "C" fn wasmtime_component_delete(_component: Box<wasmtime_component_t>) {}
143
144#[repr(transparent)]
145pub struct wasmtime_component_export_index_t {
146    pub(crate) export_index: ComponentExportIndex,
147}
148
149#[unsafe(no_mangle)]
150pub unsafe extern "C" fn wasmtime_component_get_export_index(
151    component: &wasmtime_component_t,
152    instance_export_index: *const wasmtime_component_export_index_t,
153    name: *const u8,
154    name_len: usize,
155) -> Option<Box<wasmtime_component_export_index_t>> {
156    let name = unsafe { std::slice::from_raw_parts(name, name_len) };
157    let Ok(name) = std::str::from_utf8(name) else {
158        return None;
159    };
160
161    let instance_export_index = if instance_export_index.is_null() {
162        None
163    } else {
164        Some((*instance_export_index).export_index)
165    };
166
167    component
168        .component
169        .get_export_index(instance_export_index.as_ref(), &name)
170        .map(|export_index| Box::new(wasmtime_component_export_index_t { export_index }))
171}
172
173#[unsafe(no_mangle)]
174pub extern "C" fn wasmtime_component_export_index_clone(
175    export_index: &wasmtime_component_export_index_t,
176) -> Box<wasmtime_component_export_index_t> {
177    Box::new(wasmtime_component_export_index_t {
178        export_index: export_index.export_index,
179    })
180}
181
182#[unsafe(no_mangle)]
183pub extern "C" fn wasmtime_component_export_index_delete(
184    _export_index: Box<wasmtime_component_export_index_t>,
185) {
186}