wasmtime_c_api/component/
component.rs1#[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}