1pub const _VCRT_COMPILER_PREPROCESSOR: u32 = 1;
4pub const _SAL_VERSION: u32 = 20;
5pub const __SAL_H_VERSION: u32 = 180000000;
6pub const _USE_DECLSPECS_FOR_SAL: u32 = 0;
7pub const _USE_ATTRIBUTES_FOR_SAL: u32 = 0;
8pub const _CRT_PACKING: u32 = 8;
9pub const _HAS_EXCEPTIONS: u32 = 1;
10pub const _STL_LANG: u32 = 0;
11pub const _HAS_CXX17: u32 = 0;
12pub const _HAS_CXX20: u32 = 0;
13pub const _HAS_CXX23: u32 = 0;
14pub const _HAS_NODISCARD: u32 = 0;
15pub const _ARGMAX: u32 = 100;
16pub const _CRT_INT_MAX: u32 = 2147483647;
17pub const _CRT_FUNCTIONS_REQUIRED: u32 = 1;
18pub const _CRT_HAS_CXX17: u32 = 0;
19pub const _ARM_WINAPI_PARTITION_DESKTOP_SDK_AVAILABLE: u32 = 1;
20pub const _CRT_BUILD_DESKTOP_APP: u32 = 1;
21pub const _CRT_INTERNAL_NONSTDC_NAMES: u32 = 1;
22pub const __STDC_SECURE_LIB__: u32 = 200411;
23pub const __GOT_SECURE_LIB__: u32 = 200411;
24pub const __STDC_WANT_SECURE_LIB__: u32 = 1;
25pub const _SECURECRT_FILL_BUFFER_PATTERN: u32 = 254;
26pub const _CRT_SECURE_CPP_OVERLOAD_STANDARD_NAMES: u32 = 0;
27pub const _CRT_SECURE_CPP_OVERLOAD_STANDARD_NAMES_COUNT: u32 = 0;
28pub const _CRT_SECURE_CPP_OVERLOAD_SECURE_NAMES: u32 = 1;
29pub const _CRT_SECURE_CPP_OVERLOAD_STANDARD_NAMES_MEMORY: u32 = 0;
30pub const _CRT_SECURE_CPP_OVERLOAD_SECURE_NAMES_MEMORY: u32 = 0;
31pub const true_: u32 = 1;
32pub const false_: u32 = 0;
33pub const __bool_true_false_are_defined: u32 = 1;
34pub const WCHAR_MIN: u32 = 0;
35pub const WCHAR_MAX: u32 = 65535;
36pub const WINT_MIN: u32 = 0;
37pub const WINT_MAX: u32 = 65535;
38pub type va_list = *mut ::std::os::raw::c_char;
39extern "C" {
40 pub fn __va_start(arg1: *mut *mut ::std::os::raw::c_char, ...);
41}
42pub type size_t = ::std::os::raw::c_ulonglong;
43pub type __vcrt_bool = bool;
44pub type wchar_t = ::std::os::raw::c_ushort;
45extern "C" {
46 pub fn __security_init_cookie();
47}
48extern "C" {
49 pub fn __security_check_cookie(_StackCookie: usize);
50}
51extern "C" {
52 pub fn __report_gsfailure(_StackCookie: usize);
53}
54extern "C" {
55 pub static mut __security_cookie: usize;
56}
57pub type __crt_bool = bool;
58extern "C" {
59 pub fn _invalid_parameter_noinfo();
60}
61extern "C" {
62 pub fn _invalid_parameter_noinfo_noreturn();
63}
64extern "C" {
65 pub fn _invoke_watson(
66 _Expression: *const wchar_t,
67 _FunctionName: *const wchar_t,
68 _FileName: *const wchar_t,
69 _LineNo: ::std::os::raw::c_uint,
70 _Reserved: usize,
71 );
72}
73pub type errno_t = ::std::os::raw::c_int;
74pub type wint_t = ::std::os::raw::c_ushort;
75pub type wctype_t = ::std::os::raw::c_ushort;
76pub type __time32_t = ::std::os::raw::c_long;
77pub type __time64_t = ::std::os::raw::c_longlong;
78#[repr(C)]
79#[derive(Debug, Copy, Clone)]
80pub struct __crt_locale_data_public {
81 pub _locale_pctype: *const ::std::os::raw::c_ushort,
82 pub _locale_mb_cur_max: ::std::os::raw::c_int,
83 pub _locale_lc_codepage: ::std::os::raw::c_uint,
84}
85#[test]
86fn bindgen_test_layout___crt_locale_data_public() {
87 assert_eq!(
88 ::std::mem::size_of::<__crt_locale_data_public>(),
89 16usize,
90 concat!("Size of: ", stringify!(__crt_locale_data_public))
91 );
92 assert_eq!(
93 ::std::mem::align_of::<__crt_locale_data_public>(),
94 8usize,
95 concat!("Alignment of ", stringify!(__crt_locale_data_public))
96 );
97 fn test_field__locale_pctype() {
98 assert_eq!(
99 unsafe {
100 let uninit = ::std::mem::MaybeUninit::<__crt_locale_data_public>::uninit();
101 let ptr = uninit.as_ptr();
102 ::std::ptr::addr_of!((*ptr)._locale_pctype) as usize - ptr as usize
103 },
104 0usize,
105 concat!(
106 "Offset of field: ",
107 stringify!(__crt_locale_data_public),
108 "::",
109 stringify!(_locale_pctype)
110 )
111 );
112 }
113 test_field__locale_pctype();
114 fn test_field__locale_mb_cur_max() {
115 assert_eq!(
116 unsafe {
117 let uninit = ::std::mem::MaybeUninit::<__crt_locale_data_public>::uninit();
118 let ptr = uninit.as_ptr();
119 ::std::ptr::addr_of!((*ptr)._locale_mb_cur_max) as usize - ptr as usize
120 },
121 8usize,
122 concat!(
123 "Offset of field: ",
124 stringify!(__crt_locale_data_public),
125 "::",
126 stringify!(_locale_mb_cur_max)
127 )
128 );
129 }
130 test_field__locale_mb_cur_max();
131 fn test_field__locale_lc_codepage() {
132 assert_eq!(
133 unsafe {
134 let uninit = ::std::mem::MaybeUninit::<__crt_locale_data_public>::uninit();
135 let ptr = uninit.as_ptr();
136 ::std::ptr::addr_of!((*ptr)._locale_lc_codepage) as usize - ptr as usize
137 },
138 12usize,
139 concat!(
140 "Offset of field: ",
141 stringify!(__crt_locale_data_public),
142 "::",
143 stringify!(_locale_lc_codepage)
144 )
145 );
146 }
147 test_field__locale_lc_codepage();
148}
149#[repr(C)]
150#[derive(Debug, Copy, Clone)]
151pub struct __crt_locale_pointers {
152 pub locinfo: *mut __crt_locale_data,
153 pub mbcinfo: *mut __crt_multibyte_data,
154}
155#[test]
156fn bindgen_test_layout___crt_locale_pointers() {
157 assert_eq!(
158 ::std::mem::size_of::<__crt_locale_pointers>(),
159 16usize,
160 concat!("Size of: ", stringify!(__crt_locale_pointers))
161 );
162 assert_eq!(
163 ::std::mem::align_of::<__crt_locale_pointers>(),
164 8usize,
165 concat!("Alignment of ", stringify!(__crt_locale_pointers))
166 );
167 fn test_field_locinfo() {
168 assert_eq!(
169 unsafe {
170 let uninit = ::std::mem::MaybeUninit::<__crt_locale_pointers>::uninit();
171 let ptr = uninit.as_ptr();
172 ::std::ptr::addr_of!((*ptr).locinfo) as usize - ptr as usize
173 },
174 0usize,
175 concat!(
176 "Offset of field: ",
177 stringify!(__crt_locale_pointers),
178 "::",
179 stringify!(locinfo)
180 )
181 );
182 }
183 test_field_locinfo();
184 fn test_field_mbcinfo() {
185 assert_eq!(
186 unsafe {
187 let uninit = ::std::mem::MaybeUninit::<__crt_locale_pointers>::uninit();
188 let ptr = uninit.as_ptr();
189 ::std::ptr::addr_of!((*ptr).mbcinfo) as usize - ptr as usize
190 },
191 8usize,
192 concat!(
193 "Offset of field: ",
194 stringify!(__crt_locale_pointers),
195 "::",
196 stringify!(mbcinfo)
197 )
198 );
199 }
200 test_field_mbcinfo();
201}
202pub type _locale_t = *mut __crt_locale_pointers;
203#[repr(C)]
204#[derive(Debug, Copy, Clone)]
205pub struct _Mbstatet {
206 pub _Wchar: ::std::os::raw::c_ulong,
207 pub _Byte: ::std::os::raw::c_ushort,
208 pub _State: ::std::os::raw::c_ushort,
209}
210#[test]
211fn bindgen_test_layout__Mbstatet() {
212 assert_eq!(
213 ::std::mem::size_of::<_Mbstatet>(),
214 8usize,
215 concat!("Size of: ", stringify!(_Mbstatet))
216 );
217 assert_eq!(
218 ::std::mem::align_of::<_Mbstatet>(),
219 4usize,
220 concat!("Alignment of ", stringify!(_Mbstatet))
221 );
222 fn test_field__Wchar() {
223 assert_eq!(
224 unsafe {
225 let uninit = ::std::mem::MaybeUninit::<_Mbstatet>::uninit();
226 let ptr = uninit.as_ptr();
227 ::std::ptr::addr_of!((*ptr)._Wchar) as usize - ptr as usize
228 },
229 0usize,
230 concat!(
231 "Offset of field: ",
232 stringify!(_Mbstatet),
233 "::",
234 stringify!(_Wchar)
235 )
236 );
237 }
238 test_field__Wchar();
239 fn test_field__Byte() {
240 assert_eq!(
241 unsafe {
242 let uninit = ::std::mem::MaybeUninit::<_Mbstatet>::uninit();
243 let ptr = uninit.as_ptr();
244 ::std::ptr::addr_of!((*ptr)._Byte) as usize - ptr as usize
245 },
246 4usize,
247 concat!(
248 "Offset of field: ",
249 stringify!(_Mbstatet),
250 "::",
251 stringify!(_Byte)
252 )
253 );
254 }
255 test_field__Byte();
256 fn test_field__State() {
257 assert_eq!(
258 unsafe {
259 let uninit = ::std::mem::MaybeUninit::<_Mbstatet>::uninit();
260 let ptr = uninit.as_ptr();
261 ::std::ptr::addr_of!((*ptr)._State) as usize - ptr as usize
262 },
263 6usize,
264 concat!(
265 "Offset of field: ",
266 stringify!(_Mbstatet),
267 "::",
268 stringify!(_State)
269 )
270 );
271 }
272 test_field__State();
273}
274pub type mbstate_t = _Mbstatet;
275pub type time_t = __time64_t;
276pub type rsize_t = size_t;
277extern "C" {
278 pub fn _wassert(_Message: *const wchar_t, _File: *const wchar_t, _Line: ::std::os::raw::c_uint);
279}
280pub type max_align_t = f64;
281pub type int_least8_t = ::std::os::raw::c_schar;
282pub type int_least16_t = ::std::os::raw::c_short;
283pub type int_least32_t = ::std::os::raw::c_int;
284pub type int_least64_t = ::std::os::raw::c_longlong;
285pub type uint_least8_t = ::std::os::raw::c_uchar;
286pub type uint_least16_t = ::std::os::raw::c_ushort;
287pub type uint_least32_t = ::std::os::raw::c_uint;
288pub type uint_least64_t = ::std::os::raw::c_ulonglong;
289pub type int_fast8_t = ::std::os::raw::c_schar;
290pub type int_fast16_t = ::std::os::raw::c_int;
291pub type int_fast32_t = ::std::os::raw::c_int;
292pub type int_fast64_t = ::std::os::raw::c_longlong;
293pub type uint_fast8_t = ::std::os::raw::c_uchar;
294pub type uint_fast16_t = ::std::os::raw::c_uint;
295pub type uint_fast32_t = ::std::os::raw::c_uint;
296pub type uint_fast64_t = ::std::os::raw::c_ulonglong;
297pub type intmax_t = ::std::os::raw::c_longlong;
298pub type uintmax_t = ::std::os::raw::c_ulonglong;
299#[repr(C)]
300#[derive(Debug, Copy, Clone)]
301pub struct wasm_config_t {
302 _unused: [u8; 0],
303}
304#[repr(C)]
305#[derive(Debug, Copy, Clone)]
306pub struct wasm_engine_t {
307 _unused: [u8; 0],
308}
309#[repr(C)]
310#[derive(Debug, Copy, Clone)]
311pub struct wasm_compartment_t {
312 _unused: [u8; 0],
313}
314#[repr(C)]
315#[derive(Debug, Copy, Clone)]
316pub struct wasm_store_t {
317 _unused: [u8; 0],
318}
319#[repr(C)]
320#[derive(Debug, Copy, Clone)]
321pub struct wasm_valtype_t {
322 _unused: [u8; 0],
323}
324#[repr(C)]
325#[derive(Debug, Copy, Clone)]
326pub struct wasm_functype_t {
327 _unused: [u8; 0],
328}
329#[repr(C)]
330#[derive(Debug, Copy, Clone)]
331pub struct wasm_tabletype_t {
332 _unused: [u8; 0],
333}
334#[repr(C)]
335#[derive(Debug, Copy, Clone)]
336pub struct wasm_memorytype_t {
337 _unused: [u8; 0],
338}
339#[repr(C)]
340#[derive(Debug, Copy, Clone)]
341pub struct wasm_globaltype_t {
342 _unused: [u8; 0],
343}
344#[repr(C)]
345#[derive(Debug, Copy, Clone)]
346pub struct wasm_externtype_t {
347 _unused: [u8; 0],
348}
349#[repr(C)]
350#[derive(Debug, Copy, Clone)]
351pub struct wasm_ref_t {
352 _unused: [u8; 0],
353}
354#[repr(C)]
355#[derive(Debug, Copy, Clone)]
356pub struct wasm_trap_t {
357 _unused: [u8; 0],
358}
359#[repr(C)]
360#[derive(Debug, Copy, Clone)]
361pub struct wasm_foreign_t {
362 _unused: [u8; 0],
363}
364#[repr(C)]
365#[derive(Debug, Copy, Clone)]
366pub struct wasm_module_t {
367 _unused: [u8; 0],
368}
369#[repr(C)]
370#[derive(Debug, Copy, Clone)]
371pub struct wasm_func_t {
372 _unused: [u8; 0],
373}
374#[repr(C)]
375#[derive(Debug, Copy, Clone)]
376pub struct wasm_table_t {
377 _unused: [u8; 0],
378}
379#[repr(C)]
380#[derive(Debug, Copy, Clone)]
381pub struct wasm_memory_t {
382 _unused: [u8; 0],
383}
384#[repr(C)]
385#[derive(Debug, Copy, Clone)]
386pub struct wasm_global_t {
387 _unused: [u8; 0],
388}
389#[repr(C)]
390#[derive(Debug, Copy, Clone)]
391pub struct wasm_extern_t {
392 _unused: [u8; 0],
393}
394#[repr(C)]
395#[derive(Debug, Copy, Clone)]
396pub struct wasm_instance_t {
397 _unused: [u8; 0],
398}
399#[repr(C)]
400#[derive(Debug, Copy, Clone)]
401pub struct wasm_shared_module_t {
402 _unused: [u8; 0],
403}
404#[repr(C)]
405#[derive(Debug, Copy, Clone)]
406pub struct wasm_shared_func_t {
407 _unused: [u8; 0],
408}
409#[repr(C)]
410#[derive(Debug, Copy, Clone)]
411pub struct wasm_shared_table_t {
412 _unused: [u8; 0],
413}
414#[repr(C)]
415#[derive(Debug, Copy, Clone)]
416pub struct wasm_shared_memory_t {
417 _unused: [u8; 0],
418}
419#[repr(C)]
420#[derive(Debug, Copy, Clone)]
421pub struct wasm_shared_foreign_t {
422 _unused: [u8; 0],
423}
424#[doc = ""]
425pub type wasm_float32_t = f32;
426pub type wasm_float64_t = f64;
427extern "C" {
428 pub fn wasm_config_delete(arg1: *mut wasm_config_t);
429}
430extern "C" {
431 #[doc = ""]
432 pub fn wasm_config_new() -> *mut wasm_config_t;
433}
434extern "C" {
435 pub fn wasm_config_feature_set_import_export_mutable_globals(
436 config: *mut wasm_config_t,
437 enable: bool,
438 );
439}
440extern "C" {
441 pub fn wasm_config_feature_set_nontrapping_float_to_int(
442 config: *mut wasm_config_t,
443 enable: bool,
444 );
445}
446extern "C" {
447 pub fn wasm_config_feature_set_sign_extension(config: *mut wasm_config_t, enable: bool);
448}
449extern "C" {
450 pub fn wasm_config_feature_set_bulk_memory_ops(config: *mut wasm_config_t, enable: bool);
451}
452extern "C" {
453 pub fn wasm_config_feature_set_simd(config: *mut wasm_config_t, enable: bool);
454}
455extern "C" {
456 pub fn wasm_config_feature_set_atomics(config: *mut wasm_config_t, enable: bool);
457}
458extern "C" {
459 pub fn wasm_config_feature_set_exception_handling(config: *mut wasm_config_t, enable: bool);
460}
461extern "C" {
462 pub fn wasm_config_feature_set_multivalue(config: *mut wasm_config_t, enable: bool);
463}
464extern "C" {
465 pub fn wasm_config_feature_set_reference_types(config: *mut wasm_config_t, enable: bool);
466}
467extern "C" {
468 pub fn wasm_config_feature_set_extended_name_section(config: *mut wasm_config_t, enable: bool);
469}
470extern "C" {
471 pub fn wasm_config_feature_set_multimemory(config: *mut wasm_config_t, enable: bool);
472}
473extern "C" {
474 pub fn wasm_config_feature_set_shared_tables(config: *mut wasm_config_t, enable: bool);
475}
476extern "C" {
477 pub fn wasm_config_feature_set_allow_legacy_inst_names(
478 config: *mut wasm_config_t,
479 enable: bool,
480 );
481}
482extern "C" {
483 pub fn wasm_config_feature_set_any_extern_kind_elems(config: *mut wasm_config_t, enable: bool);
484}
485extern "C" {
486 pub fn wasm_config_feature_set_wat_quoted_names(config: *mut wasm_config_t, enable: bool);
487}
488extern "C" {
489 pub fn wasm_config_feature_set_wat_custom_sections(config: *mut wasm_config_t, enable: bool);
490}
491extern "C" {
492 pub fn wasm_engine_delete(arg1: *mut wasm_engine_t);
493}
494extern "C" {
495 pub fn wasm_engine_new() -> *mut wasm_engine_t;
496}
497extern "C" {
498 pub fn wasm_engine_new_with_config(arg1: *mut wasm_config_t) -> *mut wasm_engine_t;
499}
500extern "C" {
501 pub fn wasm_compartment_delete(arg1: *mut wasm_compartment_t);
502}
503extern "C" {
504 pub fn wasm_compartment_new(
505 engine: *mut wasm_engine_t,
506 debug_name: *const ::std::os::raw::c_char,
507 ) -> *mut wasm_compartment_t;
508}
509extern "C" {
510 pub fn wasm_compartment_clone(arg1: *const wasm_compartment_t) -> *mut wasm_compartment_t;
511}
512extern "C" {
513 pub fn wasm_compartment_contains(
514 arg1: *const wasm_compartment_t,
515 arg2: *const wasm_ref_t,
516 ) -> bool;
517}
518extern "C" {
519 pub fn wasm_store_delete(arg1: *mut wasm_store_t);
520}
521extern "C" {
522 pub fn wasm_store_new(
523 arg1: *mut wasm_compartment_t,
524 debug_name: *const ::std::os::raw::c_char,
525 ) -> *mut wasm_store_t;
526}
527#[doc = ""]
528pub type wasm_mutability_t = u8;
529pub const wasm_mutability_enum_WASM_CONST: wasm_mutability_enum = 0;
530pub const wasm_mutability_enum_WASM_VAR: wasm_mutability_enum = 1;
531pub type wasm_mutability_enum = ::std::os::raw::c_int;
532pub type wasm_shared_t = u8;
533pub const wasm_shared_enum_WASM_NOTSHARED: wasm_shared_enum = 0;
534pub const wasm_shared_enum_WASM_SHARED: wasm_shared_enum = 1;
535pub type wasm_shared_enum = ::std::os::raw::c_int;
536pub type wasm_index_t = u8;
537pub const wasm_index_enum_WASM_INDEX_I32: wasm_index_enum = 0;
538pub const wasm_index_enum_WASM_INDEX_I64: wasm_index_enum = 1;
539pub type wasm_index_enum = ::std::os::raw::c_int;
540#[repr(C)]
541#[derive(Debug, Copy, Clone)]
542pub struct wasm_limits_t {
543 pub min: u32,
544 pub max: u32,
545}
546#[test]
547fn bindgen_test_layout_wasm_limits_t() {
548 assert_eq!(
549 ::std::mem::size_of::<wasm_limits_t>(),
550 8usize,
551 concat!("Size of: ", stringify!(wasm_limits_t))
552 );
553 assert_eq!(
554 ::std::mem::align_of::<wasm_limits_t>(),
555 4usize,
556 concat!("Alignment of ", stringify!(wasm_limits_t))
557 );
558 fn test_field_min() {
559 assert_eq!(
560 unsafe {
561 let uninit = ::std::mem::MaybeUninit::<wasm_limits_t>::uninit();
562 let ptr = uninit.as_ptr();
563 ::std::ptr::addr_of!((*ptr).min) as usize - ptr as usize
564 },
565 0usize,
566 concat!(
567 "Offset of field: ",
568 stringify!(wasm_limits_t),
569 "::",
570 stringify!(min)
571 )
572 );
573 }
574 test_field_min();
575 fn test_field_max() {
576 assert_eq!(
577 unsafe {
578 let uninit = ::std::mem::MaybeUninit::<wasm_limits_t>::uninit();
579 let ptr = uninit.as_ptr();
580 ::std::ptr::addr_of!((*ptr).max) as usize - ptr as usize
581 },
582 4usize,
583 concat!(
584 "Offset of field: ",
585 stringify!(wasm_limits_t),
586 "::",
587 stringify!(max)
588 )
589 );
590 }
591 test_field_max();
592}
593pub const wasm_limits_max_default: u32 = 4294967295;
594extern "C" {
595 pub fn wasm_valtype_delete(arg1: *mut wasm_valtype_t);
596}
597extern "C" {
598 pub fn wasm_valtype_copy(arg1: *mut wasm_valtype_t) -> *mut wasm_valtype_t;
599}
600pub type wasm_valkind_t = u8;
601pub const wasm_valkind_enum_WASM_I32: wasm_valkind_enum = 0;
602pub const wasm_valkind_enum_WASM_I64: wasm_valkind_enum = 1;
603pub const wasm_valkind_enum_WASM_F32: wasm_valkind_enum = 2;
604pub const wasm_valkind_enum_WASM_F64: wasm_valkind_enum = 3;
605pub const wasm_valkind_enum_WASM_V128: wasm_valkind_enum = 4;
606pub const wasm_valkind_enum_WASM_ANYREF: wasm_valkind_enum = 128;
607pub const wasm_valkind_enum_WASM_FUNCREF: wasm_valkind_enum = 129;
608pub type wasm_valkind_enum = ::std::os::raw::c_int;
609extern "C" {
610 pub fn wasm_valtype_new(arg1: wasm_valkind_t) -> *mut wasm_valtype_t;
611}
612extern "C" {
613 pub fn wasm_valtype_kind(arg1: *const wasm_valtype_t) -> wasm_valkind_t;
614}
615extern "C" {
616 pub fn wasm_functype_delete(arg1: *mut wasm_functype_t);
617}
618extern "C" {
619 pub fn wasm_functype_copy(arg1: *mut wasm_functype_t) -> *mut wasm_functype_t;
620}
621extern "C" {
622 pub fn wasm_functype_new(
623 params: *mut *mut wasm_valtype_t,
624 num_params: size_t,
625 results: *mut *mut wasm_valtype_t,
626 num_results: size_t,
627 ) -> *mut wasm_functype_t;
628}
629extern "C" {
630 pub fn wasm_functype_num_params(type_: *const wasm_functype_t) -> size_t;
631}
632extern "C" {
633 pub fn wasm_functype_param(type_: *const wasm_functype_t, index: size_t)
634 -> *mut wasm_valtype_t;
635}
636extern "C" {
637 pub fn wasm_functype_num_results(type_: *const wasm_functype_t) -> size_t;
638}
639extern "C" {
640 pub fn wasm_functype_result(
641 type_: *const wasm_functype_t,
642 index: size_t,
643 ) -> *mut wasm_valtype_t;
644}
645extern "C" {
646 pub fn wasm_globaltype_delete(arg1: *mut wasm_globaltype_t);
647}
648extern "C" {
649 pub fn wasm_globaltype_copy(arg1: *mut wasm_globaltype_t) -> *mut wasm_globaltype_t;
650}
651extern "C" {
652 pub fn wasm_globaltype_new(
653 arg1: *mut wasm_valtype_t,
654 arg2: wasm_mutability_t,
655 ) -> *mut wasm_globaltype_t;
656}
657extern "C" {
658 pub fn wasm_globaltype_content(arg1: *const wasm_globaltype_t) -> *const wasm_valtype_t;
659}
660extern "C" {
661 pub fn wasm_globaltype_mutability(arg1: *const wasm_globaltype_t) -> wasm_mutability_t;
662}
663extern "C" {
664 pub fn wasm_tabletype_delete(arg1: *mut wasm_tabletype_t);
665}
666extern "C" {
667 pub fn wasm_tabletype_copy(arg1: *mut wasm_tabletype_t) -> *mut wasm_tabletype_t;
668}
669extern "C" {
670 pub fn wasm_tabletype_new(
671 arg1: *mut wasm_valtype_t,
672 arg2: *const wasm_limits_t,
673 arg3: wasm_shared_t,
674 arg4: wasm_index_t,
675 ) -> *mut wasm_tabletype_t;
676}
677extern "C" {
678 pub fn wasm_tabletype_element(arg1: *const wasm_tabletype_t) -> *const wasm_valtype_t;
679}
680extern "C" {
681 pub fn wasm_tabletype_limits(arg1: *const wasm_tabletype_t) -> *const wasm_limits_t;
682}
683extern "C" {
684 pub fn wasm_tabletype_shared(arg1: *const wasm_tabletype_t) -> wasm_shared_t;
685}
686extern "C" {
687 pub fn wasm_tabletype_index(arg1: *const wasm_tabletype_t) -> wasm_index_t;
688}
689extern "C" {
690 pub fn wasm_memorytype_delete(arg1: *mut wasm_memorytype_t);
691}
692extern "C" {
693 pub fn wasm_memorytype_copy(arg1: *mut wasm_memorytype_t) -> *mut wasm_memorytype_t;
694}
695extern "C" {
696 pub fn wasm_memorytype_new(
697 arg1: *const wasm_limits_t,
698 arg2: wasm_shared_t,
699 arg3: wasm_index_t,
700 ) -> *mut wasm_memorytype_t;
701}
702extern "C" {
703 pub fn wasm_memorytype_limits(arg1: *const wasm_memorytype_t) -> *const wasm_limits_t;
704}
705extern "C" {
706 pub fn wasm_memorytype_shared(arg1: *const wasm_memorytype_t) -> wasm_shared_t;
707}
708extern "C" {
709 pub fn wasm_memorytype_index(arg1: *const wasm_memorytype_t) -> wasm_index_t;
710}
711extern "C" {
712 pub fn wasm_externtype_delete(arg1: *mut wasm_externtype_t);
713}
714extern "C" {
715 pub fn wasm_externtype_copy(arg1: *mut wasm_externtype_t) -> *mut wasm_externtype_t;
716}
717pub type wasm_externkind_t = u8;
718pub const wasm_externkind_enum_WASM_EXTERN_FUNC: wasm_externkind_enum = 0;
719pub const wasm_externkind_enum_WASM_EXTERN_GLOBAL: wasm_externkind_enum = 1;
720pub const wasm_externkind_enum_WASM_EXTERN_TABLE: wasm_externkind_enum = 2;
721pub const wasm_externkind_enum_WASM_EXTERN_MEMORY: wasm_externkind_enum = 3;
722pub type wasm_externkind_enum = ::std::os::raw::c_int;
723extern "C" {
724 pub fn wasm_externtype_kind(arg1: *const wasm_externtype_t) -> wasm_externkind_t;
725}
726extern "C" {
727 pub fn wasm_functype_as_externtype(arg1: *mut wasm_functype_t) -> *mut wasm_externtype_t;
728}
729extern "C" {
730 pub fn wasm_globaltype_as_externtype(arg1: *mut wasm_globaltype_t) -> *mut wasm_externtype_t;
731}
732extern "C" {
733 pub fn wasm_tabletype_as_externtype(arg1: *mut wasm_tabletype_t) -> *mut wasm_externtype_t;
734}
735extern "C" {
736 pub fn wasm_memorytype_as_externtype(arg1: *mut wasm_memorytype_t) -> *mut wasm_externtype_t;
737}
738extern "C" {
739 pub fn wasm_externtype_as_functype(arg1: *mut wasm_externtype_t) -> *mut wasm_functype_t;
740}
741extern "C" {
742 pub fn wasm_externtype_as_globaltype(arg1: *mut wasm_externtype_t) -> *mut wasm_globaltype_t;
743}
744extern "C" {
745 pub fn wasm_externtype_as_tabletype(arg1: *mut wasm_externtype_t) -> *mut wasm_tabletype_t;
746}
747extern "C" {
748 pub fn wasm_externtype_as_memorytype(arg1: *mut wasm_externtype_t) -> *mut wasm_memorytype_t;
749}
750extern "C" {
751 pub fn wasm_functype_as_externtype_const(
752 arg1: *const wasm_functype_t,
753 ) -> *const wasm_externtype_t;
754}
755extern "C" {
756 pub fn wasm_globaltype_as_externtype_const(
757 arg1: *const wasm_globaltype_t,
758 ) -> *const wasm_externtype_t;
759}
760extern "C" {
761 pub fn wasm_tabletype_as_externtype_const(
762 arg1: *const wasm_tabletype_t,
763 ) -> *const wasm_externtype_t;
764}
765extern "C" {
766 pub fn wasm_memorytype_as_externtype_const(
767 arg1: *const wasm_memorytype_t,
768 ) -> *const wasm_externtype_t;
769}
770extern "C" {
771 pub fn wasm_externtype_as_functype_const(
772 arg1: *const wasm_externtype_t,
773 ) -> *const wasm_functype_t;
774}
775extern "C" {
776 pub fn wasm_externtype_as_globaltype_const(
777 arg1: *const wasm_externtype_t,
778 ) -> *const wasm_globaltype_t;
779}
780extern "C" {
781 pub fn wasm_externtype_as_tabletype_const(
782 arg1: *const wasm_externtype_t,
783 ) -> *const wasm_tabletype_t;
784}
785extern "C" {
786 pub fn wasm_externtype_as_memorytype_const(
787 arg1: *const wasm_externtype_t,
788 ) -> *const wasm_memorytype_t;
789}
790#[repr(C)]
791#[derive(Debug, Copy, Clone)]
792pub struct wasm_import_t {
793 pub module: *const ::std::os::raw::c_char,
794 pub num_module_bytes: size_t,
795 pub name: *const ::std::os::raw::c_char,
796 pub num_name_bytes: size_t,
797 pub type_: *mut wasm_externtype_t,
798}
799#[test]
800fn bindgen_test_layout_wasm_import_t() {
801 assert_eq!(
802 ::std::mem::size_of::<wasm_import_t>(),
803 40usize,
804 concat!("Size of: ", stringify!(wasm_import_t))
805 );
806 assert_eq!(
807 ::std::mem::align_of::<wasm_import_t>(),
808 8usize,
809 concat!("Alignment of ", stringify!(wasm_import_t))
810 );
811 fn test_field_module() {
812 assert_eq!(
813 unsafe {
814 let uninit = ::std::mem::MaybeUninit::<wasm_import_t>::uninit();
815 let ptr = uninit.as_ptr();
816 ::std::ptr::addr_of!((*ptr).module) as usize - ptr as usize
817 },
818 0usize,
819 concat!(
820 "Offset of field: ",
821 stringify!(wasm_import_t),
822 "::",
823 stringify!(module)
824 )
825 );
826 }
827 test_field_module();
828 fn test_field_num_module_bytes() {
829 assert_eq!(
830 unsafe {
831 let uninit = ::std::mem::MaybeUninit::<wasm_import_t>::uninit();
832 let ptr = uninit.as_ptr();
833 ::std::ptr::addr_of!((*ptr).num_module_bytes) as usize - ptr as usize
834 },
835 8usize,
836 concat!(
837 "Offset of field: ",
838 stringify!(wasm_import_t),
839 "::",
840 stringify!(num_module_bytes)
841 )
842 );
843 }
844 test_field_num_module_bytes();
845 fn test_field_name() {
846 assert_eq!(
847 unsafe {
848 let uninit = ::std::mem::MaybeUninit::<wasm_import_t>::uninit();
849 let ptr = uninit.as_ptr();
850 ::std::ptr::addr_of!((*ptr).name) as usize - ptr as usize
851 },
852 16usize,
853 concat!(
854 "Offset of field: ",
855 stringify!(wasm_import_t),
856 "::",
857 stringify!(name)
858 )
859 );
860 }
861 test_field_name();
862 fn test_field_num_name_bytes() {
863 assert_eq!(
864 unsafe {
865 let uninit = ::std::mem::MaybeUninit::<wasm_import_t>::uninit();
866 let ptr = uninit.as_ptr();
867 ::std::ptr::addr_of!((*ptr).num_name_bytes) as usize - ptr as usize
868 },
869 24usize,
870 concat!(
871 "Offset of field: ",
872 stringify!(wasm_import_t),
873 "::",
874 stringify!(num_name_bytes)
875 )
876 );
877 }
878 test_field_num_name_bytes();
879 fn test_field_type() {
880 assert_eq!(
881 unsafe {
882 let uninit = ::std::mem::MaybeUninit::<wasm_import_t>::uninit();
883 let ptr = uninit.as_ptr();
884 ::std::ptr::addr_of!((*ptr).type_) as usize - ptr as usize
885 },
886 32usize,
887 concat!(
888 "Offset of field: ",
889 stringify!(wasm_import_t),
890 "::",
891 stringify!(type_)
892 )
893 );
894 }
895 test_field_type();
896}
897#[repr(C)]
898#[derive(Debug, Copy, Clone)]
899pub struct wasm_export_t {
900 pub name: *const ::std::os::raw::c_char,
901 pub num_name_bytes: size_t,
902 pub type_: *mut wasm_externtype_t,
903}
904#[test]
905fn bindgen_test_layout_wasm_export_t() {
906 assert_eq!(
907 ::std::mem::size_of::<wasm_export_t>(),
908 24usize,
909 concat!("Size of: ", stringify!(wasm_export_t))
910 );
911 assert_eq!(
912 ::std::mem::align_of::<wasm_export_t>(),
913 8usize,
914 concat!("Alignment of ", stringify!(wasm_export_t))
915 );
916 fn test_field_name() {
917 assert_eq!(
918 unsafe {
919 let uninit = ::std::mem::MaybeUninit::<wasm_export_t>::uninit();
920 let ptr = uninit.as_ptr();
921 ::std::ptr::addr_of!((*ptr).name) as usize - ptr as usize
922 },
923 0usize,
924 concat!(
925 "Offset of field: ",
926 stringify!(wasm_export_t),
927 "::",
928 stringify!(name)
929 )
930 );
931 }
932 test_field_name();
933 fn test_field_num_name_bytes() {
934 assert_eq!(
935 unsafe {
936 let uninit = ::std::mem::MaybeUninit::<wasm_export_t>::uninit();
937 let ptr = uninit.as_ptr();
938 ::std::ptr::addr_of!((*ptr).num_name_bytes) as usize - ptr as usize
939 },
940 8usize,
941 concat!(
942 "Offset of field: ",
943 stringify!(wasm_export_t),
944 "::",
945 stringify!(num_name_bytes)
946 )
947 );
948 }
949 test_field_num_name_bytes();
950 fn test_field_type() {
951 assert_eq!(
952 unsafe {
953 let uninit = ::std::mem::MaybeUninit::<wasm_export_t>::uninit();
954 let ptr = uninit.as_ptr();
955 ::std::ptr::addr_of!((*ptr).type_) as usize - ptr as usize
956 },
957 16usize,
958 concat!(
959 "Offset of field: ",
960 stringify!(wasm_export_t),
961 "::",
962 stringify!(type_)
963 )
964 );
965 }
966 test_field_type();
967}
968#[doc = ""]
969#[repr(C)]
970#[derive(Debug, Copy, Clone)]
971pub struct wasm_v128_t {
972 pub u64x2: [u64; 2usize],
973}
974#[test]
975fn bindgen_test_layout_wasm_v128_t() {
976 assert_eq!(
977 ::std::mem::size_of::<wasm_v128_t>(),
978 16usize,
979 concat!("Size of: ", stringify!(wasm_v128_t))
980 );
981 assert_eq!(
982 ::std::mem::align_of::<wasm_v128_t>(),
983 8usize,
984 concat!("Alignment of ", stringify!(wasm_v128_t))
985 );
986 fn test_field_u64x2() {
987 assert_eq!(
988 unsafe {
989 let uninit = ::std::mem::MaybeUninit::<wasm_v128_t>::uninit();
990 let ptr = uninit.as_ptr();
991 ::std::ptr::addr_of!((*ptr).u64x2) as usize - ptr as usize
992 },
993 0usize,
994 concat!(
995 "Offset of field: ",
996 stringify!(wasm_v128_t),
997 "::",
998 stringify!(u64x2)
999 )
1000 );
1001 }
1002 test_field_u64x2();
1003}
1004#[repr(C)]
1005#[derive(Copy, Clone)]
1006pub union wasm_val_t {
1007 pub i32_: i32,
1008 pub i64_: i64,
1009 pub f32_: wasm_float32_t,
1010 pub f64_: wasm_float64_t,
1011 pub v128: wasm_v128_t,
1012 pub ref_: *mut wasm_ref_t,
1013}
1014#[test]
1015fn bindgen_test_layout_wasm_val_t() {
1016 assert_eq!(
1017 ::std::mem::size_of::<wasm_val_t>(),
1018 16usize,
1019 concat!("Size of: ", stringify!(wasm_val_t))
1020 );
1021 assert_eq!(
1022 ::std::mem::align_of::<wasm_val_t>(),
1023 8usize,
1024 concat!("Alignment of ", stringify!(wasm_val_t))
1025 );
1026 fn test_field_i32() {
1027 assert_eq!(
1028 unsafe {
1029 let uninit = ::std::mem::MaybeUninit::<wasm_val_t>::uninit();
1030 let ptr = uninit.as_ptr();
1031 ::std::ptr::addr_of!((*ptr).i32_) as usize - ptr as usize
1032 },
1033 0usize,
1034 concat!(
1035 "Offset of field: ",
1036 stringify!(wasm_val_t),
1037 "::",
1038 stringify!(i32_)
1039 )
1040 );
1041 }
1042 test_field_i32();
1043 fn test_field_i64() {
1044 assert_eq!(
1045 unsafe {
1046 let uninit = ::std::mem::MaybeUninit::<wasm_val_t>::uninit();
1047 let ptr = uninit.as_ptr();
1048 ::std::ptr::addr_of!((*ptr).i64_) as usize - ptr as usize
1049 },
1050 0usize,
1051 concat!(
1052 "Offset of field: ",
1053 stringify!(wasm_val_t),
1054 "::",
1055 stringify!(i64_)
1056 )
1057 );
1058 }
1059 test_field_i64();
1060 fn test_field_f32() {
1061 assert_eq!(
1062 unsafe {
1063 let uninit = ::std::mem::MaybeUninit::<wasm_val_t>::uninit();
1064 let ptr = uninit.as_ptr();
1065 ::std::ptr::addr_of!((*ptr).f32_) as usize - ptr as usize
1066 },
1067 0usize,
1068 concat!(
1069 "Offset of field: ",
1070 stringify!(wasm_val_t),
1071 "::",
1072 stringify!(f32_)
1073 )
1074 );
1075 }
1076 test_field_f32();
1077 fn test_field_f64() {
1078 assert_eq!(
1079 unsafe {
1080 let uninit = ::std::mem::MaybeUninit::<wasm_val_t>::uninit();
1081 let ptr = uninit.as_ptr();
1082 ::std::ptr::addr_of!((*ptr).f64_) as usize - ptr as usize
1083 },
1084 0usize,
1085 concat!(
1086 "Offset of field: ",
1087 stringify!(wasm_val_t),
1088 "::",
1089 stringify!(f64_)
1090 )
1091 );
1092 }
1093 test_field_f64();
1094 fn test_field_v128() {
1095 assert_eq!(
1096 unsafe {
1097 let uninit = ::std::mem::MaybeUninit::<wasm_val_t>::uninit();
1098 let ptr = uninit.as_ptr();
1099 ::std::ptr::addr_of!((*ptr).v128) as usize - ptr as usize
1100 },
1101 0usize,
1102 concat!(
1103 "Offset of field: ",
1104 stringify!(wasm_val_t),
1105 "::",
1106 stringify!(v128)
1107 )
1108 );
1109 }
1110 test_field_v128();
1111 fn test_field_ref() {
1112 assert_eq!(
1113 unsafe {
1114 let uninit = ::std::mem::MaybeUninit::<wasm_val_t>::uninit();
1115 let ptr = uninit.as_ptr();
1116 ::std::ptr::addr_of!((*ptr).ref_) as usize - ptr as usize
1117 },
1118 0usize,
1119 concat!(
1120 "Offset of field: ",
1121 stringify!(wasm_val_t),
1122 "::",
1123 stringify!(ref_)
1124 )
1125 );
1126 }
1127 test_field_ref();
1128}
1129extern "C" {
1130 pub fn wasm_val_delete(kind: wasm_valkind_t, v: *mut wasm_val_t);
1131}
1132extern "C" {
1133 pub fn wasm_val_copy(kind: wasm_valkind_t, out: *mut wasm_val_t, arg1: *const wasm_val_t);
1134}
1135extern "C" {
1136 pub fn wasm_ref_delete(arg1: *mut wasm_ref_t);
1137}
1138extern "C" {
1139 pub fn wasm_ref_copy(arg1: *const wasm_ref_t) -> *mut wasm_ref_t;
1140}
1141extern "C" {
1142 pub fn wasm_ref_same(arg1: *const wasm_ref_t, arg2: *const wasm_ref_t) -> bool;
1143}
1144extern "C" {
1145 pub fn wasm_ref_get_host_info(arg1: *const wasm_ref_t) -> *mut ::std::os::raw::c_void;
1146}
1147extern "C" {
1148 pub fn wasm_ref_set_host_info(arg1: *mut wasm_ref_t, arg2: *mut ::std::os::raw::c_void);
1149}
1150extern "C" {
1151 pub fn wasm_ref_set_host_info_with_finalizer(
1152 arg1: *mut wasm_ref_t,
1153 arg2: *mut ::std::os::raw::c_void,
1154 arg3: ::std::option::Option<unsafe extern "C" fn(arg1: *mut ::std::os::raw::c_void)>,
1155 );
1156}
1157extern "C" {
1158 pub fn wasm_ref_remap_to_cloned_compartment(
1159 arg1: *const wasm_ref_t,
1160 arg2: *const wasm_compartment_t,
1161 ) -> *mut wasm_ref_t;
1162}
1163extern "C" {
1164 pub fn wasm_ref_name(arg1: *const wasm_ref_t) -> *const ::std::os::raw::c_char;
1165}
1166#[repr(C)]
1167#[derive(Debug, Copy, Clone)]
1168pub struct wasm_frame_t {
1169 pub function: *mut wasm_func_t,
1170 pub instr_index: size_t,
1171}
1172#[test]
1173fn bindgen_test_layout_wasm_frame_t() {
1174 assert_eq!(
1175 ::std::mem::size_of::<wasm_frame_t>(),
1176 16usize,
1177 concat!("Size of: ", stringify!(wasm_frame_t))
1178 );
1179 assert_eq!(
1180 ::std::mem::align_of::<wasm_frame_t>(),
1181 8usize,
1182 concat!("Alignment of ", stringify!(wasm_frame_t))
1183 );
1184 fn test_field_function() {
1185 assert_eq!(
1186 unsafe {
1187 let uninit = ::std::mem::MaybeUninit::<wasm_frame_t>::uninit();
1188 let ptr = uninit.as_ptr();
1189 ::std::ptr::addr_of!((*ptr).function) as usize - ptr as usize
1190 },
1191 0usize,
1192 concat!(
1193 "Offset of field: ",
1194 stringify!(wasm_frame_t),
1195 "::",
1196 stringify!(function)
1197 )
1198 );
1199 }
1200 test_field_function();
1201 fn test_field_instr_index() {
1202 assert_eq!(
1203 unsafe {
1204 let uninit = ::std::mem::MaybeUninit::<wasm_frame_t>::uninit();
1205 let ptr = uninit.as_ptr();
1206 ::std::ptr::addr_of!((*ptr).instr_index) as usize - ptr as usize
1207 },
1208 8usize,
1209 concat!(
1210 "Offset of field: ",
1211 stringify!(wasm_frame_t),
1212 "::",
1213 stringify!(instr_index)
1214 )
1215 );
1216 }
1217 test_field_instr_index();
1218}
1219extern "C" {
1220 pub fn wasm_trap_delete(arg1: *mut wasm_trap_t);
1221}
1222extern "C" {
1223 pub fn wasm_trap_copy(arg1: *const wasm_trap_t) -> *mut wasm_trap_t;
1224}
1225extern "C" {
1226 pub fn wasm_trap_same(arg1: *const wasm_trap_t, arg2: *const wasm_trap_t) -> bool;
1227}
1228extern "C" {
1229 pub fn wasm_trap_get_host_info(arg1: *const wasm_trap_t) -> *mut ::std::os::raw::c_void;
1230}
1231extern "C" {
1232 pub fn wasm_trap_set_host_info(arg1: *mut wasm_trap_t, arg2: *mut ::std::os::raw::c_void);
1233}
1234extern "C" {
1235 pub fn wasm_trap_set_host_info_with_finalizer(
1236 arg1: *mut wasm_trap_t,
1237 arg2: *mut ::std::os::raw::c_void,
1238 arg3: ::std::option::Option<unsafe extern "C" fn(arg1: *mut ::std::os::raw::c_void)>,
1239 );
1240}
1241extern "C" {
1242 pub fn wasm_trap_remap_to_cloned_compartment(
1243 arg1: *const wasm_trap_t,
1244 arg2: *const wasm_compartment_t,
1245 ) -> *mut wasm_trap_t;
1246}
1247extern "C" {
1248 pub fn wasm_trap_name(arg1: *const wasm_trap_t) -> *const ::std::os::raw::c_char;
1249}
1250extern "C" {
1251 pub fn wasm_trap_as_ref(arg1: *mut wasm_trap_t) -> *mut wasm_ref_t;
1252}
1253extern "C" {
1254 pub fn wasm_ref_as_trap(arg1: *mut wasm_ref_t) -> *mut wasm_trap_t;
1255}
1256extern "C" {
1257 pub fn wasm_trap_as_ref_const(arg1: *const wasm_trap_t) -> *const wasm_ref_t;
1258}
1259extern "C" {
1260 pub fn wasm_ref_as_trap_const(arg1: *const wasm_ref_t) -> *const wasm_trap_t;
1261}
1262extern "C" {
1263 pub fn wasm_trap_new(
1264 arg1: *mut wasm_compartment_t,
1265 message: *const ::std::os::raw::c_char,
1266 num_message_bytes: size_t,
1267 ) -> *mut wasm_trap_t;
1268}
1269extern "C" {
1270 pub fn wasm_trap_message(
1271 arg1: *const wasm_trap_t,
1272 out_message: *mut ::std::os::raw::c_char,
1273 inout_num_message_bytes: *mut size_t,
1274 ) -> bool;
1275}
1276extern "C" {
1277 pub fn wasm_trap_stack_num_frames(arg1: *const wasm_trap_t) -> size_t;
1278}
1279extern "C" {
1280 pub fn wasm_trap_stack_frame(
1281 arg1: *const wasm_trap_t,
1282 index: size_t,
1283 out_frame: *mut wasm_frame_t,
1284 );
1285}
1286extern "C" {
1287 pub fn wasm_foreign_delete(arg1: *mut wasm_foreign_t);
1288}
1289extern "C" {
1290 pub fn wasm_foreign_copy(arg1: *const wasm_foreign_t) -> *mut wasm_foreign_t;
1291}
1292extern "C" {
1293 pub fn wasm_foreign_same(arg1: *const wasm_foreign_t, arg2: *const wasm_foreign_t) -> bool;
1294}
1295extern "C" {
1296 pub fn wasm_foreign_get_host_info(arg1: *const wasm_foreign_t) -> *mut ::std::os::raw::c_void;
1297}
1298extern "C" {
1299 pub fn wasm_foreign_set_host_info(arg1: *mut wasm_foreign_t, arg2: *mut ::std::os::raw::c_void);
1300}
1301extern "C" {
1302 pub fn wasm_foreign_set_host_info_with_finalizer(
1303 arg1: *mut wasm_foreign_t,
1304 arg2: *mut ::std::os::raw::c_void,
1305 arg3: ::std::option::Option<unsafe extern "C" fn(arg1: *mut ::std::os::raw::c_void)>,
1306 );
1307}
1308extern "C" {
1309 pub fn wasm_foreign_remap_to_cloned_compartment(
1310 arg1: *const wasm_foreign_t,
1311 arg2: *const wasm_compartment_t,
1312 ) -> *mut wasm_foreign_t;
1313}
1314extern "C" {
1315 pub fn wasm_foreign_name(arg1: *const wasm_foreign_t) -> *const ::std::os::raw::c_char;
1316}
1317extern "C" {
1318 pub fn wasm_foreign_as_ref(arg1: *mut wasm_foreign_t) -> *mut wasm_ref_t;
1319}
1320extern "C" {
1321 pub fn wasm_ref_as_foreign(arg1: *mut wasm_ref_t) -> *mut wasm_foreign_t;
1322}
1323extern "C" {
1324 pub fn wasm_foreign_as_ref_const(arg1: *const wasm_foreign_t) -> *const wasm_ref_t;
1325}
1326extern "C" {
1327 pub fn wasm_ref_as_foreign_const(arg1: *const wasm_ref_t) -> *const wasm_foreign_t;
1328}
1329extern "C" {
1330 pub fn wasm_shared_foreign_delete(arg1: *mut wasm_shared_foreign_t);
1331}
1332extern "C" {
1333 pub fn wasm_foreign_share(arg1: *const wasm_foreign_t) -> *mut wasm_shared_foreign_t;
1334}
1335extern "C" {
1336 pub fn wasm_foreign_obtain(
1337 arg1: *mut wasm_store_t,
1338 arg2: *const wasm_shared_foreign_t,
1339 ) -> *mut wasm_foreign_t;
1340}
1341extern "C" {
1342 pub fn wasm_foreign_new(
1343 arg1: *mut wasm_compartment_t,
1344 debug_name: *const ::std::os::raw::c_char,
1345 ) -> *mut wasm_foreign_t;
1346}
1347extern "C" {
1348 pub fn wasm_module_delete(arg1: *mut wasm_module_t);
1349}
1350extern "C" {
1351 pub fn wasm_module_copy(arg1: *mut wasm_module_t) -> *mut wasm_module_t;
1352}
1353extern "C" {
1354 pub fn wasm_module_new(
1355 arg1: *mut wasm_engine_t,
1356 binary: *const ::std::os::raw::c_char,
1357 num_binary_bytes: size_t,
1358 ) -> *mut wasm_module_t;
1359}
1360extern "C" {
1361 pub fn wasm_module_new_text(
1362 arg1: *mut wasm_engine_t,
1363 text: *const ::std::os::raw::c_char,
1364 num_text_chars: size_t,
1365 ) -> *mut wasm_module_t;
1366}
1367extern "C" {
1368 pub fn wasm_module_print(
1369 module: *const wasm_module_t,
1370 out_num_chars: *mut size_t,
1371 ) -> *mut ::std::os::raw::c_char;
1372}
1373extern "C" {
1374 pub fn wasm_module_validate(
1375 binary: *const ::std::os::raw::c_char,
1376 num_binary_bytes: size_t,
1377 ) -> bool;
1378}
1379extern "C" {
1380 pub fn wasm_module_num_imports(module: *const wasm_module_t) -> size_t;
1381}
1382extern "C" {
1383 pub fn wasm_module_import(
1384 module: *const wasm_module_t,
1385 index: size_t,
1386 out_import: *mut wasm_import_t,
1387 );
1388}
1389extern "C" {
1390 pub fn wasm_module_num_exports(module: *const wasm_module_t) -> size_t;
1391}
1392extern "C" {
1393 pub fn wasm_module_export(
1394 module: *const wasm_module_t,
1395 index: size_t,
1396 out_export: *mut wasm_export_t,
1397 );
1398}
1399extern "C" {
1400 pub fn wasm_func_delete(arg1: *mut wasm_func_t);
1401}
1402extern "C" {
1403 pub fn wasm_func_copy(arg1: *const wasm_func_t) -> *mut wasm_func_t;
1404}
1405extern "C" {
1406 pub fn wasm_func_same(arg1: *const wasm_func_t, arg2: *const wasm_func_t) -> bool;
1407}
1408extern "C" {
1409 pub fn wasm_func_get_host_info(arg1: *const wasm_func_t) -> *mut ::std::os::raw::c_void;
1410}
1411extern "C" {
1412 pub fn wasm_func_set_host_info(arg1: *mut wasm_func_t, arg2: *mut ::std::os::raw::c_void);
1413}
1414extern "C" {
1415 pub fn wasm_func_set_host_info_with_finalizer(
1416 arg1: *mut wasm_func_t,
1417 arg2: *mut ::std::os::raw::c_void,
1418 arg3: ::std::option::Option<unsafe extern "C" fn(arg1: *mut ::std::os::raw::c_void)>,
1419 );
1420}
1421extern "C" {
1422 pub fn wasm_func_remap_to_cloned_compartment(
1423 arg1: *const wasm_func_t,
1424 arg2: *const wasm_compartment_t,
1425 ) -> *mut wasm_func_t;
1426}
1427extern "C" {
1428 pub fn wasm_func_name(arg1: *const wasm_func_t) -> *const ::std::os::raw::c_char;
1429}
1430extern "C" {
1431 pub fn wasm_func_as_ref(arg1: *mut wasm_func_t) -> *mut wasm_ref_t;
1432}
1433extern "C" {
1434 pub fn wasm_ref_as_func(arg1: *mut wasm_ref_t) -> *mut wasm_func_t;
1435}
1436extern "C" {
1437 pub fn wasm_func_as_ref_const(arg1: *const wasm_func_t) -> *const wasm_ref_t;
1438}
1439extern "C" {
1440 pub fn wasm_ref_as_func_const(arg1: *const wasm_ref_t) -> *const wasm_func_t;
1441}
1442extern "C" {
1443 pub fn wasm_shared_func_delete(arg1: *mut wasm_shared_func_t);
1444}
1445extern "C" {
1446 pub fn wasm_func_share(arg1: *const wasm_func_t) -> *mut wasm_shared_func_t;
1447}
1448extern "C" {
1449 pub fn wasm_func_obtain(
1450 arg1: *mut wasm_store_t,
1451 arg2: *const wasm_shared_func_t,
1452 ) -> *mut wasm_func_t;
1453}
1454pub type wasm_func_callback_t = ::std::option::Option<
1455 unsafe extern "C" fn(args: *const wasm_val_t, results: *mut wasm_val_t) -> *mut wasm_trap_t,
1456>;
1457pub type wasm_func_callback_with_env_t = ::std::option::Option<
1458 unsafe extern "C" fn(
1459 env: *mut ::std::os::raw::c_void,
1460 args: *const wasm_val_t,
1461 results: *mut wasm_val_t,
1462 ) -> *mut wasm_trap_t,
1463>;
1464extern "C" {
1465 pub fn wasm_func_new(
1466 arg1: *mut wasm_compartment_t,
1467 arg2: *const wasm_functype_t,
1468 arg3: wasm_func_callback_t,
1469 debug_name: *const ::std::os::raw::c_char,
1470 ) -> *mut wasm_func_t;
1471}
1472extern "C" {
1473 pub fn wasm_func_new_with_env(
1474 arg1: *mut wasm_compartment_t,
1475 type_: *const wasm_functype_t,
1476 arg2: wasm_func_callback_with_env_t,
1477 env: *mut ::std::os::raw::c_void,
1478 finalizer: ::std::option::Option<unsafe extern "C" fn(arg1: *mut ::std::os::raw::c_void)>,
1479 debug_name: *const ::std::os::raw::c_char,
1480 ) -> *mut wasm_func_t;
1481}
1482extern "C" {
1483 pub fn wasm_func_type(arg1: *const wasm_func_t) -> *mut wasm_functype_t;
1484}
1485extern "C" {
1486 pub fn wasm_func_param_arity(arg1: *const wasm_func_t) -> size_t;
1487}
1488extern "C" {
1489 pub fn wasm_func_result_arity(arg1: *const wasm_func_t) -> size_t;
1490}
1491extern "C" {
1492 pub fn wasm_func_call(
1493 arg1: *mut wasm_store_t,
1494 arg2: *const wasm_func_t,
1495 args: *const wasm_val_t,
1496 results: *mut wasm_val_t,
1497 ) -> *mut wasm_trap_t;
1498}
1499extern "C" {
1500 pub fn wasm_global_delete(arg1: *mut wasm_global_t);
1501}
1502extern "C" {
1503 pub fn wasm_global_copy(arg1: *const wasm_global_t) -> *mut wasm_global_t;
1504}
1505extern "C" {
1506 pub fn wasm_global_same(arg1: *const wasm_global_t, arg2: *const wasm_global_t) -> bool;
1507}
1508extern "C" {
1509 pub fn wasm_global_get_host_info(arg1: *const wasm_global_t) -> *mut ::std::os::raw::c_void;
1510}
1511extern "C" {
1512 pub fn wasm_global_set_host_info(arg1: *mut wasm_global_t, arg2: *mut ::std::os::raw::c_void);
1513}
1514extern "C" {
1515 pub fn wasm_global_set_host_info_with_finalizer(
1516 arg1: *mut wasm_global_t,
1517 arg2: *mut ::std::os::raw::c_void,
1518 arg3: ::std::option::Option<unsafe extern "C" fn(arg1: *mut ::std::os::raw::c_void)>,
1519 );
1520}
1521extern "C" {
1522 pub fn wasm_global_remap_to_cloned_compartment(
1523 arg1: *const wasm_global_t,
1524 arg2: *const wasm_compartment_t,
1525 ) -> *mut wasm_global_t;
1526}
1527extern "C" {
1528 pub fn wasm_global_name(arg1: *const wasm_global_t) -> *const ::std::os::raw::c_char;
1529}
1530extern "C" {
1531 pub fn wasm_global_as_ref(arg1: *mut wasm_global_t) -> *mut wasm_ref_t;
1532}
1533extern "C" {
1534 pub fn wasm_ref_as_global(arg1: *mut wasm_ref_t) -> *mut wasm_global_t;
1535}
1536extern "C" {
1537 pub fn wasm_global_as_ref_const(arg1: *const wasm_global_t) -> *const wasm_ref_t;
1538}
1539extern "C" {
1540 pub fn wasm_ref_as_global_const(arg1: *const wasm_ref_t) -> *const wasm_global_t;
1541}
1542extern "C" {
1543 pub fn wasm_global_new(
1544 arg1: *mut wasm_compartment_t,
1545 arg2: *const wasm_globaltype_t,
1546 arg3: *const wasm_val_t,
1547 debug_name: *const ::std::os::raw::c_char,
1548 ) -> *mut wasm_global_t;
1549}
1550extern "C" {
1551 pub fn wasm_global_type(arg1: *const wasm_global_t) -> *mut wasm_globaltype_t;
1552}
1553extern "C" {
1554 pub fn wasm_global_get(
1555 arg1: *mut wasm_store_t,
1556 arg2: *const wasm_global_t,
1557 out: *mut wasm_val_t,
1558 );
1559}
1560extern "C" {
1561 pub fn wasm_global_set(arg1: *mut wasm_global_t, arg2: *const wasm_val_t);
1562}
1563extern "C" {
1564 pub fn wasm_table_delete(arg1: *mut wasm_table_t);
1565}
1566extern "C" {
1567 pub fn wasm_table_copy(arg1: *const wasm_table_t) -> *mut wasm_table_t;
1568}
1569extern "C" {
1570 pub fn wasm_table_same(arg1: *const wasm_table_t, arg2: *const wasm_table_t) -> bool;
1571}
1572extern "C" {
1573 pub fn wasm_table_get_host_info(arg1: *const wasm_table_t) -> *mut ::std::os::raw::c_void;
1574}
1575extern "C" {
1576 pub fn wasm_table_set_host_info(arg1: *mut wasm_table_t, arg2: *mut ::std::os::raw::c_void);
1577}
1578extern "C" {
1579 pub fn wasm_table_set_host_info_with_finalizer(
1580 arg1: *mut wasm_table_t,
1581 arg2: *mut ::std::os::raw::c_void,
1582 arg3: ::std::option::Option<unsafe extern "C" fn(arg1: *mut ::std::os::raw::c_void)>,
1583 );
1584}
1585extern "C" {
1586 pub fn wasm_table_remap_to_cloned_compartment(
1587 arg1: *const wasm_table_t,
1588 arg2: *const wasm_compartment_t,
1589 ) -> *mut wasm_table_t;
1590}
1591extern "C" {
1592 pub fn wasm_table_name(arg1: *const wasm_table_t) -> *const ::std::os::raw::c_char;
1593}
1594extern "C" {
1595 pub fn wasm_table_as_ref(arg1: *mut wasm_table_t) -> *mut wasm_ref_t;
1596}
1597extern "C" {
1598 pub fn wasm_ref_as_table(arg1: *mut wasm_ref_t) -> *mut wasm_table_t;
1599}
1600extern "C" {
1601 pub fn wasm_table_as_ref_const(arg1: *const wasm_table_t) -> *const wasm_ref_t;
1602}
1603extern "C" {
1604 pub fn wasm_ref_as_table_const(arg1: *const wasm_ref_t) -> *const wasm_table_t;
1605}
1606extern "C" {
1607 pub fn wasm_shared_table_delete(arg1: *mut wasm_shared_table_t);
1608}
1609extern "C" {
1610 pub fn wasm_table_share(arg1: *const wasm_table_t) -> *mut wasm_shared_table_t;
1611}
1612extern "C" {
1613 pub fn wasm_table_obtain(
1614 arg1: *mut wasm_store_t,
1615 arg2: *const wasm_shared_table_t,
1616 ) -> *mut wasm_table_t;
1617}
1618pub type wasm_table_size_t = u32;
1619pub const WASM_TABLE_SIZE_MAX: wasm_table_size_t = 4294967295;
1620extern "C" {
1621 pub fn wasm_table_new(
1622 arg1: *mut wasm_compartment_t,
1623 arg2: *const wasm_tabletype_t,
1624 init: *mut wasm_ref_t,
1625 debug_name: *const ::std::os::raw::c_char,
1626 ) -> *mut wasm_table_t;
1627}
1628extern "C" {
1629 pub fn wasm_table_type(arg1: *const wasm_table_t) -> *mut wasm_tabletype_t;
1630}
1631extern "C" {
1632 pub fn wasm_table_get(table: *const wasm_table_t, index: wasm_table_size_t) -> *mut wasm_ref_t;
1633}
1634extern "C" {
1635 pub fn wasm_table_set(
1636 table: *mut wasm_table_t,
1637 index: wasm_table_size_t,
1638 value: *mut wasm_ref_t,
1639 ) -> bool;
1640}
1641extern "C" {
1642 pub fn wasm_table_size(table: *const wasm_table_t) -> wasm_table_size_t;
1643}
1644extern "C" {
1645 pub fn wasm_table_grow(
1646 table: *mut wasm_table_t,
1647 delta: wasm_table_size_t,
1648 init: *mut wasm_ref_t,
1649 out_previous_size: *mut wasm_table_size_t,
1650 ) -> bool;
1651}
1652extern "C" {
1653 pub fn wasm_memory_delete(arg1: *mut wasm_memory_t);
1654}
1655extern "C" {
1656 pub fn wasm_memory_copy(arg1: *const wasm_memory_t) -> *mut wasm_memory_t;
1657}
1658extern "C" {
1659 pub fn wasm_memory_same(arg1: *const wasm_memory_t, arg2: *const wasm_memory_t) -> bool;
1660}
1661extern "C" {
1662 pub fn wasm_memory_get_host_info(arg1: *const wasm_memory_t) -> *mut ::std::os::raw::c_void;
1663}
1664extern "C" {
1665 pub fn wasm_memory_set_host_info(arg1: *mut wasm_memory_t, arg2: *mut ::std::os::raw::c_void);
1666}
1667extern "C" {
1668 pub fn wasm_memory_set_host_info_with_finalizer(
1669 arg1: *mut wasm_memory_t,
1670 arg2: *mut ::std::os::raw::c_void,
1671 arg3: ::std::option::Option<unsafe extern "C" fn(arg1: *mut ::std::os::raw::c_void)>,
1672 );
1673}
1674extern "C" {
1675 pub fn wasm_memory_remap_to_cloned_compartment(
1676 arg1: *const wasm_memory_t,
1677 arg2: *const wasm_compartment_t,
1678 ) -> *mut wasm_memory_t;
1679}
1680extern "C" {
1681 pub fn wasm_memory_name(arg1: *const wasm_memory_t) -> *const ::std::os::raw::c_char;
1682}
1683extern "C" {
1684 pub fn wasm_memory_as_ref(arg1: *mut wasm_memory_t) -> *mut wasm_ref_t;
1685}
1686extern "C" {
1687 pub fn wasm_ref_as_memory(arg1: *mut wasm_ref_t) -> *mut wasm_memory_t;
1688}
1689extern "C" {
1690 pub fn wasm_memory_as_ref_const(arg1: *const wasm_memory_t) -> *const wasm_ref_t;
1691}
1692extern "C" {
1693 pub fn wasm_ref_as_memory_const(arg1: *const wasm_ref_t) -> *const wasm_memory_t;
1694}
1695extern "C" {
1696 pub fn wasm_shared_memory_delete(arg1: *mut wasm_shared_memory_t);
1697}
1698extern "C" {
1699 pub fn wasm_memory_share(arg1: *const wasm_memory_t) -> *mut wasm_shared_memory_t;
1700}
1701extern "C" {
1702 pub fn wasm_memory_obtain(
1703 arg1: *mut wasm_store_t,
1704 arg2: *const wasm_shared_memory_t,
1705 ) -> *mut wasm_memory_t;
1706}
1707pub type wasm_memory_pages_t = u32;
1708pub const WASM_MEMORY_PAGES_MAX: wasm_memory_pages_t = 4294967295;
1709pub const MEMORY_PAGE_SIZE: size_t = 65536;
1710extern "C" {
1711 pub fn wasm_memory_new(
1712 arg1: *mut wasm_compartment_t,
1713 arg2: *const wasm_memorytype_t,
1714 debug_name: *const ::std::os::raw::c_char,
1715 ) -> *mut wasm_memory_t;
1716}
1717extern "C" {
1718 pub fn wasm_memory_type(arg1: *const wasm_memory_t) -> *mut wasm_memorytype_t;
1719}
1720extern "C" {
1721 pub fn wasm_memory_data(arg1: *mut wasm_memory_t) -> *mut ::std::os::raw::c_char;
1722}
1723extern "C" {
1724 pub fn wasm_memory_data_size(arg1: *const wasm_memory_t) -> size_t;
1725}
1726extern "C" {
1727 pub fn wasm_memory_size(arg1: *const wasm_memory_t) -> wasm_memory_pages_t;
1728}
1729extern "C" {
1730 pub fn wasm_memory_grow(
1731 arg1: *mut wasm_memory_t,
1732 delta: wasm_memory_pages_t,
1733 out_previous_size: *mut wasm_memory_pages_t,
1734 ) -> bool;
1735}
1736extern "C" {
1737 pub fn wasm_extern_delete(arg1: *mut wasm_extern_t);
1738}
1739extern "C" {
1740 pub fn wasm_extern_copy(arg1: *const wasm_extern_t) -> *mut wasm_extern_t;
1741}
1742extern "C" {
1743 pub fn wasm_extern_same(arg1: *const wasm_extern_t, arg2: *const wasm_extern_t) -> bool;
1744}
1745extern "C" {
1746 pub fn wasm_extern_get_host_info(arg1: *const wasm_extern_t) -> *mut ::std::os::raw::c_void;
1747}
1748extern "C" {
1749 pub fn wasm_extern_set_host_info(arg1: *mut wasm_extern_t, arg2: *mut ::std::os::raw::c_void);
1750}
1751extern "C" {
1752 pub fn wasm_extern_set_host_info_with_finalizer(
1753 arg1: *mut wasm_extern_t,
1754 arg2: *mut ::std::os::raw::c_void,
1755 arg3: ::std::option::Option<unsafe extern "C" fn(arg1: *mut ::std::os::raw::c_void)>,
1756 );
1757}
1758extern "C" {
1759 pub fn wasm_extern_remap_to_cloned_compartment(
1760 arg1: *const wasm_extern_t,
1761 arg2: *const wasm_compartment_t,
1762 ) -> *mut wasm_extern_t;
1763}
1764extern "C" {
1765 pub fn wasm_extern_name(arg1: *const wasm_extern_t) -> *const ::std::os::raw::c_char;
1766}
1767extern "C" {
1768 pub fn wasm_extern_as_ref(arg1: *mut wasm_extern_t) -> *mut wasm_ref_t;
1769}
1770extern "C" {
1771 pub fn wasm_ref_as_extern(arg1: *mut wasm_ref_t) -> *mut wasm_extern_t;
1772}
1773extern "C" {
1774 pub fn wasm_extern_as_ref_const(arg1: *const wasm_extern_t) -> *const wasm_ref_t;
1775}
1776extern "C" {
1777 pub fn wasm_ref_as_extern_const(arg1: *const wasm_ref_t) -> *const wasm_extern_t;
1778}
1779extern "C" {
1780 pub fn wasm_extern_kind(arg1: *const wasm_extern_t) -> wasm_externkind_t;
1781}
1782extern "C" {
1783 pub fn wasm_extern_type(arg1: *const wasm_extern_t) -> *mut wasm_externtype_t;
1784}
1785extern "C" {
1786 pub fn wasm_func_as_extern(arg1: *mut wasm_func_t) -> *mut wasm_extern_t;
1787}
1788extern "C" {
1789 pub fn wasm_global_as_extern(arg1: *mut wasm_global_t) -> *mut wasm_extern_t;
1790}
1791extern "C" {
1792 pub fn wasm_table_as_extern(arg1: *mut wasm_table_t) -> *mut wasm_extern_t;
1793}
1794extern "C" {
1795 pub fn wasm_memory_as_extern(arg1: *mut wasm_memory_t) -> *mut wasm_extern_t;
1796}
1797extern "C" {
1798 pub fn wasm_extern_as_func(arg1: *mut wasm_extern_t) -> *mut wasm_func_t;
1799}
1800extern "C" {
1801 pub fn wasm_extern_as_global(arg1: *mut wasm_extern_t) -> *mut wasm_global_t;
1802}
1803extern "C" {
1804 pub fn wasm_extern_as_table(arg1: *mut wasm_extern_t) -> *mut wasm_table_t;
1805}
1806extern "C" {
1807 pub fn wasm_extern_as_memory(arg1: *mut wasm_extern_t) -> *mut wasm_memory_t;
1808}
1809extern "C" {
1810 pub fn wasm_func_as_extern_const(arg1: *const wasm_func_t) -> *const wasm_extern_t;
1811}
1812extern "C" {
1813 pub fn wasm_global_as_extern_const(arg1: *const wasm_global_t) -> *const wasm_extern_t;
1814}
1815extern "C" {
1816 pub fn wasm_table_as_extern_const(arg1: *const wasm_table_t) -> *const wasm_extern_t;
1817}
1818extern "C" {
1819 pub fn wasm_memory_as_extern_const(arg1: *const wasm_memory_t) -> *const wasm_extern_t;
1820}
1821extern "C" {
1822 pub fn wasm_extern_as_func_const(arg1: *const wasm_extern_t) -> *const wasm_func_t;
1823}
1824extern "C" {
1825 pub fn wasm_extern_as_global_const(arg1: *const wasm_extern_t) -> *const wasm_global_t;
1826}
1827extern "C" {
1828 pub fn wasm_extern_as_table_const(arg1: *const wasm_extern_t) -> *const wasm_table_t;
1829}
1830extern "C" {
1831 pub fn wasm_extern_as_memory_const(arg1: *const wasm_extern_t) -> *const wasm_memory_t;
1832}
1833extern "C" {
1834 pub fn wasm_instance_delete(arg1: *mut wasm_instance_t);
1835}
1836extern "C" {
1837 pub fn wasm_instance_copy(arg1: *const wasm_instance_t) -> *mut wasm_instance_t;
1838}
1839extern "C" {
1840 pub fn wasm_instance_same(arg1: *const wasm_instance_t, arg2: *const wasm_instance_t) -> bool;
1841}
1842extern "C" {
1843 pub fn wasm_instance_get_host_info(arg1: *const wasm_instance_t)
1844 -> *mut ::std::os::raw::c_void;
1845}
1846extern "C" {
1847 pub fn wasm_instance_set_host_info(
1848 arg1: *mut wasm_instance_t,
1849 arg2: *mut ::std::os::raw::c_void,
1850 );
1851}
1852extern "C" {
1853 pub fn wasm_instance_set_host_info_with_finalizer(
1854 arg1: *mut wasm_instance_t,
1855 arg2: *mut ::std::os::raw::c_void,
1856 arg3: ::std::option::Option<unsafe extern "C" fn(arg1: *mut ::std::os::raw::c_void)>,
1857 );
1858}
1859extern "C" {
1860 pub fn wasm_instance_remap_to_cloned_compartment(
1861 arg1: *const wasm_instance_t,
1862 arg2: *const wasm_compartment_t,
1863 ) -> *mut wasm_instance_t;
1864}
1865extern "C" {
1866 pub fn wasm_instance_name(arg1: *const wasm_instance_t) -> *const ::std::os::raw::c_char;
1867}
1868extern "C" {
1869 pub fn wasm_instance_as_ref(arg1: *mut wasm_instance_t) -> *mut wasm_ref_t;
1870}
1871extern "C" {
1872 pub fn wasm_ref_as_instance(arg1: *mut wasm_ref_t) -> *mut wasm_instance_t;
1873}
1874extern "C" {
1875 pub fn wasm_instance_as_ref_const(arg1: *const wasm_instance_t) -> *const wasm_ref_t;
1876}
1877extern "C" {
1878 pub fn wasm_ref_as_instance_const(arg1: *const wasm_ref_t) -> *const wasm_instance_t;
1879}
1880extern "C" {
1881 pub fn wasm_instance_new(
1882 arg1: *mut wasm_store_t,
1883 arg2: *const wasm_module_t,
1884 imports: *const *const wasm_extern_t,
1885 arg3: *mut *mut wasm_trap_t,
1886 debug_name: *const ::std::os::raw::c_char,
1887 ) -> *mut wasm_instance_t;
1888}
1889extern "C" {
1890 pub fn wasm_instance_num_exports(arg1: *const wasm_instance_t) -> size_t;
1891}
1892extern "C" {
1893 pub fn wasm_instance_export(arg1: *const wasm_instance_t, index: size_t) -> *mut wasm_extern_t;
1894}
1895#[repr(C)]
1896#[derive(Debug, Copy, Clone)]
1897pub struct __crt_locale_data {
1898 pub _address: u8,
1899}
1900#[repr(C)]
1901#[derive(Debug, Copy, Clone)]
1902pub struct __crt_multibyte_data {
1903 pub _address: u8,
1904}