compiler

type Bytecode ¶

type Bytecode struct {
	Instructions code.Instructions
	Constants    []object.Object
}

Bytecode contains the Instructions our Compiler generated and the Constants the Compiler evaluated

type CompilationScope ¶

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

CompilationScope - Before we start compiling a function's body (enter a new scope) we push a new CompilationScope on to the scopes stack. While compiling inside this scope, the emit method of the compiler will modify only the fields of the current CompilationScope. Once we're done compiling the function, we leave the scope by popping it off the scopes stack and putting the instructions in a new *object.CompiledFunction

type Compiler ¶

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

Compiler defines our compiler with instructions which hold the generated bytecode, constants which serve as our constant pool, and the last and previous instructions

func New() *Compiler

func NewWithState(s *SymbolTable, constants []object.Object) *Compiler

func (c *Compiler) Bytecode() *vm.Bytecode

func (c *Compiler) Compile(node ast.Node) error

func (c *Compiler) Errors() []string

func (c *Compiler) RegisterBuiltin(name string, builtin *object.Builtin)

type ELF64Header ¶

type ELF64Header struct {
	Magic      [4]byte
	Class      byte
	Endian     byte
	EVers      byte
	OSABI      byte
	ABIVersion byte
	Padding    [7]byte
	Type       uint16
	Machine    uint16
	Version    uint32
	Entry      uint64
	PHOff      uint64
	SHOff      uint64
	Flags      uint32
	EHSize     uint16
	PHOffSize  uint16
	PHOffNum   uint16
	SHOffSize  uint16
	SHOffNum   uint16
	SHStrNdx   uint16
}

ELF structures

type ELF64ProgramHeader ¶

type ELF64ProgramHeader struct {
	Type     uint32
	Flags    uint32
	Offset   uint64
	VAddr    uint64
	PAddr    uint64
	FileSize uint64
	MemSize  uint64
	Align    uint64
}

type ELFCompiler ¶

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

ELFCompiler generates portable ELF binaries from O language source code

func NewELFCompiler() *ELFCompiler

func (c *ELFCompiler) Compile(node ast.Node) error

func (c *ELFCompiler) GenerateELF() ([]byte, error)

type ELFSymbol ¶

type ELFSymbol struct {
	Name   string
	Offset int64
	Type   ELFSymbolType
}

ELFSymbol represents a symbol in the binary

type ELFSymbolType ¶

type ELFSymbolType int

const (
	SymFunction ELFSymbolType = iota
	SymVariable
	SymString
)

type EmittedInstruction ¶

type EmittedInstruction struct {
	Opcode   code.Opcode
	Position int
}

EmittedInstruction represents an instruction through an opcode and it's position

type ServerFunction ¶

type ServerFunction struct {
	Name   string
	Router *gin.Engine
}

func NewServer(name string) *ServerFunction

func (fn *ServerFunction) RouterGenerator(obj object.Object) *ServerFunction

func (fn *ServerFunction) Server(args ...object.Object) object.Object

type Symbol ¶

type Symbol struct {
	Name  string
	Scope SymbolScope
	Index int
}

Symbol - Holds all the necessary info about a symbol - Name, Scope, and Index

type SymbolScope ¶

type SymbolScope string

SymbolScope - Type alias for a string. Used in a Symbol to define it's scope.

const (
	GlobalScope   SymbolScope = "GLOBAL"
	LocalScope    SymbolScope = "LOCAL"
	BuiltinScope  SymbolScope = "BUILTIN"
	FreeScope     SymbolScope = "FREE"
	FunctionScope SymbolScope = "FUNCTION"
)

type SymbolTable ¶

type SymbolTable struct {
	Outer       *SymbolTable
	FreeSymbols []Symbol
	// contains filtered or unexported fields
}

SymbolTable holds a "store" which is a map of strings to Symbols, an int of number of definitions, and "Outer" which defines it's parent scope

func NewEnclosedSymbolTable(outer *SymbolTable) *SymbolTable

func NewSymbolTable() *SymbolTable

func (s *SymbolTable) Define(name string) Symbol

func (s *SymbolTable) DefineBuiltin(index int, name string) Symbol

func (s *SymbolTable) DefineFunctionName(name string) Symbol

func (s *SymbolTable) Resolve(name string) (Symbol, bool)