package main
import (
"fmt"
"io"
"os"
"os/exec"
"path"
"slices"
"strings"
"github.com/marzeq/qk/codegen"
"github.com/marzeq/qk/modules"
"github.com/marzeq/qk/parser"
"github.com/marzeq/qk/shared"
"github.com/marzeq/qk/tokeniser"
"github.com/marzeq/qk/typechecker"
)
func _check(err error) {
if err != nil {
fmt.Fprintln(os.Stderr, err)
os.Exit(1)
}
}
func usage() {
prog := path.Base(os.Args[0])
fmt.Printf("Usage: %s -o <output file> [-lf ...] <src files>\n", prog)
}
func runCmd(args ...string) error {
if len(args) == 0 {
return nil
}
cmd := exec.Command(args[0], args[1:]...)
cmd.Stdout = os.Stdout
cmd.Stderr = os.Stderr
return cmd.Run()
}
func copyFile(src, dst string) error {
in, err := os.Open(src)
if err != nil {
return err
}
defer in.Close()
out, err := os.Create(dst)
if err != nil {
return err
}
defer func() {
_ = out.Close()
}()
_, err = io.Copy(out, in)
if err != nil {
return err
}
return out.Sync()
}
func parseArgs() (
outfile string,
linkerFlags []string,
sources []string,
irOutput string,
asmOutput string,
buildDir string,
) {
args := os.Args[1:]
for i := 0; i < len(args); i++ {
arg := args[i]
if len(arg) > 2 && arg[0] == '-' && arg[1] == '-' {
arg = arg[1:]
}
switch arg {
case "-o", "-output", "-out":
if i+1 >= len(args) {
fmt.Println("missing argument for output file")
os.Exit(1)
}
outfile = args[i+1]
i++
case "-lf", "-lflags", "-linkerflags":
if i+1 >= len(args) {
fmt.Println("missing argument for linker flags")
}
linkerFlags = append(linkerFlags, args[i+1])
i++
case "-h", "-help":
usage()
os.Exit(0)
// flags for debugging, do not document
case "-iro", "-irout", "-iroutput":
if i+1 >= len(args) {
fmt.Println("missing argument for ir output file")
}
irOutput = args[i+1]
i++
case "-asmo", "-asmout", "-asmoutput":
if i+1 >= len(args) {
fmt.Println("missing argument for asm output file")
}
asmOutput = args[i+1]
i++
case "-bd", "-builddir":
if i+1 >= len(args) {
fmt.Println("missing argument for build dir")
}
buildDir = args[i+1]
i++
default:
if len(arg) > 0 && arg[0] == '-' {
fmt.Printf("unknown argument: %s\n", arg)
os.Exit(1)
}
sources = append(sources, args[i])
}
}
if len(sources) == 0 {
usage()
os.Exit(1)
}
return
}
func main() {
outFile, linkerFlags, sources, irOutput, asmOutput, buildDir := parseArgs()
if len(sources) != 1 {
fmt.Println("for now, only one source file is supported")
os.Exit(1)
}
srcFile := sources[0]
outBaseName := strings.TrimSuffix(path.Base(outFile), path.Ext(outFile))
pathExt := path.Ext(outFile)
var tmpDir string
if buildDir == "" {
td, err := os.MkdirTemp("", "qk_build_*")
_check(err)
tmpDir = td
defer os.RemoveAll(tmpDir)
} else {
tmpDir = buildDir
os.MkdirAll(tmpDir, 0o755)
}
t, err := tokeniser.NewTokeniserFromFile(srcFile)
_check(err)
toks, err := t.Tokenise()
_check(err)
p := parser.NewParser(toks)
ast, err := p.Parse()
_check(err)
dg, err := modules.NewDepGraph(srcFile, ast)
_check(err)
files, err := dg.TopoSort()
_check(err)
ms := make(typechecker.ModulesSignatures)
moduleToFiles := make(map[string][]string)
for _, f := range files {
mod, err := ms.CollectSignaturesFromRootNode(dg.ASTs[f], typechecker.CollectImports(dg.ASTs[f]))
_check(err)
moduleToFiles[mod] = append(moduleToFiles[mod], f)
}
processedModules := map[string]struct{}{}
for mod, filesInMod := range moduleToFiles {
if _, ok := processedModules[mod]; ok {
continue
}
tc := typechecker.NewTypeChecker(mod, ms)
for _, f := range filesInMod {
ast, err := tc.TypeCheck(dg.ASTs[f])
_check(err)
dg.ASTs[f] = ast
}
processedModules[mod] = struct{}{}
}
ir := ""
var cnstId uint = 0
for _, f := range files {
mod := ""
for m, fs := range moduleToFiles {
if slices.Contains(fs, f) {
mod = m
}
if mod != "" {
break
}
}
cg := codegen.NewCodeGen(dg.ASTs[f], mod, ms, cnstId)
fileIr, cId, err := cg.EmitIR()
_check(err)
ir += fileIr + "\n"
cnstId += cId
}
switch pathExt {
case "":
mainSig, ok := ms.LookupFunction("", "main", "", nil, false)
if !ok {
fmt.Println("no main function found in the default module")
os.Exit(1)
}
if len(mainSig.ArgTypes) != 0 {
fmt.Println("main function must take no arguments")
os.Exit(1)
}
if !mainSig.RetType.Compare(shared.PRIMITIVE_VOID) {
fmt.Println("main function must return void")
os.Exit(1)
}
ir += "\nexport function w $main() {\n"
ir += "@start\n"
ir += " call $_main()\n"
ir += " ret 0\n"
ir += "}\n"
}
cc := []string{os.Getenv("CC")}
if cc[0] == "" {
cc = []string{"cc"}
}
if cc[0] == "zig cc" {
cc = []string{"zig", "cc"}
}
ssaPath := path.Join(tmpDir, outBaseName+".ssa")
_check(os.WriteFile(ssaPath, []byte(ir), 0o644))
if irOutput != "" {
_check(copyFile(ssaPath, irOutput))
}
sPath := path.Join(tmpDir, outBaseName+".s")
_check(runCmd("qbe", "-o", sPath, ssaPath))
if asmOutput != "" {
_check(copyFile(sPath, asmOutput))
}
oPath := path.Join(tmpDir, outBaseName+".o")
_check(runCmd(slices.Concat(cc, []string{"-c", "-o", oPath, sPath})...))
switch pathExt {
case ".o":
_check(copyFile(oPath, outFile))
case ".a":
_check(runCmd("ar", "rcs", outFile, oPath))
case ".so":
args := slices.Concat(cc, append([]string{"cc", "-shared", "-o", outFile, oPath}, linkerFlags...))
_check(runCmd(args...))
case "":
if outFile == "" {
outFile = "a.out"
}
args := slices.Concat(cc, append([]string{"-o", outFile, oPath}, linkerFlags...))
_check(runCmd(args...))
default:
fmt.Printf("unknown output file extension: %s\n", pathExt)
}
}