wasm

type BlockType ValueType // varint7

type DataSegment struct {
	Index  uint32 // The index into the global linear memory space, should always be 0 in the MVP.
	Offset []byte // initializer expression for computing the offset for placing elements, should return an i32 value
	Data   []byte
}

type DuplicateExportError string

type ElemType int // varint7

type ElementSegment struct {
	Index  uint32 // The index into the global table space, should always be 0 in the MVP.
	Offset []byte // initializer expression for computing the offset for placing elements, should return an i32 value
	Elems  []uint32
}

type ExportEntry struct {
	FieldStr string
	Kind     External
	Index    uint32
}

type ExportNotFoundError struct {
	ModuleName string
	FieldName  string
}

type External uint8

type FuncImport struct {
	Type uint32
}

type Function struct {
	IsEnvFunc bool   //is the function is a env func
	Name      string //function name
	Sig       *FunctionSig
	Body      *FunctionBody
}

type FunctionBody struct {
	Module *Module // The parent module containing this function body, for execution purposes
	Locals []LocalEntry
	Code   []byte
}

type FunctionSig struct {
	// value for the 'func` type constructor
	Form int8
	// The parameter types of the function
	ParamTypes  []ValueType
	ReturnTypes []ValueType
}

type GlobalEntry struct {
	Type    *GlobalVar // Type holds information about the value type and mutability of the variable
	Init    []byte     // Init is an initializer expression that computes the initial value of the variable
	IsEnv   bool       // true if the Global is env import
	InitVal uint64     // todo init value from env outside
}

type GlobalVar struct {
	Type    ValueType // Type of the value stored by the variable
	Mutable bool      // Whether the value of the variable can be changed by the set_global operator
}

type GlobalVarImport struct {
	Type GlobalVar
}

type Import interface {
	// contains filtered or unexported methods
}

type ImportEntry struct {
	ModuleName string // module name string
	FieldName  string // field name string
	Kind       External

	// If Kind is Function, Type is a FuncImport containing the type index of the function signature
	// If Kind is Table, Type is a TableImport containing the type of the imported table
	// If Kind is Memory, Type is a MemoryImport containing the type of the imported memory
	// If the Kind is Global, Type is a GlobalVarImport
	Type Import
}

type InvalidCodeIndexError int

type InvalidExternalError uint8

type InvalidFunctionIndexError uint32

type InvalidGlobalIndexError uint32

type InvalidInitExprOpError byte

type InvalidLinearMemoryIndexError uint32

type InvalidSectionIDError SectionID

type InvalidTableIndexError uint32

type InvalidTypeConstructorError struct {
	Wanted int
	Got    int
}

type InvalidValueTypeInitExprError struct {
	Wanted reflect.Kind
	Got    reflect.Kind
}

type KindMismatchError struct {
	ModuleName string
	FieldName  string
	Import     External
	Export     External
}

type LocalEntry struct {
	Count uint32    // The total number of local variables of the given Type used in the function body
	Type  ValueType // The type of value stored by the variable
}

type Memory struct {
	Limits ResizableLimits
}

type MemoryImport struct {
	Type Memory
}

type MissingSectionError SectionID

type Module struct {
	Version uint32

	Types    *SectionTypes
	Import   *SectionImports
	Function *SectionFunctions
	Table    *SectionTables
	Memory   *SectionMemories
	Global   *SectionGlobals
	Export   *SectionExports
	Start    *SectionStartFunction
	Elements *SectionElements
	Code     *SectionCode
	Data     *SectionData

	// The function index space of the module
	FunctionIndexSpace []Function
	GlobalIndexSpace   []GlobalEntry
	// function indices into the global function space
	// the limit of each table is its capacity (cap)
	TableIndexSpace        [][]uint32
	LinearMemoryIndexSpace [][]byte

	Other []Section // Other holds the custom sections if any
	// contains filtered or unexported fields
}

type ResizableLimits struct {
	Flags   uint32 // 1 if the Maximum field is valid
	Initial uint32 // initial length (in units of table elements or wasm pages)
	Maximum uint32 // If flags is 1, it describes the maximum size of the table or memory
}

type ResolveFunc func(name string) (*Module, error)

type Section struct {
	Start int64
	End   int64

	ID SectionID
	// Size of this section in bytes
	PayloadLen uint32
	// Section name, empty if id != 0
	Name  string
	Bytes []byte
}

type SectionCode struct {
	Section
	Bodies []FunctionBody
}

type SectionData struct {
	Section
	Entries []DataSegment
}

type SectionElements struct {
	Section
	Entries []ElementSegment
}

type SectionExports struct {
	Section
	Entries map[string]ExportEntry
}

type SectionFunctions struct {
	Section
	// Sequences of indices into (FunctionSignatues).Entries
	Types []uint32
}

type SectionGlobals struct {
	Section
	Globals []GlobalEntry
}

type SectionID uint8

type SectionImports struct {
	Section
	Entries []ImportEntry
}

type SectionMemories struct {
	Section
	Entries []Memory
}

type SectionStartFunction struct {
	Section
	Index uint32 // The index of the start function into the global index space.
}

type SectionTables struct {
	Section
	Entries []Table
}

type SectionTypes struct {
	Section
	Entries []FunctionSig
}

type Table struct {
	// The type of elements
	ElementType ElemType
	Limits      ResizableLimits
}

type TableImport struct {
	Type Table
}

type ValueType int8