ast

type BinaryNode ¶ added in v0.0.7

type BinaryNode struct {
	NodeType

	OP    string
	Left  Node
	Right Node
}

BinaryNode is a binary operation representation

func (n BinaryNode) Codegen(scope *Scope, c *Compiler) value.Value

func (n BinaryNode) InferType(scope *Scope) types.Type

func (n BinaryNode) NameString() string

type BlockNode ¶ added in v0.0.7

type BlockNode struct {
	NodeType
	Nodes []Node
}

BlockNode is a block statement. A block statement is just an array of Nodes that run in sequence.

func (n BlockNode) Codegen(scope *Scope, c *Compiler) value.Value

func (n BlockNode) InferType(scope *Scope) types.Type

func (n BlockNode) NameString() string

type CastNode ¶ added in v0.0.7

type CastNode struct {
	NodeType
	From Node
	To   string
}

CastNode is a type cast "function" call. TODO: Replace this with normal function calls and check in the function call codegen function

func (n CastNode) Codegen(scope *Scope, c *Compiler) value.Value

func (n CastNode) InferType(scope *Scope) types.Type

func (n CastNode) NameString() string

type CharNode ¶ added in v0.0.7

type CharNode struct {
	NodeType
	Value int8
}

CharNode is a char literal TODO: get parsing working for this.

func (n CharNode) Codegen(scope *Scope, c *Compiler) value.Value

func (n CharNode) InferType(scope *Scope) types.Type

func (n CharNode) NameString() string

type ClassNode ¶ added in v0.0.7

type ClassNode struct {
	NodeType

	Name      string
	Methods   []FunctionNode
	Variables []VariableNode
}

ClassNode -

func (n ClassNode) Codegen(scope *Scope, c *Compiler) value.Value

func (n ClassNode) InferType(scope *Scope) types.Type

func (n ClassNode) NameString() string

type CompileTarget ¶

type CompileTarget int

CompileTarget is a target to build a binary for

const (
	ASMTarget CompileTarget = iota
	BinaryTarget
)

type Compiler ¶

type Compiler struct {
	Name string
	// A reference to the scope in the package for easier access
	Scope   *Scope
	Package *Package
	Module  *ir.Module

	FN *ir.Function // current funciton being compiled
	// contains filtered or unexported fields
}

Compiler contains all information to compile a program from nodes to llvm ir

func NewCompiler(moduleName string, pkg *Package) *Compiler

func (c *Compiler) CurrentBlock() *ir.BasicBlock

func (c *Compiler) FunctionDefined(fn *ir.Function) bool

func (c *Compiler) PopBlock() *ir.BasicBlock

func (c *Compiler) PushBlock(blk *ir.BasicBlock)

type DependencyNode ¶ added in v0.0.7

type DependencyNode struct {
	NodeType
	Paths    []string
	CLinkage bool
}

DependencyNode is a way of representing the need to include a dependency or multiple dependencies. It also works to link a c program as well. Paths contains a list of paths to the dependencies that the user entered into the statement. These paths are not resolved and may not contain a geode source file.

Example:

Paths = ["std:io"]
CLinkage = false

/

func (n DependencyNode) Codegen(scope *Scope, c *Compiler) value.Value

func (n DependencyNode) Handle(c *Compiler) value.Value

func (n DependencyNode) InferType(scope *Scope) types.Type

func (n DependencyNode) NameString() string

type FloatNode ¶ added in v0.0.7

type FloatNode struct {
	NodeType
	Value float64
}

FloatNode is a float literla

func (n FloatNode) Codegen(scope *Scope, c *Compiler) value.Value

func (n FloatNode) InferType(scope *Scope) types.Type

func (n FloatNode) NameString() string

type ForNode ¶ added in v0.0.7

type ForNode struct {
	NodeType
	Index int
	Init  Node
	Cond  Node
	Step  Node
	Body  Node
}

ForNode is a for loop structure representation

func (n ForNode) Codegen(scope *Scope, c *Compiler) value.Value

