goscript

type ApplicationSource struct {
	ApplicationFile SourceFile      // path to the main file
	Modules         []*ModuleSource // list of local and standard libarary modules
}

type BinaryOperation struct {
	Type OperationType `json:",omitempty" bson:",omitempty"` // which operation should be performed
	Args []any         `json:",omitempty" bson:",omitempty"` // the arguments passed to the operation
}

type BinaryOperator byte

type BinarySymbol struct {
	Name  string            `json:",omitempty" bson:",omitempty"`
	Value *BinaryTypedValue `json:",omitempty" bson:",omitempty"`
}

type BinaryType byte

type BinaryTypedValue struct {
	Type  BinaryType `json:",omitempty" bson:",omitempty"`
	Value any        `json:",omitempty" bson:",omitempty"`
}

type BuiltinFunction byte

type CompileJob struct {
	MainFilePath       string
	VendorPath         string
	LocalWorkspaceRoot string
	StandardLibPath    string
}

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

type Composition struct {
	Type        BinaryType
	Pattern     *regexp.Regexp
	Constraints []TypeConstraint
}

type Expression struct {
	LeftExpression  *Expression         `json:",omitempty" bson:",omitempty"`
	RightExpression *Expression         `json:",omitempty" bson:",omitempty"`
	Operator        BinaryOperator      `json:",omitempty" bson:",omitempty"`
	Value           *BinaryTypedValue   `json:",omitempty" bson:",omitempty"`
	Ref             int                 `json:",omitempty" bson:",omitempty"`
	Args            []*FunctionArgument `json:",omitempty" bson:",omitempty"`
}

type ExpressionToken struct {
	ID        uint64
	TokenType TokenType
	Value     string
}

type ExpressionTreeNode struct {
	ID       uint64
	Left     uint64
	Right    uint64
	Operator BinaryOperator
	IsChild  bool
}

type ExternalModuleSource struct {
	Name    string // module name
	URL     string // url from which to clone the module
	Version string // version expression that must match the git tag version (empty=latest)
	Branch  string // branch from which to get the version (empty=master)
}

type FunctionArgument struct {
	Expression *Expression `json:",omitempty" bson:",omitempty"`
	SymbolRef  int         `json:",omitempty" bson:",omitempty"`
}

type FunctionCallPlaceholder struct {
	Name       string
	SymbolName []string
	Args       []*Expression
}

type FunctionDefinition struct {
	Name       string
	Accepts    []*IntermediateVar
	Returns    IntermediateType
	Operations []*IntermediateOperation
}

type GSKeyword string

type ImportDirective struct {
	RootType     ModuleSourceRootType // which root path the module should be imported from
	Name         string               // name of the module to be imported
	RawDirective string               // the unprocessed directive
	ImportPath   string               // the import path of the module without the root prefix
	Alias        string               // the alias in the import directive
}

type IntermediateExpression struct {
	Left     *IntermediateExpression
	Right    *IntermediateExpression
	Operator BinaryOperator
	Value    *BinaryTypedValue // only set when the expression is a constant
	Ref      int
	Args     []*FunctionArgument
}

type IntermediateOperation struct {
	Type IntermediateOperationType
	Args []any
}

type IntermediateOperationType byte

type IntermediateProgram struct {
	Entrypoint FunctionDefinition
	Functions  []*FunctionDefinition
}

type IntermediateType struct {
	Type       BinaryType
	KeyType    *IntermediateType
	ValueType  *IntermediateType
	IsComposed bool
}

type IntermediateVar struct {
	Name string
	Type IntermediateType
}

type Kind byte

type ModuleSource struct {
	Name       string                      // name of the module
	Path       string                      // actual path of the module relative to its root
	ImportPath string                      // the path using which this module can be imported (without its prefix)
	RootType   ModuleSourceRootType        // type of the root this module can be found under
	Files      []SourceFile                // paths to all the files in the module
	Hash       string                      // the hash uniquely identifying this module
	Content    string                      // merged content of all files (happens in preprocessor)
	Imports    map[string]*ImportDirective // map of the aliased module name to the module import
}

type ModuleSourceRootType byte

type Numeric interface {
	~int | ~int8 | ~int16 | ~int32 | ~int64 | ~uint | ~uint8 | ~uint16 | ~uint32 | ~uint64 | ~float32 | ~float64
}

type Operation struct {
	Type OperationType
	Args []any
}

type OperationType byte

type PartialExpression struct {
	IsOperator bool // otherwise is assumed to be a value of some kind

}

type PartialExpressionType byte

type Program struct {
	Operations      []BinaryOperation
	SymbolTableSize int
}

type Runtime struct {
	SymbolTable      []*BinaryTypedValue
	SymbolScopeStack [][]int // [scope depth][symbols]
	ProgramCounter   int
	Program          Program
}

type SourceFile struct {
	Path    string                      // path to the source file
	Content string                      // content of the source file
	Imports map[string]*ImportDirective // aliased imports only set in the main file
}

type TokenType byte

type TypeConstraint byte

type UnparsedFunction struct {
	Name    string
	Args    string
	Returns string
	Body    string
}

type VSymbol struct {
	Name  string
	Value any
	Type  BinaryType
}