pub type U8 = ::core::ffi::c_uchar;
pub type U32 = ::core::ffi::c_uint;
pub type I32 = ::core::ffi::c_int;
pub type U64 = ::core::ffi::c_ulonglong;
pub type I64 = ::core::ffi::c_longlong;
pub type F32 = f32;
pub type F64 = f64;
pub type wasmFunc = ::core::option::Option<unsafe extern "C" fn()>;
pub type __m128i = [::core::ffi::c_longlong; 2usize];
pub type SETJMP_FLOAT128 = _SETJMP_FLOAT128;
pub type _JBTYPE = SETJMP_FLOAT128;
#[repr(C)]
#[derive(Debug, Copy, Clone, Hash, ConstDefault, TypedBuilder)]
pub struct wasmMemory {
pub data: *mut U8,
pub size: U32,
pub pages: U32,
pub maxPages: U32,
pub shared: bool,
pub futex: *mut ::core::ffi::c_void,
pub futexFree: ::core::option::Option<unsafe extern "C" fn(futex: *mut ::core::ffi::c_void)>,
}
#[repr(C)]
#[derive(Debug, Copy, Clone, Hash, ConstDefault, TypedBuilder)]
pub struct wasmTable {
pub data: *mut wasmFunc,
pub size: U32,
pub maxSize: U32,
}
#[repr(C)]
#[derive(Debug, Copy, Clone, Hash, ConstDefault, TypedBuilder)]
pub struct wasmFuncExport {
pub func: wasmFunc,
pub name: *mut ::core::ffi::c_char,
}
#[repr(C)]
#[derive(Debug, Copy, Clone, Hash, ConstDefault, TypedBuilder)]
pub struct wasmModuleInstance {
pub funcExports: *mut wasmFuncExport,
pub resolveImports: ::core::option::Option<
unsafe extern "C" fn(
module: *const ::core::ffi::c_char,
name: *const ::core::ffi::c_char,
) -> *mut ::core::ffi::c_void,
>,
pub newChild: ::core::option::Option<
unsafe extern "C" fn(self_: *mut wasmModuleInstance) -> *mut wasmModuleInstance,
>,
}
#[repr(C)]
#[repr(align(16))]
#[derive(Debug, Copy, Clone, Hash, ConstDefault, TypedBuilder)]
pub struct _SETJMP_FLOAT128 {
pub Part: [::core::ffi::c_ulonglong; 2usize],
}
#[repr(C)]
#[derive(Debug, Copy, Clone, Hash, ConstDefault, TypedBuilder)]
pub struct Buffer {
pub data: *mut U8,
pub length: usize,
}
#[repr(transparent)]
#[derive(Debug, Copy, Clone, Hash, PartialEq, Eq, ConstDefault)]
pub struct WasmValueType(pub ::core::ffi::c_int);
#[repr(C)]
#[derive(Debug, Copy, Clone, Hash, ConstDefault, TypedBuilder)]
pub struct WasmFunctionType {
pub parameterCount: U32,
pub parameterTypes: *mut WasmValueType,
pub resultCount: U32,
pub resultTypes: *mut WasmValueType,
}
#[repr(C)]
#[derive(Debug, Copy, Clone, Hash, ConstDefault, TypedBuilder)]
pub struct WasmLocalsDeclaration {
pub type_: WasmValueType,
pub count: U32,
}
#[repr(C)]
#[derive(Debug, Copy, Clone, Hash, ConstDefault, TypedBuilder)]
pub struct WasmLocalsDeclarations {
pub declarations: *mut WasmLocalsDeclaration,
pub declarationCount: U32,
}
#[repr(C)]
#[derive(Debug, Copy, Clone, Hash, ConstDefault, TypedBuilder)]
pub struct WasmFunction {
pub functionTypeIndex: U32,
pub localsDeclarations: WasmLocalsDeclarations,
pub code: Buffer,
pub start: usize,
pub hash: [::core::ffi::c_uchar; 20usize],
pub exportName: *mut ::core::ffi::c_char,
}
#[repr(C)]
#[derive(Debug, Copy, Clone, Hash, ConstDefault, TypedBuilder)]
pub struct WasmFunctionID {
pub hash: [::core::ffi::c_uchar; 20usize],
pub functionIndex: U32,
}
#[repr(C)]
#[derive(Debug, Copy, Clone, Hash, ConstDefault, TypedBuilder)]
pub struct WasmFunctionIDs {
pub length: usize,
pub capacity: usize,
pub functionIDs: *mut WasmFunctionID,
}
#[repr(transparent)]
#[derive(Debug, Copy, Clone, Hash, PartialEq, Eq, ConstDefault)]
pub struct WasmExportKind(pub ::core::ffi::c_int);
#[repr(C)]
#[derive(Debug, Copy, Clone, Hash, ConstDefault, TypedBuilder)]
pub struct WasmExport {
pub name: *mut ::core::ffi::c_char,
pub kind: WasmExportKind,
pub index: U32,
}
#[repr(C)]
#[derive(Debug, Copy, Clone, Hash, ConstDefault, TypedBuilder)]
pub struct WasmGlobalType {
pub valueType: WasmValueType,
pub mutable: bool,
}
#[repr(C)]
#[derive(Debug, Copy, Clone, Hash, ConstDefault, TypedBuilder)]
pub struct WasmGlobal {
pub type_: WasmGlobalType,
pub init: Buffer,
}
#[repr(transparent)]
#[derive(Debug, Copy, Clone, Hash, PartialEq, Eq, ConstDefault)]
pub struct WasmImportKind(pub ::core::ffi::c_int);
#[repr(C)]
#[derive(Debug, Copy, Clone, Hash, ConstDefault, TypedBuilder)]
pub struct WasmFunctionImport {
pub module: *mut ::core::ffi::c_char,
pub name: *mut ::core::ffi::c_char,
pub functionTypeIndex: U32,
}
#[repr(C)]
#[derive(Debug, Copy, Clone, Hash, ConstDefault, TypedBuilder)]
pub struct WasmFunctionImports {
pub length: usize,
pub capacity: usize,
pub imports: *mut WasmFunctionImport,
}
#[repr(C)]
#[derive(Debug, Copy, Clone, Hash, ConstDefault, TypedBuilder)]
pub struct WasmGlobalImport {
pub module: *mut ::core::ffi::c_char,
pub name: *mut ::core::ffi::c_char,
pub globalType: WasmGlobalType,
}
#[repr(C)]
#[derive(Debug, Copy, Clone, Hash, ConstDefault, TypedBuilder)]
pub struct WasmGlobalImports {
pub length: usize,
pub capacity: usize,
pub imports: *mut WasmGlobalImport,
}
#[repr(C)]
#[derive(Debug, Copy, Clone, Hash, ConstDefault, TypedBuilder)]
pub struct WasmMemoryImport {
pub module: *mut ::core::ffi::c_char,
pub name: *mut ::core::ffi::c_char,
pub min: U32,
pub max: U32,
pub shared: bool,
}
#[repr(C)]
#[derive(Debug, Copy, Clone, Hash, ConstDefault, TypedBuilder)]
pub struct WasmMemoryImports {
pub length: usize,
pub capacity: usize,
pub imports: *mut WasmMemoryImport,
}
#[repr(C)]
#[derive(Debug, Copy, Clone, Hash, ConstDefault, TypedBuilder)]
pub struct WasmTableImport {
pub module: *mut ::core::ffi::c_char,
pub name: *mut ::core::ffi::c_char,
pub min: U32,
pub max: U32,
pub shared: bool,
}
#[repr(C)]
#[derive(Debug, Copy, Clone, Hash, ConstDefault, TypedBuilder)]
pub struct WasmTableImports {
pub length: usize,
pub capacity: usize,
pub imports: *mut WasmTableImport,
}
#[repr(C)]
#[derive(Debug, Copy, Clone, Hash, ConstDefault, TypedBuilder)]
pub struct WasmMemory {
pub min: U32,
pub max: U32,
pub shared: bool,
}
#[repr(C)]
#[derive(Debug, Copy, Clone, Hash, ConstDefault, TypedBuilder)]
pub struct WasmDataSegment {
pub memoryIndex: U32,
pub offset: Buffer,
pub bytes: Buffer,
pub passive: bool,
}
#[repr(transparent)]
#[derive(Debug, Copy, Clone, Hash, PartialEq, Eq, ConstDefault)]
pub struct WasmDataSegmentMode(pub ::core::ffi::c_int);
#[repr(C)]
#[derive(Debug, Copy, Clone, Hash, ConstDefault, TypedBuilder)]
pub struct WasmTable {
pub min: U32,
pub max: U32,
pub shared: bool,
}
#[repr(C)]
#[derive(Debug, Copy, Clone, Hash, ConstDefault, TypedBuilder)]
pub struct WasmElementSegment {
pub tableIndex: U32,
pub offset: Buffer,
pub functionIndexCount: U32,
pub functionIndices: *mut U32,
}
#[repr(C)]
#[derive(Debug, Copy, Clone, Hash, ConstDefault, TypedBuilder)]
pub struct WasmDebugSection {
pub name: *mut ::core::ffi::c_char,
pub buffer: Buffer,
}
#[repr(C)]
#[derive(Debug, Copy, Clone, Hash, ConstDefault, TypedBuilder)]
pub struct WasmDebugSections {
pub length: usize,
pub capacity: usize,
pub debugSections: *mut WasmDebugSection,
}
#[repr(C)]
#[derive(Debug, Copy, Clone, Hash, ConstDefault, TypedBuilder)]
pub struct WasmDebugLine {
pub address: U64,
pub path: *mut ::core::ffi::c_char,
pub number: U64,
}
#[repr(C)]
#[derive(Debug, Copy, Clone, Hash, ConstDefault, TypedBuilder)]
pub struct WasmDebugLines {
pub length: usize,
pub capacity: usize,
pub debugLines: *mut WasmDebugLine,
}
#[repr(C)]
#[derive(Debug, Copy, Clone, Hash, ConstDefault, TypedBuilder)]
pub struct WasmNames {
pub length: usize,
pub capacity: usize,
pub names: *mut *mut ::core::ffi::c_char,
}
#[repr(C)]
#[derive(Debug, Copy, Clone, Hash, ConstDefault, TypedBuilder)]
pub struct WasmFunctionTypes {
pub functionTypes: *mut WasmFunctionType,
pub count: U32,
}
#[repr(C)]
#[derive(Debug, Copy, Clone, Hash, ConstDefault, TypedBuilder)]
pub struct WasmFunctions {
pub functions: *mut WasmFunction,
pub count: U32,
}
#[repr(C)]
#[derive(Debug, Copy, Clone, Hash, ConstDefault, TypedBuilder)]
pub struct WasmExports {
pub exports: *mut WasmExport,
pub count: U32,
}
#[repr(C)]
#[derive(Debug, Copy, Clone, Hash, ConstDefault, TypedBuilder)]
pub struct WasmGlobals {
pub globals: *mut WasmGlobal,
pub count: U32,
}
#[repr(C)]
#[derive(Debug, Copy, Clone, Hash, ConstDefault, TypedBuilder)]
pub struct WasmMemories {
pub memories: *mut WasmMemory,
pub count: U32,
}
#[repr(C)]
#[derive(Debug, Copy, Clone, Hash, ConstDefault, TypedBuilder)]
pub struct WasmDataSegments {
pub dataSegments: *mut WasmDataSegment,
pub count: U32,
}
#[repr(C)]
#[derive(Debug, Copy, Clone, Hash, ConstDefault, TypedBuilder)]
pub struct WasmTables {
pub tables: *mut WasmTable,
pub count: U32,
}
#[repr(C)]
#[derive(Debug, Copy, Clone, Hash, ConstDefault, TypedBuilder)]
pub struct WasmElementSegments {
pub elementSegments: *mut WasmElementSegment,
pub count: U32,
}
#[repr(C)]
#[derive(Debug, Copy, Clone, Hash, ConstDefault, TypedBuilder)]
pub struct WasmModule {
pub length: usize,
pub functionTypes: WasmFunctionTypes,
pub functions: WasmFunctions,
pub exports: WasmExports,
pub globals: WasmGlobals,
pub functionImports: WasmFunctionImports,
pub globalImports: WasmGlobalImports,
pub memoryImports: WasmMemoryImports,
pub memories: WasmMemories,
pub dataSegments: WasmDataSegments,
pub tableImports: WasmTableImports,
pub tables: WasmTables,
pub elementSegments: WasmElementSegments,
pub startFunctionIndex: U32,
pub hasStartFunction: bool,
pub debugSections: WasmDebugSections,
pub debugLines: WasmDebugLines,
pub functionNames: WasmNames,
}
#[repr(C)]
#[derive(Debug, Copy, Clone, Hash, ConstDefault, TypedBuilder)]
pub struct WasmCWriteModuleOptions {
pub outputPath: *const ::core::ffi::c_char,
pub threadCount: U32,
pub functionsPerFile: U32,
pub pretty: bool,
pub debug: bool,
pub multipleModules: bool,
pub dataSegmentMode: WasmDataSegmentMode,
}
#[repr(transparent)]
#[derive(Debug, Copy, Clone, Hash, PartialEq, Eq, ConstDefault)]
pub struct WasmOpcode(pub ::core::ffi::c_int);
#[repr(transparent)]
#[derive(Debug, Copy, Clone, Hash, PartialEq, Eq, ConstDefault)]
pub struct WasmMiscOpcode(pub ::core::ffi::c_int);
#[repr(transparent)]
#[derive(Debug, Copy, Clone, Hash, PartialEq, Eq, ConstDefault)]
pub struct WasmThreadsOpcode(pub ::core::ffi::c_int);
#[repr(C)]
#[derive(Debug, Copy, Clone, Hash, ConstDefault, TypedBuilder)]
pub struct WasmLocalInstruction {
pub localIndex: U32,
}
#[repr(C)]
#[derive(Debug, Copy, Clone, Hash, ConstDefault, TypedBuilder)]
pub struct WasmGlobalInstruction {
pub globalIndex: U32,
}
#[repr(C)]
#[derive(Copy, Clone)]
pub struct WasmConstInstruction {
pub value: WasmValue,
}
#[repr(C)]
#[derive(Debug, Copy, Clone, Hash, ConstDefault, TypedBuilder)]
pub struct WasmMemoryArgumentInstruction {
pub align: U32,
pub offset: U32,
}
#[repr(C)]
#[derive(Debug, Copy, Clone, Hash, ConstDefault, TypedBuilder)]
pub struct WasmCallInstruction {
pub funcIndex: U32,
}
#[repr(C)]
#[derive(Debug, Copy, Clone, Hash, ConstDefault, TypedBuilder)]
pub struct WasmCallIndirectInstruction {
pub functionTypeIndex: U32,
pub tableIndex: U32,
}
#[repr(C)]
#[derive(Debug, Copy, Clone, Hash, ConstDefault, TypedBuilder)]
pub struct WasmBranchInstruction {
pub labelIndex: U32,
}
#[repr(C)]
#[derive(Debug, Copy, Clone, Hash, ConstDefault, TypedBuilder)]
pub struct WasmBranchTableInstruction {
pub labelIndices: *mut U32,
pub labelIndexCount: U32,
pub defaultLabelIndex: U32,
}
#[repr(C)]
#[derive(Debug, Copy, Clone, Hash, ConstDefault, TypedBuilder)]
pub struct WasmMemoryInstruction {
pub memoryIndex: U32,
}
#[repr(C)]
#[derive(Debug, Copy, Clone, Hash, ConstDefault, TypedBuilder)]
pub struct WasmMemoryCopyInstruction {
pub memoryIndex1: U32,
pub memoryIndex2: U32,
}
#[repr(C)]
#[derive(Debug, Copy, Clone, Hash, ConstDefault, TypedBuilder)]
pub struct WasmMemoryInitInstruction {
pub dataSegmentIndex: U32,
pub memoryIndex: U32,
}
#[repr(C)]
#[derive(Debug, Copy, Clone, Hash, ConstDefault, TypedBuilder)]
pub struct WasmLabel {
pub index: U32,
pub typeStackLength: usize,
pub type_: *mut WasmValueType,
}
#[repr(C)]
#[derive(Debug, Copy, Clone, Hash, ConstDefault, TypedBuilder)]
pub struct WasmLabels {
pub length: usize,
pub capacity: usize,
pub labels: *mut WasmLabel,
}
#[repr(C)]
#[derive(Debug, Copy, Clone, Hash, ConstDefault, TypedBuilder)]
pub struct WasmLabelStack {
pub labels: WasmLabels,
pub nextLabelIndex: U32,
}
#[repr(C)]
#[derive(Debug, Copy, Clone, Hash, ConstDefault, TypedBuilder)]
pub struct WasmModuleReader {
pub buffer: Buffer,
pub module: *mut WasmModule,
pub debug: bool,
}
#[repr(transparent)]
#[derive(Debug, Copy, Clone, Hash, PartialEq, Eq, ConstDefault)]
pub struct WasmModuleReaderErrorCode(pub ::core::ffi::c_int);
#[repr(C)]
#[derive(Debug, Copy, Clone, Hash, ConstDefault, TypedBuilder)]
pub struct WasmModuleReaderError {
pub code: WasmModuleReaderErrorCode,
}
#[repr(transparent)]
#[derive(Debug, Copy, Clone, Hash, PartialEq, Eq, ConstDefault)]
pub struct WasmSectionID(pub ::core::ffi::c_int);
#[repr(transparent)]
#[derive(Debug, Copy, Clone, Hash, PartialEq, Eq, ConstDefault)]
pub struct WasmNameSubsectionID(pub ::core::ffi::c_int);
#[repr(C)]
#[derive(Debug, Copy, Clone, Hash, ConstDefault, TypedBuilder)]
pub struct StringBuilder {
pub string: *mut ::core::ffi::c_char,
pub length: usize,
pub capacity: usize,
}
#[repr(C)]
#[derive(Debug, Copy, Clone, Hash, ConstDefault, TypedBuilder)]
pub struct WasmTypeStack {
pub length: usize,
pub capacity: usize,
pub valueTypes: *mut WasmValueType,
}
pub const wasmTableTypeFuncRef: U8 = 112;
#[repr(C)]
#[derive(Copy, Clone)]
pub union WasmValue {
pub i32_: I32,
pub i64_: I64,
pub f32_: F32,
pub f64_: F64,
}
impl WasmValueType {
pub const wasmValueTypeI32: WasmValueType = WasmValueType(0);
pub const wasmValueTypeI64: WasmValueType = WasmValueType(1);
pub const wasmValueTypeF32: WasmValueType = WasmValueType(2);
pub const wasmValueTypeF64: WasmValueType = WasmValueType(3);
pub const wasmValueType_count: WasmValueType = WasmValueType(4);
}
impl WasmExportKind {
pub const wasmExportKindFunction: WasmExportKind = WasmExportKind(0);
pub const wasmExportKindTable: WasmExportKind = WasmExportKind(1);
pub const wasmExportKindMemory: WasmExportKind = WasmExportKind(2);
pub const wasmExportKindGlobal: WasmExportKind = WasmExportKind(3);
pub const wasmExportKind_count: WasmExportKind = WasmExportKind(4);
}
impl WasmImportKind {
pub const wasmImportKindFunction: WasmImportKind = WasmImportKind(0);
pub const wasmImportKindTable: WasmImportKind = WasmImportKind(1);
pub const wasmImportKindMemory: WasmImportKind = WasmImportKind(2);
pub const wasmImportKindGlobal: WasmImportKind = WasmImportKind(3);
pub const wasmImportKind_count: WasmImportKind = WasmImportKind(4);
}
impl WasmDataSegmentMode {
pub const wasmDataSegmentModeArrays: WasmDataSegmentMode = WasmDataSegmentMode(0);
pub const wasmDataSegmentModeGNULD: WasmDataSegmentMode = WasmDataSegmentMode(1);
pub const wasmDataSegmentModeSectcreate1: WasmDataSegmentMode = WasmDataSegmentMode(2);
pub const wasmDataSegmentModeSectcreate2: WasmDataSegmentMode = WasmDataSegmentMode(3);
}
impl WasmOpcode {
pub const wasmOpcodeUnreachable: WasmOpcode = WasmOpcode(0);
pub const wasmOpcodeNop: WasmOpcode = WasmOpcode(1);
pub const wasmOpcodeBlock: WasmOpcode = WasmOpcode(2);
pub const wasmOpcodeLoop: WasmOpcode = WasmOpcode(3);
pub const wasmOpcodeIf: WasmOpcode = WasmOpcode(4);
pub const wasmOpcodeElse: WasmOpcode = WasmOpcode(5);
pub const wasmOpcodeEnd: WasmOpcode = WasmOpcode(11);
pub const wasmOpcodeBr: WasmOpcode = WasmOpcode(12);
pub const wasmOpcodeBrIf: WasmOpcode = WasmOpcode(13);
pub const wasmOpcodeBrTable: WasmOpcode = WasmOpcode(14);
pub const wasmOpcodeReturn: WasmOpcode = WasmOpcode(15);
pub const wasmOpcodeCall: WasmOpcode = WasmOpcode(16);
pub const wasmOpcodeCallIndirect: WasmOpcode = WasmOpcode(17);
pub const wasmOpcodeDrop: WasmOpcode = WasmOpcode(26);
pub const wasmOpcodeSelect: WasmOpcode = WasmOpcode(27);
pub const wasmOpcodeLocalGet: WasmOpcode = WasmOpcode(32);
pub const wasmOpcodeLocalSet: WasmOpcode = WasmOpcode(33);
pub const wasmOpcodeLocalTee: WasmOpcode = WasmOpcode(34);
pub const wasmOpcodeGlobalGet: WasmOpcode = WasmOpcode(35);
pub const wasmOpcodeGlobalSet: WasmOpcode = WasmOpcode(36);
pub const wasmOpcodeI32Load: WasmOpcode = WasmOpcode(40);
pub const wasmOpcodeI64Load: WasmOpcode = WasmOpcode(41);
pub const wasmOpcodeF32Load: WasmOpcode = WasmOpcode(42);
pub const wasmOpcodeF64Load: WasmOpcode = WasmOpcode(43);
pub const wasmOpcodeI32Load8S: WasmOpcode = WasmOpcode(44);
pub const wasmOpcodeI32Load8U: WasmOpcode = WasmOpcode(45);
pub const wasmOpcodeI32Load16S: WasmOpcode = WasmOpcode(46);
pub const wasmOpcodeI32Load16U: WasmOpcode = WasmOpcode(47);
pub const wasmOpcodeI64Load8S: WasmOpcode = WasmOpcode(48);
pub const wasmOpcodeI64Load8U: WasmOpcode = WasmOpcode(49);
pub const wasmOpcodeI64Load16S: WasmOpcode = WasmOpcode(50);
pub const wasmOpcodeI64Load16U: WasmOpcode = WasmOpcode(51);
pub const wasmOpcodeI64Load32S: WasmOpcode = WasmOpcode(52);
pub const wasmOpcodeI64Load32U: WasmOpcode = WasmOpcode(53);
pub const wasmOpcodeI32Store: WasmOpcode = WasmOpcode(54);
pub const wasmOpcodeI64Store: WasmOpcode = WasmOpcode(55);
pub const wasmOpcodeF32Store: WasmOpcode = WasmOpcode(56);
pub const wasmOpcodeF64Store: WasmOpcode = WasmOpcode(57);
pub const wasmOpcodeI32Store8: WasmOpcode = WasmOpcode(58);
pub const wasmOpcodeI32Store16: WasmOpcode = WasmOpcode(59);
pub const wasmOpcodeI64Store8: WasmOpcode = WasmOpcode(60);
pub const wasmOpcodeI64Store16: WasmOpcode = WasmOpcode(61);
pub const wasmOpcodeI64Store32: WasmOpcode = WasmOpcode(62);
pub const wasmOpcodeMemorySize: WasmOpcode = WasmOpcode(63);
pub const wasmOpcodeMemoryGrow: WasmOpcode = WasmOpcode(64);
pub const wasmOpcodeI32Const: WasmOpcode = WasmOpcode(65);
pub const wasmOpcodeI64Const: WasmOpcode = WasmOpcode(66);
pub const wasmOpcodeF32Const: WasmOpcode = WasmOpcode(67);
pub const wasmOpcodeF64Const: WasmOpcode = WasmOpcode(68);
pub const wasmOpcodeI32Eqz: WasmOpcode = WasmOpcode(69);
pub const wasmOpcodeI32Eq: WasmOpcode = WasmOpcode(70);
pub const wasmOpcodeI32Ne: WasmOpcode = WasmOpcode(71);
pub const wasmOpcodeI32LtS: WasmOpcode = WasmOpcode(72);
pub const wasmOpcodeI32LtU: WasmOpcode = WasmOpcode(73);
pub const wasmOpcodeI32GtS: WasmOpcode = WasmOpcode(74);
pub const wasmOpcodeI32GtU: WasmOpcode = WasmOpcode(75);
pub const wasmOpcodeI32LeS: WasmOpcode = WasmOpcode(76);
pub const wasmOpcodeI32LeU: WasmOpcode = WasmOpcode(77);
pub const wasmOpcodeI32GeS: WasmOpcode = WasmOpcode(78);
pub const wasmOpcodeI32GeU: WasmOpcode = WasmOpcode(79);
pub const wasmOpcodeI64Eqz: WasmOpcode = WasmOpcode(80);
pub const wasmOpcodeI64Eq: WasmOpcode = WasmOpcode(81);
pub const wasmOpcodeI64Ne: WasmOpcode = WasmOpcode(82);
pub const wasmOpcodeI64LtS: WasmOpcode = WasmOpcode(83);
pub const wasmOpcodeI64LtU: WasmOpcode = WasmOpcode(84);
pub const wasmOpcodeI64GtS: WasmOpcode = WasmOpcode(85);
pub const wasmOpcodeI64GtU: WasmOpcode = WasmOpcode(86);
pub const wasmOpcodeI64LeS: WasmOpcode = WasmOpcode(87);
pub const wasmOpcodeI64LeU: WasmOpcode = WasmOpcode(88);
pub const wasmOpcodeI64GeS: WasmOpcode = WasmOpcode(89);
pub const wasmOpcodeI64GeU: WasmOpcode = WasmOpcode(90);
pub const wasmOpcodeF32Eq: WasmOpcode = WasmOpcode(91);
pub const wasmOpcodeF32Ne: WasmOpcode = WasmOpcode(92);
pub const wasmOpcodeF32Lt: WasmOpcode = WasmOpcode(93);
pub const wasmOpcodeF32Gt: WasmOpcode = WasmOpcode(94);
pub const wasmOpcodeF32Le: WasmOpcode = WasmOpcode(95);
pub const wasmOpcodeF32Ge: WasmOpcode = WasmOpcode(96);
pub const wasmOpcodeF64Eq: WasmOpcode = WasmOpcode(97);
pub const wasmOpcodeF64Ne: WasmOpcode = WasmOpcode(98);
pub const wasmOpcodeF64Lt: WasmOpcode = WasmOpcode(99);
pub const wasmOpcodeF64Gt: WasmOpcode = WasmOpcode(100);
pub const wasmOpcodeF64Le: WasmOpcode = WasmOpcode(101);
pub const wasmOpcodeF64Ge: WasmOpcode = WasmOpcode(102);
pub const wasmOpcodeI32Clz: WasmOpcode = WasmOpcode(103);
pub const wasmOpcodeI32Ctz: WasmOpcode = WasmOpcode(104);
pub const wasmOpcodeI32PopCnt: WasmOpcode = WasmOpcode(105);
pub const wasmOpcodeI32Add: WasmOpcode = WasmOpcode(106);
pub const wasmOpcodeI32Sub: WasmOpcode = WasmOpcode(107);
pub const wasmOpcodeI32Mul: WasmOpcode = WasmOpcode(108);
pub const wasmOpcodeI32DivS: WasmOpcode = WasmOpcode(109);
pub const wasmOpcodeI32DivU: WasmOpcode = WasmOpcode(110);
pub const wasmOpcodeI32RemS: WasmOpcode = WasmOpcode(111);
pub const wasmOpcodeI32RemU: WasmOpcode = WasmOpcode(112);
pub const wasmOpcodeI32And: WasmOpcode = WasmOpcode(113);
pub const wasmOpcodeI32Or: WasmOpcode = WasmOpcode(114);
pub const wasmOpcodeI32Xor: WasmOpcode = WasmOpcode(115);
pub const wasmOpcodeI32Shl: WasmOpcode = WasmOpcode(116);
pub const wasmOpcodeI32ShrS: WasmOpcode = WasmOpcode(117);
pub const wasmOpcodeI32ShrU: WasmOpcode = WasmOpcode(118);
pub const wasmOpcodeI32Rotl: WasmOpcode = WasmOpcode(119);
pub const wasmOpcodeI32Rotr: WasmOpcode = WasmOpcode(120);
pub const wasmOpcodeI64Clz: WasmOpcode = WasmOpcode(121);
pub const wasmOpcodeI64Ctz: WasmOpcode = WasmOpcode(122);
pub const wasmOpcodeI64PopCnt: WasmOpcode = WasmOpcode(123);
pub const wasmOpcodeI64Add: WasmOpcode = WasmOpcode(124);
pub const wasmOpcodeI64Sub: WasmOpcode = WasmOpcode(125);
pub const wasmOpcodeI64Mul: WasmOpcode = WasmOpcode(126);
pub const wasmOpcodeI64DivS: WasmOpcode = WasmOpcode(127);
pub const wasmOpcodeI64DivU: WasmOpcode = WasmOpcode(128);
pub const wasmOpcodeI64RemS: WasmOpcode = WasmOpcode(129);
pub const wasmOpcodeI64RemU: WasmOpcode = WasmOpcode(130);
pub const wasmOpcodeI64And: WasmOpcode = WasmOpcode(131);
pub const wasmOpcodeI64Or: WasmOpcode = WasmOpcode(132);
pub const wasmOpcodeI64Xor: WasmOpcode = WasmOpcode(133);
pub const wasmOpcodeI64Shl: WasmOpcode = WasmOpcode(134);
pub const wasmOpcodeI64ShrS: WasmOpcode = WasmOpcode(135);
pub const wasmOpcodeI64ShrU: WasmOpcode = WasmOpcode(136);
pub const wasmOpcodeI64Rotl: WasmOpcode = WasmOpcode(137);
pub const wasmOpcodeI64Rotr: WasmOpcode = WasmOpcode(138);
pub const wasmOpcodeF32Abs: WasmOpcode = WasmOpcode(139);
pub const wasmOpcodeF32Neg: WasmOpcode = WasmOpcode(140);
pub const wasmOpcodeF32Ceil: WasmOpcode = WasmOpcode(141);
pub const wasmOpcodeF32Floor: WasmOpcode = WasmOpcode(142);
pub const wasmOpcodeF32Trunc: WasmOpcode = WasmOpcode(143);
pub const wasmOpcodeF32Nearest: WasmOpcode = WasmOpcode(144);
pub const wasmOpcodeF32Sqrt: WasmOpcode = WasmOpcode(145);
pub const wasmOpcodeF32Add: WasmOpcode = WasmOpcode(146);
pub const wasmOpcodeF32Sub: WasmOpcode = WasmOpcode(147);
pub const wasmOpcodeF32Mul: WasmOpcode = WasmOpcode(148);
pub const wasmOpcodeF32Div: WasmOpcode = WasmOpcode(149);
pub const wasmOpcodeF32Min: WasmOpcode = WasmOpcode(150);
pub const wasmOpcodeF32Max: WasmOpcode = WasmOpcode(151);
pub const wasmOpcodeF32CopySign: WasmOpcode = WasmOpcode(152);
pub const wasmOpcodeF64Abs: WasmOpcode = WasmOpcode(153);
pub const wasmOpcodeF64Neg: WasmOpcode = WasmOpcode(154);
pub const wasmOpcodeF64Ceil: WasmOpcode = WasmOpcode(155);
pub const wasmOpcodeF64Floor: WasmOpcode = WasmOpcode(156);
pub const wasmOpcodeF64Trunc: WasmOpcode = WasmOpcode(157);
pub const wasmOpcodeF64Nearest: WasmOpcode = WasmOpcode(158);
pub const wasmOpcodeF64Sqrt: WasmOpcode = WasmOpcode(159);
pub const wasmOpcodeF64Add: WasmOpcode = WasmOpcode(160);
pub const wasmOpcodeF64Sub: WasmOpcode = WasmOpcode(161);
pub const wasmOpcodeF64Mul: WasmOpcode = WasmOpcode(162);
pub const wasmOpcodeF64Div: WasmOpcode = WasmOpcode(163);
pub const wasmOpcodeF64Min: WasmOpcode = WasmOpcode(164);
pub const wasmOpcodeF64Max: WasmOpcode = WasmOpcode(165);
pub const wasmOpcodeF64CopySign: WasmOpcode = WasmOpcode(166);
pub const wasmOpcodeI32WrapI64: WasmOpcode = WasmOpcode(167);
pub const wasmOpcodeI32TruncF32S: WasmOpcode = WasmOpcode(168);
pub const wasmOpcodeI32TruncF32U: WasmOpcode = WasmOpcode(169);
pub const wasmOpcodeI32TruncF64S: WasmOpcode = WasmOpcode(170);
pub const wasmOpcodeI32TruncF64U: WasmOpcode = WasmOpcode(171);
pub const wasmOpcodeI64ExtendI32S: WasmOpcode = WasmOpcode(172);
pub const wasmOpcodeI64ExtendI32U: WasmOpcode = WasmOpcode(173);
pub const wasmOpcodeI64TruncF32S: WasmOpcode = WasmOpcode(174);
pub const wasmOpcodeI64TruncF32U: WasmOpcode = WasmOpcode(175);
pub const wasmOpcodeI64TruncF64S: WasmOpcode = WasmOpcode(176);
pub const wasmOpcodeI64TruncF64U: WasmOpcode = WasmOpcode(177);
pub const wasmOpcodeF32ConvertI32S: WasmOpcode = WasmOpcode(178);
pub const wasmOpcodeF32ConvertI32U: WasmOpcode = WasmOpcode(179);
pub const wasmOpcodeF32ConvertI64S: WasmOpcode = WasmOpcode(180);
pub const wasmOpcodeF32ConvertI64U: WasmOpcode = WasmOpcode(181);
pub const wasmOpcodeF32DemoteF64: WasmOpcode = WasmOpcode(182);
pub const wasmOpcodeF64ConvertI32S: WasmOpcode = WasmOpcode(183);
pub const wasmOpcodeF64ConvertI32U: WasmOpcode = WasmOpcode(184);
pub const wasmOpcodeF64ConvertI64S: WasmOpcode = WasmOpcode(185);
pub const wasmOpcodeF64ConvertI64U: WasmOpcode = WasmOpcode(186);
pub const wasmOpcodeF64PromoteF32: WasmOpcode = WasmOpcode(187);
pub const wasmOpcodeI32ReinterpretF32: WasmOpcode = WasmOpcode(188);
pub const wasmOpcodeI64ReinterpretF64: WasmOpcode = WasmOpcode(189);
pub const wasmOpcodeF32ReinterpretI32: WasmOpcode = WasmOpcode(190);
pub const wasmOpcodeF64ReinterpretI64: WasmOpcode = WasmOpcode(191);
pub const wasmOpcodeI32Extend8S: WasmOpcode = WasmOpcode(192);
pub const wasmOpcodeI32Extend16S: WasmOpcode = WasmOpcode(193);
pub const wasmOpcodeI64Extend8S: WasmOpcode = WasmOpcode(194);
pub const wasmOpcodeI64Extend16S: WasmOpcode = WasmOpcode(195);
pub const wasmOpcodeI64Extend32S: WasmOpcode = WasmOpcode(196);
pub const wasmOpcodeThreadsPrefix: WasmOpcode = WasmOpcode(254);
pub const wasmOpcodeMiscPrefix: WasmOpcode = WasmOpcode(252);
}
impl WasmMiscOpcode {
pub const wasmMiscOpcodeI32TruncSatF32S: WasmMiscOpcode = WasmMiscOpcode(0);
pub const wasmMiscOpcodeI32TruncSatF32U: WasmMiscOpcode = WasmMiscOpcode(1);
pub const wasmMiscOpcodeI32TruncSatF64S: WasmMiscOpcode = WasmMiscOpcode(2);
pub const wasmMiscOpcodeI32TruncSatF64U: WasmMiscOpcode = WasmMiscOpcode(3);
pub const wasmMiscOpcodeI64TruncSatF32S: WasmMiscOpcode = WasmMiscOpcode(4);
pub const wasmMiscOpcodeI64TruncSatF32U: WasmMiscOpcode = WasmMiscOpcode(5);
pub const wasmMiscOpcodeI64TruncSatF64S: WasmMiscOpcode = WasmMiscOpcode(6);
pub const wasmMiscOpcodeI64TruncSatF64U: WasmMiscOpcode = WasmMiscOpcode(7);
pub const wasmMiscOpcodeMemoryInit: WasmMiscOpcode = WasmMiscOpcode(8);
pub const wasmMiscOpcodeDataDrop: WasmMiscOpcode = WasmMiscOpcode(9);
pub const wasmMiscOpcodeMemoryCopy: WasmMiscOpcode = WasmMiscOpcode(10);
pub const wasmMiscOpcodeMemoryFill: WasmMiscOpcode = WasmMiscOpcode(11);
pub const wasmMiscOpcodeTableInit: WasmMiscOpcode = WasmMiscOpcode(12);
pub const wasmMiscOpcodeElemDrop: WasmMiscOpcode = WasmMiscOpcode(13);
pub const wasmMiscOpcodeTableCopy: WasmMiscOpcode = WasmMiscOpcode(14);
pub const wasmMiscOpcodeTableGrow: WasmMiscOpcode = WasmMiscOpcode(15);
pub const wasmMiscOpcodeTableSize: WasmMiscOpcode = WasmMiscOpcode(16);
pub const wasmMiscOpcodeTableFill: WasmMiscOpcode = WasmMiscOpcode(17);
}
impl WasmThreadsOpcode {
pub const wasmThreadsOpcodeMemoryAtomicNotify: WasmThreadsOpcode = WasmThreadsOpcode(0);
pub const wasmThreadsOpcodeMemoryAtomicWait32: WasmThreadsOpcode = WasmThreadsOpcode(1);
pub const wasmThreadsOpcodeMemoryAtomicWait64: WasmThreadsOpcode = WasmThreadsOpcode(2);
pub const wasmThreadsOpcodeAtomicFence: WasmThreadsOpcode = WasmThreadsOpcode(3);
pub const wasmThreadsOpcodeI32AtomicLoad: WasmThreadsOpcode = WasmThreadsOpcode(16);
pub const wasmThreadsOpcodeI64AtomicLoad: WasmThreadsOpcode = WasmThreadsOpcode(17);
pub const wasmThreadsOpcodeI32AtomicLoad8U: WasmThreadsOpcode = WasmThreadsOpcode(18);
pub const wasmThreadsOpcodeI32AtomicLoad16U: WasmThreadsOpcode = WasmThreadsOpcode(19);
pub const wasmThreadsOpcodeI64AtomicLoad8U: WasmThreadsOpcode = WasmThreadsOpcode(20);
pub const wasmThreadsOpcodeI64AtomicLoad16U: WasmThreadsOpcode = WasmThreadsOpcode(21);
pub const wasmThreadsOpcodeI64AtomicLoad32U: WasmThreadsOpcode = WasmThreadsOpcode(22);
pub const wasmThreadsOpcodeI32AtomicStore: WasmThreadsOpcode = WasmThreadsOpcode(23);
pub const wasmThreadsOpcodeI64AtomicStore: WasmThreadsOpcode = WasmThreadsOpcode(24);
pub const wasmThreadsOpcodeI32AtomicStore8: WasmThreadsOpcode = WasmThreadsOpcode(25);
pub const wasmThreadsOpcodeI32AtomicStore16: WasmThreadsOpcode = WasmThreadsOpcode(26);
pub const wasmThreadsOpcodeI64AtomicStore8: WasmThreadsOpcode = WasmThreadsOpcode(27);
pub const wasmThreadsOpcodeI64AtomicStore16: WasmThreadsOpcode = WasmThreadsOpcode(28);
pub const wasmThreadsOpcodeI64AtomicStore32: WasmThreadsOpcode = WasmThreadsOpcode(29);
pub const wasmThreadsOpcodeI32AtomicRMWAdd: WasmThreadsOpcode = WasmThreadsOpcode(30);
pub const wasmThreadsOpcodeI64AtomicRMWAdd: WasmThreadsOpcode = WasmThreadsOpcode(31);
pub const wasmThreadsOpcodeI32AtomicRMW8AddU: WasmThreadsOpcode = WasmThreadsOpcode(32);
pub const wasmThreadsOpcodeI32AtomicRMW16AddU: WasmThreadsOpcode = WasmThreadsOpcode(33);
pub const wasmThreadsOpcodeI64AtomicRMW8AddU: WasmThreadsOpcode = WasmThreadsOpcode(34);
pub const wasmThreadsOpcodeI64AtomicRMW16AddU: WasmThreadsOpcode = WasmThreadsOpcode(35);
pub const wasmThreadsOpcodeI64AtomicRMW32AddU: WasmThreadsOpcode = WasmThreadsOpcode(36);
pub const wasmThreadsOpcodeI32AtomicRMWSub: WasmThreadsOpcode = WasmThreadsOpcode(37);
pub const wasmThreadsOpcodeI64AtomicRMWSub: WasmThreadsOpcode = WasmThreadsOpcode(38);
pub const wasmThreadsOpcodeI32AtomicRMW8SubU: WasmThreadsOpcode = WasmThreadsOpcode(39);
pub const wasmThreadsOpcodeI32AtomicRMW16SubU: WasmThreadsOpcode = WasmThreadsOpcode(40);
pub const wasmThreadsOpcodeI64AtomicRMW8SubU: WasmThreadsOpcode = WasmThreadsOpcode(41);
pub const wasmThreadsOpcodeI64AtomicRMW16SubU: WasmThreadsOpcode = WasmThreadsOpcode(42);
pub const wasmThreadsOpcodeI64AtomicRMW32SubU: WasmThreadsOpcode = WasmThreadsOpcode(43);
pub const wasmThreadsOpcodeI32AtomicRMWAnd: WasmThreadsOpcode = WasmThreadsOpcode(44);
pub const wasmThreadsOpcodeI64AtomicRMWAnd: WasmThreadsOpcode = WasmThreadsOpcode(45);
pub const wasmThreadsOpcodeI32AtomicRMW8AndU: WasmThreadsOpcode = WasmThreadsOpcode(46);
pub const wasmThreadsOpcodeI32AtomicRMW16AndU: WasmThreadsOpcode = WasmThreadsOpcode(47);
pub const wasmThreadsOpcodeI64AtomicRMW8AndU: WasmThreadsOpcode = WasmThreadsOpcode(48);
pub const wasmThreadsOpcodeI64AtomicRMW16AndU: WasmThreadsOpcode = WasmThreadsOpcode(49);
pub const wasmThreadsOpcodeI64AtomicRMW32AndU: WasmThreadsOpcode = WasmThreadsOpcode(50);
pub const wasmThreadsOpcodeI32AtomicRMWOr: WasmThreadsOpcode = WasmThreadsOpcode(51);
pub const wasmThreadsOpcodeI64AtomicRMWOr: WasmThreadsOpcode = WasmThreadsOpcode(52);
pub const wasmThreadsOpcodeI32AtomicRMW8OrU: WasmThreadsOpcode = WasmThreadsOpcode(53);
pub const wasmThreadsOpcodeI32AtomicRMW16OrU: WasmThreadsOpcode = WasmThreadsOpcode(54);
pub const wasmThreadsOpcodeI64AtomicRMW8OrU: WasmThreadsOpcode = WasmThreadsOpcode(55);
pub const wasmThreadsOpcodeI64AtomicRMW16OrU: WasmThreadsOpcode = WasmThreadsOpcode(56);
pub const wasmThreadsOpcodeI64AtomicRMW32OrU: WasmThreadsOpcode = WasmThreadsOpcode(57);
pub const wasmThreadsOpcodeI32AtomicRMWXor: WasmThreadsOpcode = WasmThreadsOpcode(58);
pub const wasmThreadsOpcodeI64AtomicRMWXor: WasmThreadsOpcode = WasmThreadsOpcode(59);
pub const wasmThreadsOpcodeI32AtomicRMW8XorU: WasmThreadsOpcode = WasmThreadsOpcode(60);
pub const wasmThreadsOpcodeI32AtomicRMW16XorU: WasmThreadsOpcode = WasmThreadsOpcode(61);
pub const wasmThreadsOpcodeI64AtomicRMW8XorU: WasmThreadsOpcode = WasmThreadsOpcode(62);
pub const wasmThreadsOpcodeI64AtomicRMW16XorU: WasmThreadsOpcode = WasmThreadsOpcode(63);
pub const wasmThreadsOpcodeI64AtomicRMW32XorU: WasmThreadsOpcode = WasmThreadsOpcode(64);
pub const wasmThreadsOpcodeI32AtomicRMWXchg: WasmThreadsOpcode = WasmThreadsOpcode(65);
pub const wasmThreadsOpcodeI64AtomicRMWXchg: WasmThreadsOpcode = WasmThreadsOpcode(66);
pub const wasmThreadsOpcodeI32AtomicRMW8XchgU: WasmThreadsOpcode = WasmThreadsOpcode(67);
pub const wasmThreadsOpcodeI32AtomicRMW16XchgU: WasmThreadsOpcode = WasmThreadsOpcode(68);
pub const wasmThreadsOpcodeI64AtomicRMW8XchgU: WasmThreadsOpcode = WasmThreadsOpcode(69);
pub const wasmThreadsOpcodeI64AtomicRMW16XchgU: WasmThreadsOpcode = WasmThreadsOpcode(70);
pub const wasmThreadsOpcodeI64AtomicRMW32XchgU: WasmThreadsOpcode = WasmThreadsOpcode(71);
pub const wasmThreadsOpcodeI32AtomicRMWCmpxchg: WasmThreadsOpcode = WasmThreadsOpcode(72);
pub const wasmThreadsOpcodeI64AtomicRMWCmpxchg: WasmThreadsOpcode = WasmThreadsOpcode(73);
pub const wasmThreadsOpcodeI32AtomicRMW8CmpxchgU: WasmThreadsOpcode = WasmThreadsOpcode(74);
pub const wasmThreadsOpcodeI32AtomicRMW16CmpxchgU: WasmThreadsOpcode = WasmThreadsOpcode(75);
pub const wasmThreadsOpcodeI64AtomicRMW8CmpxchgU: WasmThreadsOpcode = WasmThreadsOpcode(76);
pub const wasmThreadsOpcodeI64AtomicRMW16CmpxchgU: WasmThreadsOpcode = WasmThreadsOpcode(77);
pub const wasmThreadsOpcodeI64AtomicRMW32CmpxchgU: WasmThreadsOpcode = WasmThreadsOpcode(78);
}
impl WasmModuleReaderErrorCode {
pub const wasmModuleReaderInvalidMagic: WasmModuleReaderErrorCode =
WasmModuleReaderErrorCode(0);
pub const wasmModuleReaderAllocationFailed: WasmModuleReaderErrorCode =
WasmModuleReaderErrorCode(1);
pub const wasmModuleReaderInvalidSectionID: WasmModuleReaderErrorCode =
WasmModuleReaderErrorCode(2);
pub const wasmModuleReaderInvalidSectionSize: WasmModuleReaderErrorCode =
WasmModuleReaderErrorCode(3);
pub const wasmModuleReaderIncorrectSectionRead: WasmModuleReaderErrorCode =
WasmModuleReaderErrorCode(4);
pub const wasmModuleReaderInvalidCustomSectionName: WasmModuleReaderErrorCode =
WasmModuleReaderErrorCode(5);
pub const wasmModuleReaderDebugSectionAppendFailed: WasmModuleReaderErrorCode =
WasmModuleReaderErrorCode(6);
pub const wasmModuleReaderInvalidTypeSectionTypeCount: WasmModuleReaderErrorCode =
WasmModuleReaderErrorCode(7);
pub const wasmModuleReaderInvalidFunctionTypeIndicator: WasmModuleReaderErrorCode =
WasmModuleReaderErrorCode(8);
pub const wasmModuleReaderInvalidFunctionTypeParameterCount: WasmModuleReaderErrorCode =
WasmModuleReaderErrorCode(9);
pub const wasmModuleReaderInvalidFunctionTypeResultCount: WasmModuleReaderErrorCode =
WasmModuleReaderErrorCode(10);
pub const wasmModuleReaderInvalidImportSectionImportCount: WasmModuleReaderErrorCode =
WasmModuleReaderErrorCode(11);
pub const wasmModuleReaderInvalidImportSectionImportModule: WasmModuleReaderErrorCode =
WasmModuleReaderErrorCode(12);
pub const wasmModuleReaderInvalidImportSectionImportName: WasmModuleReaderErrorCode =
WasmModuleReaderErrorCode(13);
pub const wasmModuleReaderInvalidImportSectionImportKind: WasmModuleReaderErrorCode =
WasmModuleReaderErrorCode(14);
pub const wasmModuleReaderInvalidImportSectionFunctionTypeIndex: WasmModuleReaderErrorCode =
WasmModuleReaderErrorCode(15);
pub const wasmModuleReaderInvalidValueType: WasmModuleReaderErrorCode =
WasmModuleReaderErrorCode(16);
pub const wasmModuleReaderInvalidFunctionSectionFunctionCount: WasmModuleReaderErrorCode =
WasmModuleReaderErrorCode(17);
pub const wasmModuleReaderInvalidFunctionTypeIndex: WasmModuleReaderErrorCode =
WasmModuleReaderErrorCode(18);
pub const wasmModuleReaderInvalidCodeSectionFunctionCount: WasmModuleReaderErrorCode =
WasmModuleReaderErrorCode(19);
pub const wasmModuleReaderInvalidCodeSectionCodeSize: WasmModuleReaderErrorCode =
WasmModuleReaderErrorCode(20);
pub const wasmModuleReaderInvalidCodeSectionLocalsDeclarations: WasmModuleReaderErrorCode =
WasmModuleReaderErrorCode(21);
pub const wasmModuleReaderInvalidExportSectionExportCount: WasmModuleReaderErrorCode =
WasmModuleReaderErrorCode(22);
pub const wasmModuleReaderInvalidExportSectionExportName: WasmModuleReaderErrorCode =
WasmModuleReaderErrorCode(23);
pub const wasmModuleReaderInvalidExportSectionExportKind: WasmModuleReaderErrorCode =
WasmModuleReaderErrorCode(24);
pub const wasmModuleReaderInvalidExportSectionExportIndex: WasmModuleReaderErrorCode =
WasmModuleReaderErrorCode(25);
pub const wasmModuleReaderInvalidGlobalSectionGlobalCount: WasmModuleReaderErrorCode =
WasmModuleReaderErrorCode(26);
pub const wasmModuleReaderInvalidGlobalSectionMutabilityIndicator: WasmModuleReaderErrorCode =
WasmModuleReaderErrorCode(27);
pub const wasmModuleReaderInvalidGlobalSectionInitExpression: WasmModuleReaderErrorCode =
WasmModuleReaderErrorCode(28);
pub const wasmModuleReaderInvalidMemorySectionMemoryCount: WasmModuleReaderErrorCode =
WasmModuleReaderErrorCode(29);
pub const wasmModuleReaderInvalidLimitKind: WasmModuleReaderErrorCode =
WasmModuleReaderErrorCode(30);
pub const wasmModuleReaderInvalidLimitMinimum: WasmModuleReaderErrorCode =
WasmModuleReaderErrorCode(31);
pub const wasmModuleReaderInvalidLimitMaximum: WasmModuleReaderErrorCode =
WasmModuleReaderErrorCode(32);
pub const wasmModuleReaderInvalidDataSectionDataSegmentCount: WasmModuleReaderErrorCode =
WasmModuleReaderErrorCode(33);
pub const wasmModuleReaderInvalidDataSectionKind: WasmModuleReaderErrorCode =
WasmModuleReaderErrorCode(34);
pub const wasmModuleReaderInvalidDataSectionMemoryIndex: WasmModuleReaderErrorCode =
WasmModuleReaderErrorCode(35);
pub const wasmModuleReaderInvalidDataSectionOffsetExpression: WasmModuleReaderErrorCode =
WasmModuleReaderErrorCode(36);
pub const wasmModuleReaderInvalidDataSectionBytes: WasmModuleReaderErrorCode =
WasmModuleReaderErrorCode(37);
pub const wasmModuleReaderInvalidDataCountSectionDataCount: WasmModuleReaderErrorCode =
WasmModuleReaderErrorCode(38);
pub const wasmModuleReaderInvalidTableSectionTableCount: WasmModuleReaderErrorCode =
WasmModuleReaderErrorCode(39);
pub const wasmModuleReaderInvalidTableSectionTableType: WasmModuleReaderErrorCode =
WasmModuleReaderErrorCode(40);
pub const wasmModuleReaderInvalidElementSectionElementSegmentCount: WasmModuleReaderErrorCode =
WasmModuleReaderErrorCode(41);
pub const wasmModuleReaderInvalidElementSectionTableIndex: WasmModuleReaderErrorCode =
WasmModuleReaderErrorCode(42);
pub const wasmModuleReaderInvalidElementSectionOffsetExpression: WasmModuleReaderErrorCode =
WasmModuleReaderErrorCode(43);
pub const wasmModuleReaderInvalidElementSectionFunctionIndexCount: WasmModuleReaderErrorCode =
WasmModuleReaderErrorCode(44);
pub const wasmModuleReaderInvalidElementSectionFunctionIndex: WasmModuleReaderErrorCode =
WasmModuleReaderErrorCode(45);
pub const wasmModuleReaderInvalidStartSectionFunctionIndex: WasmModuleReaderErrorCode =
WasmModuleReaderErrorCode(46);
pub const wasmModuleReaderInvalidNameSectionFunctionNameCount: WasmModuleReaderErrorCode =
WasmModuleReaderErrorCode(47);
pub const wasmModuleReaderInvalidNameSectionFunctionIndex: WasmModuleReaderErrorCode =
WasmModuleReaderErrorCode(48);
pub const wasmModuleReaderInvalidNameSectionFunctionName: WasmModuleReaderErrorCode =
WasmModuleReaderErrorCode(49);
}
impl WasmSectionID {
pub const wasmSectionIDCustom: WasmSectionID = WasmSectionID(0);
pub const wasmSectionIDType: WasmSectionID = WasmSectionID(1);
pub const wasmSectionIDImport: WasmSectionID = WasmSectionID(2);
pub const wasmSectionIDFunction: WasmSectionID = WasmSectionID(3);
pub const wasmSectionIDTable: WasmSectionID = WasmSectionID(4);
pub const wasmSectionIDMemory: WasmSectionID = WasmSectionID(5);
pub const wasmSectionIDGlobal: WasmSectionID = WasmSectionID(6);
pub const wasmSectionIDExport: WasmSectionID = WasmSectionID(7);
pub const wasmSectionIDStart: WasmSectionID = WasmSectionID(8);
pub const wasmSectionIDElement: WasmSectionID = WasmSectionID(9);
pub const wasmSectionIDCode: WasmSectionID = WasmSectionID(10);
pub const wasmSectionIDData: WasmSectionID = WasmSectionID(11);
pub const wasmSectionIDDataCount: WasmSectionID = WasmSectionID(12);
}
impl WasmNameSubsectionID {
pub const wasmNameSubsectionIDModuleName: WasmNameSubsectionID = WasmNameSubsectionID(0);
pub const wasmNameSubsectionIDFunctionNames: WasmNameSubsectionID = WasmNameSubsectionID(1);
pub const wasmNameSubsectionIDLocalNames: WasmNameSubsectionID = WasmNameSubsectionID(2);
pub const wasmNameSubsectionIDLabelNames: WasmNameSubsectionID = WasmNameSubsectionID(3);
pub const wasmNameSubsectionIDTypeNames: WasmNameSubsectionID = WasmNameSubsectionID(4);
pub const wasmNameSubsectionIDTableNames: WasmNameSubsectionID = WasmNameSubsectionID(5);
pub const wasmNameSubsectionIDMemoryNames: WasmNameSubsectionID = WasmNameSubsectionID(6);
pub const wasmNameSubsectionIDGlobalNames: WasmNameSubsectionID = WasmNameSubsectionID(7);
pub const wasmNameSubsectionIDElemSegmentNames: WasmNameSubsectionID = WasmNameSubsectionID(8);
pub const wasmNameSubsectionIDDataSegmentNames: WasmNameSubsectionID = WasmNameSubsectionID(9);
}
unsafe extern "C" {
#[link_name = "wasmMemoryAllocate__extern"]
pub fn wasmMemoryAllocate(initialPages: U32, maxPages: U32, shared: bool) -> *mut wasmMemory;
#[link_name = "wasmMemoryFree__extern"]
pub fn wasmMemoryFree(memory: *mut wasmMemory);
#[link_name = "wasmMemoryGrow__extern"]
pub fn wasmMemoryGrow(memory: *mut wasmMemory, delta: U32) -> U32;
#[link_name = "wasmMemoryCopy__extern"]
pub fn wasmMemoryCopy(
destinationMemory: *const wasmMemory,
sourceMemory: *const wasmMemory,
destinationAddress: U32,
sourceAddress: U32,
count: U32,
);
#[link_name = "wasmMemoryFill__extern"]
pub fn wasmMemoryFill(
memory: *const wasmMemory,
destinationAddress: U32,
value: U32,
count: U32,
);
#[link_name = "wasmTableAllocate__extern"]
pub fn wasmTableAllocate(table: *mut wasmTable, size: U32, maxSize: U32);
#[link_name = "wasmTableFree__extern"]
pub fn wasmTableFree(table: *mut wasmTable);
pub fn wasmMemoryAtomicWait(
mem: *mut wasmMemory,
address: U32,
expect: U64,
timeout: I64,
wait64: bool,
) -> U32;
pub fn wasmMemoryAtomicNotify(mem: *mut wasmMemory, address: U32, count: U32) -> U32;
pub fn arrayEnsureCapacitySlowPath(
items: *mut *mut ::core::ffi::c_void,
length: usize,
capacity: *mut usize,
itemSize: usize,
) -> bool;
#[link_name = "arrayEnsureCapacity__extern"]
pub fn arrayEnsureCapacity(
items: *mut *mut ::core::ffi::c_void,
length: usize,
capacity: *mut usize,
itemSize: usize,
) -> bool;
#[link_name = "bufferSkipUnchecked__extern"]
pub fn bufferSkipUnchecked(buffer: *mut Buffer, length: usize);
#[link_name = "bufferReadEqual__extern"]
pub fn bufferReadEqual(buffer: *mut Buffer, data: *const U8, length: usize) -> bool;
#[link_name = "bufferReadByte__extern"]
pub fn bufferReadByte(buffer: *mut Buffer, result: *mut U8) -> bool;
#[link_name = "bufferReadF32__extern"]
pub fn bufferReadF32(buffer: *mut Buffer, result: *mut I32) -> bool;
#[link_name = "bufferReadF64__extern"]
pub fn bufferReadF64(buffer: *mut Buffer, result: *mut I64) -> bool;
#[link_name = "bufferAtEnd__extern"]
pub fn bufferAtEnd(buffer: *const Buffer) -> bool;
#[link_name = "bufferSkip__extern"]
pub fn bufferSkip(buffer: *mut Buffer, length: usize);
pub fn wasmValueTypeDescription(valueType: WasmValueType) -> *const ::core::ffi::c_char;
#[link_name = "wasmDecodeValueType__extern"]
pub fn wasmDecodeValueType(encodedValueType: I32, result: *mut WasmValueType) -> bool;
#[link_name = "wasmReadValueType__extern"]
pub fn wasmReadValueType(buffer: *mut Buffer, result: *mut WasmValueType) -> bool;
#[link_name = "wasmReadBlockType__extern"]
pub fn wasmReadBlockType(buffer: *mut Buffer, result: *mut *mut WasmValueType) -> bool;
pub static wasmEmptyFunctionType: WasmFunctionType;
#[link_name = "wasmLocalsDeclarationsGetType__extern"]
pub fn wasmLocalsDeclarationsGetType(
localsDeclarations: WasmLocalsDeclarations,
localIndex: U32,
result: *mut WasmValueType,
) -> bool;
pub static wasmEmptyFunction: WasmFunction;
#[link_name = "wasmFunctionIDsEnsureCapacity__extern"]
pub fn wasmFunctionIDsEnsureCapacity(
wasmFunctionIDs: *mut WasmFunctionIDs,
length: usize,
) -> bool;
#[link_name = "wasmFunctionIDsAppend__extern"]
pub fn wasmFunctionIDsAppend(
wasmFunctionIDs: *mut WasmFunctionIDs,
functionID: WasmFunctionID,
) -> bool;
#[link_name = "wasmFunctionIDsFree__extern"]
pub fn wasmFunctionIDsFree(wasmFunctionIDs: *mut WasmFunctionIDs);
pub fn wasmExportKindDescription(exportKind: WasmExportKind) -> *const ::core::ffi::c_char;
pub static wasmEmptyExport: WasmExport;
pub static wasmEmptyGlobal: WasmGlobal;
pub static wasmEmptyFunctionImport: WasmFunctionImport;
#[link_name = "wasmFunctionImportsEnsureCapacity__extern"]
pub fn wasmFunctionImportsEnsureCapacity(
wasmFunctionImports: *mut WasmFunctionImports,
length: usize,
) -> bool;
#[link_name = "wasmFunctionImportsAppend__extern"]
pub fn wasmFunctionImportsAppend(
wasmFunctionImports: *mut WasmFunctionImports,
import: WasmFunctionImport,
) -> bool;
#[link_name = "wasmFunctionImportsFree__extern"]
pub fn wasmFunctionImportsFree(wasmFunctionImports: *mut WasmFunctionImports);
pub static wasmEmptyGlobalImport: WasmGlobalImport;
#[link_name = "wasmGlobalImportsEnsureCapacity__extern"]
pub fn wasmGlobalImportsEnsureCapacity(
wasmGlobalImports: *mut WasmGlobalImports,
length: usize,
) -> bool;
#[link_name = "wasmGlobalImportsAppend__extern"]
pub fn wasmGlobalImportsAppend(
wasmGlobalImports: *mut WasmGlobalImports,
import: WasmGlobalImport,
) -> bool;
#[link_name = "wasmGlobalImportsFree__extern"]
pub fn wasmGlobalImportsFree(wasmGlobalImports: *mut WasmGlobalImports);
pub static wasmEmptyMemoryImport: WasmMemoryImport;
#[link_name = "wasmMemoryImportsEnsureCapacity__extern"]
pub fn wasmMemoryImportsEnsureCapacity(
wasmMemoryImports: *mut WasmMemoryImports,
length: usize,
) -> bool;
#[link_name = "wasmMemoryImportsAppend__extern"]
pub fn wasmMemoryImportsAppend(
wasmMemoryImports: *mut WasmMemoryImports,
import: WasmMemoryImport,
) -> bool;
#[link_name = "wasmMemoryImportsFree__extern"]
pub fn wasmMemoryImportsFree(wasmMemoryImports: *mut WasmMemoryImports);
pub static wasmEmptyTableImport: WasmTableImport;
#[link_name = "wasmTableImportsEnsureCapacity__extern"]
pub fn wasmTableImportsEnsureCapacity(
wasmTableImports: *mut WasmTableImports,
length: usize,
) -> bool;
#[link_name = "wasmTableImportsAppend__extern"]
pub fn wasmTableImportsAppend(
wasmTableImports: *mut WasmTableImports,
import: WasmTableImport,
) -> bool;
#[link_name = "wasmTableImportsFree__extern"]
pub fn wasmTableImportsFree(wasmTableImports: *mut WasmTableImports);
pub static wasmEmptyMemory: WasmMemory;
pub static wasmEmptyDataSegment: WasmDataSegment;
pub static wasmEmptyTable: WasmTable;
pub static wasmEmptyElementSegment: WasmElementSegment;
#[link_name = "wasmDebugSectionsEnsureCapacity__extern"]
pub fn wasmDebugSectionsEnsureCapacity(
wasmDebugSections: *mut WasmDebugSections,
length: usize,
) -> bool;
#[link_name = "wasmDebugSectionsAppend__extern"]
pub fn wasmDebugSectionsAppend(
wasmDebugSections: *mut WasmDebugSections,
debugSection: WasmDebugSection,
) -> bool;
#[link_name = "wasmDebugSectionsFree__extern"]
pub fn wasmDebugSectionsFree(wasmDebugSections: *mut WasmDebugSections);
#[link_name = "wasmDebugLinesEnsureCapacity__extern"]
pub fn wasmDebugLinesEnsureCapacity(wasmDebugLines: *mut WasmDebugLines, length: usize)
-> bool;
#[link_name = "wasmDebugLinesAppend__extern"]
pub fn wasmDebugLinesAppend(
wasmDebugLines: *mut WasmDebugLines,
debugLine: WasmDebugLine,
) -> bool;
#[link_name = "wasmDebugLinesFree__extern"]
pub fn wasmDebugLinesFree(wasmDebugLines: *mut WasmDebugLines);
pub fn wasmParseDebugInfo(sections: WasmDebugSections) -> WasmDebugLines;
#[link_name = "wasmNamesEnsureCapacity__extern"]
pub fn wasmNamesEnsureCapacity(wasmNames: *mut WasmNames, length: usize) -> bool;
#[link_name = "wasmNamesAppend__extern"]
pub fn wasmNamesAppend(wasmNames: *mut WasmNames, name: *mut ::core::ffi::c_char) -> bool;
#[link_name = "wasmNamesFree__extern"]
pub fn wasmNamesFree(wasmNames: *mut WasmNames);
#[link_name = "wasmModuleFunctionGetLocalType__extern"]
pub fn wasmModuleFunctionGetLocalType(
module: *const WasmModule,
function: WasmFunction,
localIndex: U32,
result: *mut WasmValueType,
) -> bool;
#[link_name = "wasmModuleGetGlobalType__extern"]
pub fn wasmModuleGetGlobalType(
module: *const WasmModule,
globalIndex: U32,
result: *mut WasmValueType,
) -> bool;
#[link_name = "wasmModuleGetFunctionType__extern"]
pub fn wasmModuleGetFunctionType(
module: *const WasmModule,
functionIndex: U32,
result: *mut WasmFunctionType,
) -> bool;
pub fn wasmCWriteModule(
module: *const WasmModule,
moduleName: *const ::core::ffi::c_char,
options: WasmCWriteModuleOptions,
staticFunctionIDs: WasmFunctionIDs,
dynamicFunctionIDs: WasmFunctionIDs,
) -> bool;
pub fn readFile(path: *const ::core::ffi::c_char) -> Buffer;
pub fn wasmOpcodeDescription(opcode: WasmOpcode) -> *const ::core::ffi::c_char;
pub fn wasmMiscOpcodeDescription(miscOpcode: WasmMiscOpcode) -> *const ::core::ffi::c_char;
pub fn wasmThreadsOpcodeDescription(
threadsOpcode: WasmThreadsOpcode,
) -> *const ::core::ffi::c_char;
pub fn wasmOpcodeResultType(opcode: WasmOpcode) -> WasmValueType;
pub fn wasmOpcodeParameter1Type(opcode: WasmOpcode) -> WasmValueType;
#[link_name = "wasmOpcodeRead__extern"]
pub fn wasmOpcodeRead(buffer: *mut Buffer, result: *mut WasmOpcode) -> bool;
pub fn wasmLocalInstructionRead(buffer: *mut Buffer, result: *mut WasmLocalInstruction)
-> bool;
pub fn wasmGlobalInstructionRead(
buffer: *mut Buffer,
result: *mut WasmGlobalInstruction,
) -> bool;
pub fn wasmConstInstructionRead(
buffer: *mut Buffer,
opcode: WasmOpcode,
result: *mut WasmConstInstruction,
) -> bool;
pub fn wasmMemoryArgumentInstructionRead(
buffer: *mut Buffer,
result: *mut WasmMemoryArgumentInstruction,
) -> bool;
#[link_name = "wasmMemoryArgument8InstructionRead__extern"]
pub fn wasmMemoryArgument8InstructionRead(
buffer: *mut Buffer,
result: *mut WasmMemoryArgumentInstruction,
) -> bool;
#[link_name = "wasmMemoryArgument16InstructionRead__extern"]
pub fn wasmMemoryArgument16InstructionRead(
buffer: *mut Buffer,
result: *mut WasmMemoryArgumentInstruction,
) -> bool;
#[link_name = "wasmMemoryArgument32InstructionRead__extern"]
pub fn wasmMemoryArgument32InstructionRead(
buffer: *mut Buffer,
result: *mut WasmMemoryArgumentInstruction,
) -> bool;
#[link_name = "wasmMemoryArgument64InstructionRead__extern"]
pub fn wasmMemoryArgument64InstructionRead(
buffer: *mut Buffer,
result: *mut WasmMemoryArgumentInstruction,
) -> bool;
pub fn wasmCallInstructionRead(buffer: *mut Buffer, result: *mut WasmCallInstruction) -> bool;
pub fn wasmCallIndirectInstructionRead(
buffer: *mut Buffer,
result: *mut WasmCallIndirectInstruction,
) -> bool;
pub fn wasmBranchInstructionRead(
buffer: *mut Buffer,
result: *mut WasmBranchInstruction,
) -> bool;
pub fn wasmBranchTableInstructionFree(instruction: WasmBranchTableInstruction);
pub fn wasmBranchTableInstructionRead(
buffer: *mut Buffer,
result: *mut WasmBranchTableInstruction,
) -> bool;
pub fn wasmMemoryInstructionRead(
buffer: *mut Buffer,
result: *mut WasmMemoryInstruction,
) -> bool;
pub fn wasmMemoryCopyInstructionRead(
buffer: *mut Buffer,
result: *mut WasmMemoryCopyInstruction,
) -> bool;
pub fn wasmMemoryInitInstructionRead(
buffer: *mut Buffer,
result: *mut WasmMemoryInitInstruction,
) -> bool;
pub static wasmEmptyLabel: WasmLabel;
#[link_name = "wasmLabelsEnsureCapacity__extern"]
pub fn wasmLabelsEnsureCapacity(wasmLabels: *mut WasmLabels, length: usize) -> bool;
#[link_name = "wasmLabelsAppend__extern"]
pub fn wasmLabelsAppend(wasmLabels: *mut WasmLabels, label: WasmLabel) -> bool;
#[link_name = "wasmLabelsFree__extern"]
pub fn wasmLabelsFree(wasmLabels: *mut WasmLabels);
pub static wasmEmptyLabelStack: WasmLabelStack;
#[link_name = "wasmLabelStackClear__extern"]
pub fn wasmLabelStackClear(labelStack: *mut WasmLabelStack);
#[link_name = "wasmLabelStackPush__extern"]
pub fn wasmLabelStackPush(
labelStack: *mut WasmLabelStack,
typeStackLength: usize,
type_: *mut WasmValueType,
result: *mut WasmLabel,
) -> bool;
#[link_name = "wasmLabelStackPop__extern"]
pub fn wasmLabelStackPop(labelStack: *mut WasmLabelStack);
#[link_name = "wasmLabelStackGetTopIndex__extern"]
pub fn wasmLabelStackGetTopIndex(labelStack: *const WasmLabelStack, index: U32) -> U32;
pub fn wasmModuleReaderErrorMessage(
error: *const WasmModuleReaderError,
) -> *const ::core::ffi::c_char;
pub fn wasmModuleRead(reader: *mut WasmModuleReader, error: *mut *mut WasmModuleReaderError);
pub fn wasmSectionIDDescription(sectionID: WasmSectionID) -> *const ::core::ffi::c_char;
pub fn wasmNameSubsectionIDDescription(
subsectionID: WasmNameSubsectionID,
) -> *const ::core::ffi::c_char;
pub fn stringBuilderInitialize(stringBuilder: *mut StringBuilder) -> bool;
pub fn stringBuilderReset(stringBuilder: *mut StringBuilder) -> bool;
pub fn stringBuilderFree(stringBuilder: *mut StringBuilder);
pub fn stringBuilderAppendSized(
stringBuilder: *mut StringBuilder,
string: *const ::core::ffi::c_char,
length: usize,
) -> bool;
#[link_name = "stringBuilderAppend__extern"]
pub fn stringBuilderAppend(
stringBuilder: *mut StringBuilder,
string: *const ::core::ffi::c_char,
) -> bool;
pub fn stringBuilderAppendChar(
stringBuilder: *mut StringBuilder,
c: ::core::ffi::c_char,
) -> bool;
pub fn stringBuilderAppendCharHex(
stringBuilder: *mut StringBuilder,
value: ::core::ffi::c_char,
) -> bool;
pub fn stringBuilderAppendU32(stringBuilder: *mut StringBuilder, value: U32) -> bool;
pub fn stringBuilderAppendI32(stringBuilder: *mut StringBuilder, value: I32) -> bool;
pub fn stringBuilderAppendU64(stringBuilder: *mut StringBuilder, value: U64) -> bool;
pub fn stringBuilderAppendI64(stringBuilder: *mut StringBuilder, value: I64) -> bool;
pub fn stringBuilderAppendF32(stringBuilder: *mut StringBuilder, value: F32) -> bool;
pub fn stringBuilderAppendF64(stringBuilder: *mut StringBuilder, value: F64) -> bool;
pub fn stringBuilderAppendU32Hex(stringBuilder: *mut StringBuilder, value: U32) -> bool;
pub fn stringBuilderAppendU64Hex(stringBuilder: *mut StringBuilder, value: U64) -> bool;
#[link_name = "wasmTypeStackEnsureCapacity__extern"]
pub fn wasmTypeStackEnsureCapacity(wasmTypeStack: *mut WasmTypeStack, length: usize) -> bool;
#[link_name = "wasmTypeStackAppend__extern"]
pub fn wasmTypeStackAppend(wasmTypeStack: *mut WasmTypeStack, valueType: WasmValueType)
-> bool;
#[link_name = "wasmTypeStackFree__extern"]
pub fn wasmTypeStackFree(wasmTypeStack: *mut WasmTypeStack);
pub static wasmEmptyTypeStack: WasmTypeStack;
#[link_name = "wasmTypeStackDrop__extern"]
pub fn wasmTypeStackDrop(typeStack: *mut WasmTypeStack, count: usize);
#[link_name = "wasmTypeStackClear__extern"]
pub fn wasmTypeStackClear(typeStack: *mut WasmTypeStack);
#[link_name = "wasmTypeStackSet__extern"]
pub fn wasmTypeStackSet(
typeStack: *mut WasmTypeStack,
index: U32,
valueType: WasmValueType,
) -> bool;
#[link_name = "wasmTypeStackIsSet__extern"]
pub fn wasmTypeStackIsSet(
typeStack: *const WasmTypeStack,
index: U32,
valueType: WasmValueType,
) -> bool;
#[link_name = "wasmTypeStackGetTopIndex__extern"]
pub fn wasmTypeStackGetTopIndex(typeStack: *const WasmTypeStack, index: U32) -> U32;
}