func (n ForNode) InferType(scope *Scope) types.Type

func (n ForNode) NameString() string

type FunctionCallNode ¶ added in v0.0.7

type FunctionCallNode struct {
	NodeType

	Name string
	Args []Node
}

FunctionCallNode is a function call, example: `foo(a, b, c)`. This would be:

Name = "foo"
Args = [a, b, c]    <- these are Node references

func (n FunctionCallNode) Codegen(scope *Scope, c *Compiler) value.Value

func (n FunctionCallNode) InferType(scope *Scope) types.Type

func (n FunctionCallNode) NameString() string

type FunctionNode ¶ added in v0.0.7

type FunctionNode struct {
	NodeType

	Name       string
	Args       []VariableNode
	Body       BlockNode
	External   bool
	Variadic   bool
	Nomangle   bool
	ReturnType GeodeTypeRef
}

FunctionNode is the representation of some function. It has methods on it to declare the function as well as codegen. A function has a list of VariableNodes for arguments and a single block for a body, all of which are codegenned.

func (n FunctionNode) Arguments(scope *Scope) ([]*types.Param, []types.Type)

func (n FunctionNode) Codegen(scope *Scope, c *Compiler) value.Value

func (n FunctionNode) Declare(scope *Scope, c *Compiler) *ir.Function

func (n FunctionNode) InferType(scope *Scope) types.Type

func (n FunctionNode) MangledName(scope *Scope, c *Compiler) string

func (n FunctionNode) NameString() string

type FunctionScopeItem ¶

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

FunctionScopeItem implements ScopeItem. This is used so we can store functions in the scope (mainly in the root scope)

func NewFunctionScopeItem(name string, function *ir.Function, vis Visibility) FunctionScopeItem

func (item FunctionScopeItem) Mangled() bool

func (item FunctionScopeItem) Name() string

func (item FunctionScopeItem) SetMangled(m bool)

func (item FunctionScopeItem) Type() ScopeItemType

func (item FunctionScopeItem) Value() value.Value

func (item FunctionScopeItem) Visibility() Visibility

type GeodeBinaryInstr ¶

type GeodeBinaryInstr struct {
	// Parent basic block.
	Parent *ir.BasicBlock
	// Name of the local variable associated with the instruction.
	Name string
	// Operator string.
	Operator string
	// Operands.
	X, Y value.Value
	// Map from metadata identifier (e.g. !dbg) to metadata associated with the
	// instruction.
	Metadata map[string]*metadata.Metadata
}

GeodeBinaryInstr implements ir.Instruction This will be easier than doing individual work per operation

func NewGeodeBinaryInstr(op string, x, y value.Value) *GeodeBinaryInstr

func (inst *GeodeBinaryInstr) GetName() string

func (inst *GeodeBinaryInstr) GetParent() *ir.BasicBlock

func (inst *GeodeBinaryInstr) Ident() string

func (inst *GeodeBinaryInstr) SetName(name string)

func (inst *GeodeBinaryInstr) SetParent(parent *ir.BasicBlock)

func (inst *GeodeBinaryInstr) String() string

func (inst *GeodeBinaryInstr) Type() types.Type

type GeodeTypeRef ¶

type GeodeTypeRef struct {
	Array        bool
	PointerLevel int
	Name         string
}

GeodeTypeRef -

func (r GeodeTypeRef) BuildPointerType(t types.Type) types.Type

type IfNode ¶ added in v0.0.7

type IfNode struct {
	NodeType
	If    Node
	Then  Node
	Else  Node
	Index int
}

IfNode is an if statement representation

func (n IfNode) Codegen(scope *Scope, c *Compiler) value.Value

func (n IfNode) InferType(scope *Scope) types.Type

func (n IfNode) NameString() string

type IntNode ¶ added in v0.0.7

type IntNode struct {
	NodeType
	Value int64
}

IntNode is an integer literal

func (n IntNode) Codegen(scope *Scope, c *Compiler) value.Value

func (n IntNode) InferType(scope *Scope) types.Type

