vm

type BuiltinType struct {
	// contains filtered or unexported fields
}

type CapturingOutHandler struct {
	// contains filtered or unexported fields
}

type CloneType struct {
	Name          string
	Path          string
	Parent        values.ValueType
	Private       bool
	IsSliceable   bool
	IsFilterable  bool
	IsMappable    bool
	IsMI          bool
	Using         []token.Token // TODO --- this is used during API serialization only and can be stored somewhere else once we move that to initialization time.
	Validation    *TypeCheck
	TypeArguments []values.Value
}

type ConsumingOutHandler struct{}

type DecIterator struct {
	StartVal int
	Val      int
	MinVal   int
	// contains filtered or unexported fields
}

type DescribeTypeOfValueAtLocation uint32

type EnumIterator struct {
	Type values.ValueType
	Max  int
	// contains filtered or unexported fields
}

type EnumType struct {
	Name          string
	Path          string
	ElementNames  []string
	ElementValues values.Value // A list.
	Private       bool
	IsMI          bool
}

type ExternalCallHandler interface {
	Evaluate(line string) values.Value
	Problem() *err.Error
	GetAPI() string
}

type GoFn struct {
	Code reflect.Value
}

type HTMLInjector struct {
	Data []any
}

type InHandler interface {
	Get() string
}

type IncIterator struct {
	StartVal int
	Val      int
	MaxVal   int
	// contains filtered or unexported fields
}

type Iterator interface {
	Unfinished() bool
	GetKey() values.Value
	GetValue() values.Value
	GetKeyValuePair() (values.Value, values.Value)
}

type KeyIncIterator struct {
	Max int
	// contains filtered or unexported fields
}

type Lambda struct {
	CapturesStart  uint32
	CapturesEnd    uint32
	ParametersEnd  uint32
	ResultLocation uint32
	AddressToCall  uint32
	Captures       []values.Value
	Sig            []values.AbstractType // To represent the call signature. Unusual in that the types of the AbstractType will be nil in case the type is 'any?'
	RtnSig         []values.AbstractType // The return signature. If empty means ok/error for a command, anything for a function.
	Tok            *token.Token
	Gocode         *reflect.Value // If it's a lambda returned from Go code, this will be non-nil, and most of the other fields will be their zero value except the sig information.
}

type LambdaFactory struct {
	Model            *Lambda  // Copy this to make the lambda.
	CaptureLocations []uint32 // Then these are the location of the values we're closing over, so we copy them into the lambda.
}

type ListIterator struct {
	VecIt vector.Iterator
	// contains filtered or unexported fields
}

type LiteralOutHandler struct {
	// contains filtered or unexported fields
}

type MapIterator struct {
	KVPairs []values.MapPair
	Len     int
	// contains filtered or unexported fields
}

type MaskedInHandler struct {
	// contains filtered or unexported fields
}

type Opcode uint8

type Operation struct {
	Opcode Opcode
	Args   []uint32
}

type OutHandler interface {
	Out(v values.Value)
	Write(s string)
}

type SetIterator struct {
	Elements []values.Value
	Len      int
	// contains filtered or unexported fields
}

type SimpleInHandler struct {
	// contains filtered or unexported fields
}

type SimpleOutHandler struct {
	// contains filtered or unexported fields
}

type SnippetFactory struct {
	Bindle *values.SnippetBindle // Points to the structure defined below.
}

type StandardInHandler struct {
	// contains filtered or unexported fields
}

type StringIterator struct {
	Str string
	// contains filtered or unexported fields
}

type StructIterator struct {
	Labels []int
	Values []values.Value
	// contains filtered or unexported fields
}

type StructType struct {
	Name                 string
	Path                 string
	LabelNumbers         []int
	LabelValues          values.Value // A list.
	Snippet              bool
	Private              bool
	AbstractStructFields []values.AbstractType
	ResolvingMap         map[int]int // TODO --- it would probably be better to implment this as a linear search below a given threshhold and a binary search above it.
	IsMI                 bool
	Validation           *TypeCheck
	TypeArguments        []values.Value
}

