compiler

Documentation

Index

• Constants
• func ParseEntityRef(ref string) core.EntityRef
• func Pointer[T any](v T) *T
• func SaveFilesToDir(dst string, files map[string][]byte) error
• type Analyzer
• type Backend
• type Builder
• type Compiler
  • func New(builder Builder, parser Parser, desugarer Desugarer, analyzer Analyzer, ...) Compiler
  • func (c Compiler) Compile(ctx context.Context, input CompilerInput) error
• type CompilerInput
• type Desugarer
• type Error
  • func (e *Error) Error() string
  • func (e Error) Wrap(child *Error) *Error
• type Frontend
  • func NewFrontend(builder Builder, parser Parser) Frontend
  • func (f Frontend) Process(ctx context.Context, main string) (FrontendResult, *Error)
• type FrontendResult
• type IRGenerator
• type Middleend
  • func (m Middleend) Process(feResult FrontendResult) (MiddleendResult, *Error)
• type MiddleendResult
• type Parser
• type RawBuild
• type RawModule
• type RawPackage

Constants

const (
	ExternDirective    src.Directive = "extern"
	BindDirective      src.Directive = "bind"
	AutoportsDirective src.Directive = "autoports"
)

Functions

func ParseEntityRef

func ParseEntityRef(ref string) core.EntityRef

ParseEntityRef assumes string-ref has form of <pkg_name>.<entity_name≥ or just <entity_name>.

func Pointer

func Pointer[T any](v T) *T

Pointer allows to avoid creating of temporary variables just to take pointers.

func SaveFilesToDir

func SaveFilesToDir(dst string, files map[string][]byte) error

Types

type Analyzer

type Analyzer interface {
	AnalyzeExecutableBuild(mod src.Build, mainPkgName string) (src.Build, *Error)
}

type Backend

type Backend interface {
	Emit(dst string, prog *ir.Program, trace bool) error
}

type Builder

type Builder interface {
	Build(ctx context.Context, wd string) (RawBuild, string, *Error)
}

type Compiler

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

func New

func New(
	builder Builder,
	parser Parser,
	desugarer Desugarer,
	analyzer Analyzer,
	irgen IRGenerator,
	backend Backend,
) Compiler

func (Compiler) Compile

func (c Compiler) Compile(ctx context.Context, input CompilerInput) error

type CompilerInput

type CompilerInput struct {
	Main   string
	Output string
	Trace  bool
}

type Desugarer

type Desugarer interface {
	Desugar(build src.Build) (src.Build, error)
}

type Error

type Error struct {
	Message  string
	Location *src.Location
	Meta     *core.Meta
	// contains filtered or unexported fields
}

func (*Error) Error

func (e *Error) Error() string

func (Error) Wrap

func (e Error) Wrap(child *Error) *Error

type Frontend

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

func NewFrontend

func NewFrontend(builder Builder, parser Parser) Frontend

func (Frontend) Process

func (f Frontend) Process(ctx context.Context, main string) (FrontendResult, *Error)

type FrontendResult

type FrontendResult struct {
	MainPkg     string
	RawBuild    RawBuild
	ParsedBuild sourcecode.Build
}

type IRGenerator

type IRGenerator interface {
	Generate(build src.Build, mainpkg string) (*ir.Program, *Error)
}

type Middleend

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

func (Middleend) Process

func (m Middleend) Process(feResult FrontendResult) (MiddleendResult, *Error)

type MiddleendResult

type MiddleendResult struct {
	AnalyzedBuild  sourcecode.Build
	DesugaredBuild sourcecode.Build
	IR             *ir.Program
}

type Parser

type Parser interface {
	ParseModules(rawMods map[src.ModuleRef]RawModule) (map[src.ModuleRef]src.Module, *Error)
}

type RawBuild

type RawBuild struct {
	EntryModRef src.ModuleRef
	Modules     map[src.ModuleRef]RawModule
}

type RawModule

type RawModule struct {
	Manifest src.ModuleManifest    // Manifest must be parsed by builder before passing into compiler
	Packages map[string]RawPackage // Packages themselves on the other hand can be parsed by compiler
}

type RawPackage

type RawPackage map[string][]byte