func (n IntNode) NameString() string

type LLVMIdent ¶ added in v0.0.7

type LLVMIdent struct {
	// Parent basic block.
	Parent *ir.BasicBlock

	// Map from metadata identifier (e.g. !dbg) to metadata associated with the
	// instruction.
	Metadata map[string]*metadata.Metadata
	// contains filtered or unexported fields
}

LLVMIdent implements ir.Instruction This will be easier than doing individual work per operation

func NewLLVMIdent(typ types.Type, lines ...string) *LLVMIdent

func (inst *LLVMIdent) GetName() string

func (inst *LLVMIdent) GetParent() *ir.BasicBlock

func (inst *LLVMIdent) Ident() string

func (inst *LLVMIdent) SetName(name string)

func (inst *LLVMIdent) SetParent(parent *ir.BasicBlock)

func (inst *LLVMIdent) String() string

func (inst *LLVMIdent) Type() types.Type

type Linker ¶

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

Linker is an instance that can link several object files into a single binary or other format

func NewLinker(output string) *Linker

func (l *Linker) AddObject(path string)

func (l *Linker) Cleanup()

func (l *Linker) HasObject(path string) bool

func (l *Linker) Run()

func (l *Linker) SetOptimize(o bool)

func (l *Linker) SetOutput(path string)

func (l *Linker) SetTarget(t CompileTarget)

type NamespaceNode ¶ added in v0.0.7

type NamespaceNode struct {
	NodeType

	Name string
}

NamespaceNode -

func (n NamespaceNode) Codegen(scope *Scope, c *Compiler) value.Value

func (n NamespaceNode) InferType(scope *Scope) types.Type

func (n NamespaceNode) NameString() string

type Node ¶

type Node interface {
	Kind() NodeType
	NameString() string
	Codegen(*Scope, *Compiler) value.Value
	InferType(scope *Scope) types.Type
}

Node -

func QuickParseExpression(src string) Node

func QuickParseFunction(src string) Node

func QuickParseIdentifier(src string) Node

type NodeType ¶

type NodeType int

NodeType -

func (t NodeType) Kind() NodeType

type Package ¶

type Package struct {
	fmt.Stringer

	Name         string
	Source       *lexer.Sourcefile
	Nodes        []Node
	Dependencies []*Package
	Scope        *Scope
	Compiler     *Compiler
	IsRuntime    bool

	Compiled      bool
	CLinkages     []string
	NamespaceName string
	// contains filtered or unexported fields
}

Package is a wrapper around a module. It is able to compile and emit code, as well as lex and parse it.

var RuntimePackage *Package

func GetRuntime() *Package

func NewPackage(name string, source *lexer.Sourcefile) *Package

func (p *Package) AddClinkage(libPath string)

func (p *Package) AddDepPackage(pkg *Package)

func (p *Package) Compile() chan *Package

func (p *Package) Emit(buildDir string) string

func (p *Package) Hash() []byte

func (p *Package) Inject(c *Package)

func (p *Package) InjectExternalFunction(from *Package, fn *ir.Function)

func (p *Package) LoadDep(depPath string) *Package

func (p *Package) Parse() chan *Package

func (p *Package) String() string

type Parser ¶

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

Parser -

func NewQuickParser(source string) *Parser

func (p *Parser) Error(format string, args ...interface{})

type ReferenceType ¶

type ReferenceType int

ReferenceType is how we go about accessing a variable. Do we just want the value, or do we want to assign to it

const (
	ReferenceDefine ReferenceType = iota
	ReferenceAssign
	ReferenceAccessValue
	ReferenceAccessStackAddress
	ReferenceDereference
)

type ReturnNode ¶ added in v0.0.7

type ReturnNode struct {
	NodeType
	Value Node
}

ReturnNode is how functions return values from any block A return node contains the value (another Node) that will be codegenned and used in a `NewRet()` call on the parent function

func (n ReturnNode) Codegen(scope *Scope, c *Compiler) value.Value