type TrackingData struct {
	Flavor     TrackingFlavor
	Tok        *token.Token
	LogToLoc   uint32 // The memory location in the compiler storing what to do with the logging output.
	LogTimeLoc uint32 // The memory location in the compiler storing whether to attach the time to the logging output.
	Args       []any
}

type TrackingFlavor int

type TupleIterator struct {
	Elements []values.Value
	Len      int
	// contains filtered or unexported fields
}

type TypeCheck struct {
	CallAddress  uint32 // The address we `jsr“ to to perform the typecheck.
	InLoc        uint32 // The location of the first argument of the constructor.
	ResultLoc    uint32 // Where we put the error/ok.
	TokNumberLoc uint32 // Contains a location which contains an integer which is an index of the tokens in the vm.
}

type TypeInformation interface {
	GetName(flavor descriptionFlavor) string
	IsEnum() bool
	IsStruct() bool

	IsClone() bool
	IsWrapperType() bool
	IsPrivate() bool
	IsMandatoryImport() bool
	IsClonedBy() values.AbstractType
	// contains filtered or unexported methods
}

type UsefulTypes struct {
	UnwrappedError values.ValueType
	LogTo          values.ValueType
}

type UsefulValues struct {
	OutputAs uint32
}

type ValidationError struct {
	Tok       *token.Token
	Condition string
	Type      string
	Value     uint32
}

type ValueIterator struct {
	// contains filtered or unexported fields
}

type Vm struct {
	// Temporary state: things we change at runtime.
	Mem  []values.Value
	Code []*Operation

	// TODO --- the LogToLoc field of TrackingData is never used by *live* tracking, which should therefore have its own data type.
	LiveTracking []TrackingData // "Live" tracking data in which the uint32s in the permanent tracking data have been replaced by the corresponding memory registers.
	PostHappened bool

	// These are things the ordinal of which can be an operand.
	Tokens           []*token.Token
	LambdaFactories  []*LambdaFactory
	SnippetFactories []*SnippetFactory
	GoFns            []GoFn
	Evaluators       []func(string) values.Value // One per compiler, to implement `eval`.

	// As sometimes can this; it is indexed by the numbers of concrete types.
	ConcreteTypeInfo []TypeInformation

	// This contains the information necessary to attach a suitable namespace to the literal
	// of a value; it is indexed first by the number of the compiler and second by the number of
	// the type.
	NamespaceInfo []map[values.ValueType]string

	Labels                     []string // Array from the number of a field label to its name.
	ValidationErrors           []*ValidationError
	Tracking                   []TrackingData // Data needed by the 'trak' opcode to produce the live tracking data.
	InHandle                   InHandler
	OutHandle                  OutHandler
	AbstractTypes              []values.AbstractTypeInfo
	ExternalCallHandlers       []ExternalCallHandler // The services declared external, whether on the same hub or a different one.
	UsefulTypes                UsefulTypes
	UsefulValues               UsefulValues
	TypeNumberOfUnwrappedError values.ValueType  // What it says. When we unwrap an 'error' to an 'Error' struct, the vm needs to know the number of the struct.
	StringifyLoReg             uint32            // |
	StringifyCallTo            uint32            // | These are so the vm knows how to call the stringify function.
	StringifyOutReg            uint32            // |
	FieldLabelsInMem           map[string]uint32 // Used to turn a string into a label.
	ParameterizedTypeInfo      []*values.Map     // A list of maps from type parameters (as TUPLE values) to types (as TYPE values). The list is itself keyed by a map from type operators to the position in the list, which is stored in the compiler.

	GoToPipefishTypes map[reflect.Type]values.ValueType
	GoConverter       [](func(t uint32, v any) any)
	GoEquals          func(x any, y any) bool
	GoLiteral         func(x any) string
	// contains filtered or unexported fields
}

type WrapperType struct {
	Name    string
	Path    string
	Private bool
	Gotype  string
}