parse

type ArgumentNode Node

type ArgumentParser struct {
	RegisterParser  Parser[RegisterNode]
	ImmediateParser *ImmediateParser
	LabelParser     Parser[LabelNode]
	GlobalParser    Parser[GlobalNode]
}

type BlockNode[NodeT Node] struct {
	core.UnmanagedSourceView
	Nodes []NodeT
}

type BlockParser[NodeT Node] struct {
	Parser Parser[NodeT]
}

type ConstDeclarationNode struct {
	Declaration GlobalDeclarationNode
}

type ConstDeclarationParser struct {
	ConstParser             Parser[ConstNode]
	GlobalDeclarationParser GlobalDeclarationParser
}

type ConstNode struct{ TokenNode }

type ConstParser struct{ TokenParser[ConstNode] }

type FileNode struct {
	Functions []FunctionNode
	Types     []TypeDeclarationNode
	Constants []ConstDeclarationNode
	Variables []VarDeclarationNode
}

type FileParser struct {
	FunctionParser         FunctionParser
	TypeDeclarationParser  TypeDeclarationParser
	ConstDeclarationParser Parser[ConstDeclarationNode]
	VarDeclarationParser   Parser[VarDeclarationNode]
}

type FunctionNode struct {
	core.UnmanagedSourceView
	Signature    FunctionSignatureNode
	Instructions *BlockNode[InstructionNode]
}

type FunctionParser struct {
	FunctionSignatureParser FunctionSignatureParser
	InstructionBlockParser  BlockParser[InstructionNode]
}

type FunctionSignatureNode struct {
	core.UnmanagedSourceView
	Identifier core.UnmanagedSourceView
	Parameters []ParameterNode
	Returns    []TypeNode
}

type FunctionSignatureParser struct {
	ParameterParser ParameterParser
	TypeParser      TypeParser
}

type GlobalDeclarationNode struct {
	Identifier GlobalNode
	Type       TypeNode
	Immediate  *ImmediateValueNode
}

type GlobalDeclarationParser struct {
	GlobalParser         Parser[GlobalNode]
	TypeParser           TypeParser
	ImmediateValueParser *ImmediateValueParser
}

type GlobalNode struct{ TokenNode }

type GlobalParser struct{ TokenParser[GlobalNode] }

type ImmediateBlockNode = BlockNode[ImmediateFieldNode]

type ImmediateBlockParser = BlockParser[ImmediateFieldNode]

type ImmediateFieldNode struct {
	// At most one (possible, zero) field labels can be specified for each filed
	// Field is nil if a label is not specified.
	Label *LabelNode
	Value ImmediateValueNode
}

type ImmediateFieldParser struct {
	LabelParser          Parser[LabelNode]
	ImmediateValueParser *ImmediateValueParser
}

type ImmediateFinalValueNode struct {
	core.UnmanagedSourceView
}

type ImmediateFinalValueParser struct{}

type ImmediateNode struct {
	Type  TypeNode
	Value ImmediateValueNode
}

type ImmediateParser struct {
	TypeParser
	ImmediateValueParser *ImmediateValueParser
}

type ImmediateValueNode interface {
	Node
}

type ImmediateValueParser struct {
	ImmediateFinalValueParser *ImmediateFinalValueParser
	ImmediateBlockParser      *ImmediateBlockParser
}

type InstructionNode struct {
	Operator  core.UnmanagedSourceView
	Arguments []ArgumentNode
	Targets   []TargetNode
	Labels    []LabelNode
}

type InstructionParser struct {
	LabelParser    Parser[LabelNode]
	TargetParser   Parser[TargetNode]
	ArgumentParser Parser[ArgumentNode]
}

type LabelNode struct{ TokenNode }

type LabelParser struct{ TokenParser[LabelNode] }

type Node interface {
	// Return a reference to the node substring in the source code
	View() core.UnmanagedSourceView

	// Regenerate ("format") the code to a unique, single representation.
	String(ctx *StringContext) string
}

type ParameterNode struct {
	Type     TypeNode
	Register RegisterNode
}

type ParameterParser struct {
	TypeParser     TypeParser
	RegisterParser Parser[RegisterNode]
}

type Parser[Node any] interface {
	Parse(v *TokenView) (Node, core.Result)
}

type RegisterNode struct{ TokenNode }

type RegisterParser struct{ TokenParser[RegisterNode] }

type StringContext struct {
	core.SourceContext
	Indent int
}

type TargetNode struct {
	// Optional type declaration. Depending on the instruction, the type may be
	// inferred and does not need to be provided explicitly.
	Type *TypeNode

	Register RegisterNode
}

type TargetParser struct {
	TypeParser
	RegisterParser Parser[RegisterNode]
}

type TokenNode struct {
	core.UnmanagedSourceView
}

type TokenParser[NodeT Node] struct {
	Token       lex.TokenType
	NodeCreator func(lex.Token) NodeT
}

type TokenView struct{ view.View[lex.Token, uint32] }

type TypeDeclarationNode struct {
	core.UnmanagedSourceView
	Identifier core.UnmanagedSourceView
	Fields     BlockNode[TypeFieldNode]
}

type TypeDeclarationParser struct {
	FieldsParser BlockParser[TypeFieldNode]
}

type TypeDecoratorNode struct {
	core.UnmanagedSourceView
	Type TypeDecoratorType
}

type TypeDecoratorParser struct{}

type TypeDecoratorType uint8

type TypeFieldNode struct {
	Type   TypeNode
	Labels []LabelNode
}

type TypeFieldParser struct {
	LabelParser Parser[LabelNode]
	TypeParser  TypeParser
}

type TypeNode struct {
	Identifier core.UnmanagedSourceView
	Decorators []TypeDecoratorNode
}

type TypeParser struct {
	TypeDecoratorParser
}

type VarDeclarationNode struct {
	Declaration GlobalDeclarationNode
}

type VarDeclarationParser struct {
	VarParser               Parser[VarNode]
	GlobalDeclarationParser GlobalDeclarationParser
}

type VarNode struct{ TokenNode }

type VarParser struct{ TokenParser[VarNode] }