func (n ReturnNode) InferType(scope *Scope) types.Type

func (n ReturnNode) NameString() string

type Scope ¶

type Scope struct {
	Parent *Scope
	Vals   map[string]ScopeItem
	Types  *map[string]*TypeDef
}

Scope trees represent block scoping by having a root scope and children scopes that point back to their parent scope.

func NewScope() *Scope

func (s *Scope) Add(val ScopeItem)

func (s *Scope) Find(name string) (ScopeItem, bool)

func (s *Scope) FindFunctions(needle string) []FunctionScopeItem

func (s *Scope) FindType(name string) *TypeDef

func (s *Scope) InjectPrimitives()

func (s *Scope) SpawnChild() *Scope

type ScopeItem ¶

type ScopeItem interface {
	Type() ScopeItemType
	Value() value.Value // an llvm value
	Visibility() Visibility
	Name() string
	Mangled() bool
	SetMangled(m bool)
}

ScopeItem is what the scope contains.ScopeItem When you set a value in the scope, you must wrap it in a struct implementing ScopeItem

type ScopeItemType ¶

type ScopeItemType int

ScopeItemType -

const (
	ScopeItemFunctionType ScopeItemType = iota
	ScopeItemVariableType
	ScopeItemTypeType
)

type StringNode ¶ added in v0.0.7

type StringNode struct {
	NodeType
	Value string
}

StringNode is a string literal

func (n StringNode) Codegen(scope *Scope, c *Compiler) value.Value

func (n StringNode) InferType(scope *Scope) types.Type

func (n StringNode) NameString() string

type TypeDef ¶ added in v0.0.7

type TypeDef struct {
	Type types.Type
	Name string
	Prec int
}

TypeDef is a storage for types in the scope. They are stored seperately from variables.

func NewTypeDef(name string, t types.Type, prec int) *TypeDef

func (t *TypeDef) InjectInto(s *Scope)

type UnaryNode ¶ added in v0.0.7

type UnaryNode struct {
	NodeType

	Operator string
	Operand  Node
}

UnaryNode is a unary operation representation. Example:

• !a
• &value

func (n UnaryNode) Codegen(scope *Scope, c *Compiler) value.Value

func (n UnaryNode) InferType(scope *Scope) types.Type

func (n UnaryNode) NameString() string

type VariableNode ¶ added in v0.0.7

type VariableNode struct {
	NodeType
	Type         GeodeTypeRef
	HasValue     bool
	Name         string
	IsPointer    bool
	RefType      ReferenceType
	IndexExpr    Node
	IsArray      bool
	Reassignment bool
	Body         Node
}

VariableNode is a generic variable statement representation this contains a reference type inside it that tellst the code generator what kind of variable statement to build

func (n VariableNode) Codegen(scope *Scope, c *Compiler) value.Value

func (n VariableNode) InferType(scope *Scope) types.Type

func (n VariableNode) NameString() string

type VariableScopeItem ¶

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

VariableScopeItem implements ScopeItem. This is used so we can store functions in the scope (mainly in the root scope)

func NewVariableScopeItem(name string, value value.Value, vis Visibility) VariableScopeItem

func (item VariableScopeItem) Mangled() bool

func (item VariableScopeItem) Name() string

func (item VariableScopeItem) SetMangled(m bool)

func (item VariableScopeItem) Type() ScopeItemType

func (item VariableScopeItem) Value() value.Value

func (item VariableScopeItem) Visibility() Visibility

type Visibility ¶

type Visibility int

Visibility is the access modifier of some scope variable.

const (
	PublicVisibility Visibility = iota
	PrivateVisibility
)

type WhileNode ¶ added in v0.0.7

type WhileNode struct {
	NodeType

	If    Node
	Body  Node
	Index int
}

WhileNode is a while loop representationvbnm,bvbnm

func (n WhileNode) Codegen(scope *Scope, c *Compiler) value.Value

func (n WhileNode) InferType(scope *Scope) types.Type

func (n WhileNode) NameString() string