func build(files []string, outputFile string, cg string, outputType LLVMCodegen.OutputType, optLevel int) {
constructedModules, _ := parseFiles(files)
// resolve
log.Timed("resolve phase", "", func() {
for _, module := range constructedModules {
res := &parser.Resolver{Module: module}
vis := parser.NewASTVisitor(res)
vis.VisitModule(module)
}
})
// type inference
log.Timed("inference phase", "", func() {
for _, module := range constructedModules {
inf := &parser.TypeInferer{Module: module}
inf.Infer()
// Dump AST
log.Debugln("main", "AST of module `%s`:", module.Name)
for _, node := range module.Nodes {
log.Debugln("main", "%s", node.String())
}
log.Debugln("main", "")
}
})
// semantic analysis
log.Timed("semantic analysis phase", "", func() {
for _, module := range constructedModules {
sem := semantic.NewSemanticAnalyzer(module, *buildOwnership, *ignoreUnused)
vis := parser.NewASTVisitor(sem)
vis.VisitModule(module)
sem.Finalize()
}
})
// codegen
if cg != "none" {
var gen codegen.Codegen
switch cg {
case "llvm":
gen = &LLVMCodegen.Codegen{
OutputName: outputFile,
OutputType: outputType,
OptLevel: optLevel,
}
default:
log.Error("main", util.Red("error: ")+"Invalid backend choice `"+cg+"`")
os.Exit(1)
}
log.Timed("codegen phase", "", func() {
gen.Generate(constructedModules)
})
}
}
func build(files []string, outputFile string, cg string, ccArgs []string, outputType LLVMCodegen.OutputType) {
constructedModules, modules := parseFiles(files)
// resolve
timed("resolve phase", func() {
// TODO: We're looping over a map, the order we get is thus random
for _, module := range modules {
res := &parser.Resolver{Module: module}
res.Resolve(modules)
}
})
// semantic analysis
timed("semantic analysis phase", func() {
// TODO: We're looping over a map, the order we get is thus random
for _, module := range modules {
sem := &parser.SemanticAnalyzer{Module: module}
sem.Analyze(modules)
}
})
// codegen
if cg != "none" {
var gen codegen.Codegen
switch cg {
case "llvm":
gen = &LLVMCodegen.Codegen{
OutputName: outputFile,
CompilerArgs: ccArgs,
OutputType: outputType,
}
default:
log.Error("main", util.Red("error: ")+"Invalid backend choice `"+cg+"`")
os.Exit(1)
}
timed("codegen phase", func() {
gen.Generate(constructedModules, modules)
})
}
}
func build(files []string, outputFile string, cg string, outputType LLVMCodegen.OutputType, optLevel int) {
constructedModules, moduleLookup := parseFiles(files)
// resolve
hasMainFunc := false
log.Timed("resolve phase", "", func() {
for _, module := range constructedModules {
parser.Resolve(module, moduleLookup)
// Use module scope to check for main function
mainIdent := module.ModScope.GetIdent(parser.UnresolvedName{Name: "main"})
if mainIdent != nil && mainIdent.Type == parser.IDENT_FUNCTION && mainIdent.Public {
hasMainFunc = true
}
}
})
// and here we check if we should
// bother continuing any further...
if !hasMainFunc {
log.Error("main", util.Red("error: ")+"main function not found\n")
os.Exit(1)
}
// type inference
log.Timed("inference phase", "", func() {
for _, module := range constructedModules {
for _, submod := range module.Parts {
inf := &parser.TypeInferer{Submodule: submod}
inf.Infer()
// Dump AST
log.Debugln("main", "AST of submodule `%s/%s`:", module.Name, submod.File.Name)
for _, node := range submod.Nodes {
log.Debugln("main", "%s", node.String())
}
log.Debugln("main", "")
}
}
})
// semantic analysis
log.Timed("semantic analysis phase", "", func() {
for _, module := range constructedModules {
for _, submod := range module.Parts {
sem := semantic.NewSemanticAnalyzer(submod, *buildOwnership, *ignoreUnused)
vis := parser.NewASTVisitor(sem)
vis.VisitSubmodule(submod)
sem.Finalize()
}
}
})
// codegen
if cg != "none" {
var gen codegen.Codegen
switch cg {
case "llvm":
gen = &LLVMCodegen.Codegen{
OutputName: outputFile,
OutputType: outputType,
OptLevel: optLevel,
}
default:
log.Error("main", util.Red("error: ")+"Invalid backend choice `"+cg+"`")
os.Exit(1)
}
log.Timed("codegen phase", "", func() {
gen.Generate(constructedModules)
})
}
}
func (v *Context) Build(output string, outputType codegen.OutputType, usedCodegen string, optLevel int) {
// Start by loading the runtime
runtimeModule := LoadRuntime()
// Parse the passed files
v.parseFiles()
// resolve
hasMainFunc := false
log.Timed("resolve phase", "", func() {
for _, module := range v.modules {
ast.Resolve(module, v.moduleLookup)
// Use module scope to check for main function
mainIdent := module.ModScope.GetIdent(ast.UnresolvedName{Name: "main"})
if mainIdent != nil && mainIdent.Type == ast.IDENT_FUNCTION && mainIdent.Public {
hasMainFunc = true
}
}
})
// and here we check if we should
// bother continuing any further...
if !hasMainFunc {
log.Error("main", util.Red("error: ")+"main function not found\n")
os.Exit(1)
}
// type inference
log.Timed("inference phase", "", func() {
for _, module := range v.modules {
for _, submod := range module.Parts {
ast.Infer(submod)
// Dump AST
log.Debugln("main", "AST of submodule `%s/%s`:", module.Name, submod.File.Name)
for _, node := range submod.Nodes {
log.Debugln("main", "%s", node.String())
}
log.Debugln("main", "")
}
}
})
// semantic analysis
log.Timed("semantic analysis phase", "", func() {
for _, module := range v.modules {
semantic.SemCheck(module, *ignoreUnused)
}
})
// codegen
if usedCodegen != "none" {
var gen codegen.Codegen
switch usedCodegen {
case "llvm":
gen = &LLVMCodegen.Codegen{
OutputName: output,
OutputType: outputType,
OptLevel: optLevel,
}
default:
log.Error("main", util.Red("error: ")+"Invalid backend choice `"+usedCodegen+"`")
os.Exit(1)
}
log.Timed("codegen phase", "", func() {
mods := v.modules
if runtimeModule != nil {
mods = append(mods, runtimeModule)
}
gen.Generate(mods)
})
}
}
