Separated compiler into its own package

src/build/core/Compile.go

@@ -1,55 +1,66 @@
 package core
 
 import (
+	"git.akyoto.dev/cli/q/src/build/ast"
 	"git.akyoto.dev/cli/q/src/build/errors"
+	"git.akyoto.dev/cli/q/src/build/token"
 )
 
-// Compile waits for the scan to finish and compiles all functions.
-func Compile(functions <-chan *Function, errs <-chan error) (Result, error) {
-	result := Result{}
-	allFunctions := map[string]*Function{}
-
-	for functions != nil || errs != nil {
-		select {
-		case err, ok := <-errs:
-			if !ok {
-				errs = nil
-				continue
-			}
-
-			return result, err
-
-		case function, ok := <-functions:
-			if !ok {
-				functions = nil
-				continue
-			}
-
-			function.functions = allFunctions
-			allFunctions[function.Name] = function
-		}
-	}
-
-	// Start parallel compilation
-	CompileAllFunctions(allFunctions)
-
-	// Report errors if any occurred
-	for _, function := range allFunctions {
-		if function.err != nil {
-			return result, function.err
-		}
-
-		result.InstructionCount += len(function.assembler.Instructions)
-	}
-
-	// Check for existence of `main`
-	main, exists := allFunctions["main"]
-
-	if !exists {
-		return result, errors.MissingMainFunction
-	}
-
-	result.Main = main
-	result.Functions = allFunctions
-	return result, nil
+// Compile turns a function into machine code.
+func (f *Function) Compile() {
+	defer close(f.finished)
+	f.AddLabel(f.Name)
+	f.Err = f.CompileTokens(f.Body)
+	f.Return()
+}
+
+// CompileTokens compiles a token list.
+func (f *Function) CompileTokens(tokens token.List) error {
+	body, err := ast.Parse(tokens)
+
+	if err != nil {
+		err.(*errors.Error).File = f.File
+		return err
+	}
+
+	return f.CompileAST(body)
+}
+
+// CompileAST compiles an abstract syntax tree.
+func (f *Function) CompileAST(tree ast.AST) error {
+	for _, node := range tree {
+		err := f.CompileASTNode(node)
+
+		if err != nil {
+			return err
+		}
+	}
+
+	return nil
+}
+
+// CompileASTNode compiles a node in the AST.
+func (f *Function) CompileASTNode(node ast.Node) error {
+	switch node := node.(type) {
+	case *ast.Assign:
+		return f.CompileAssign(node)
+
+	case *ast.Call:
+		return f.CompileCall(node.Expression)
+
+	case *ast.Define:
+		return f.CompileDefinition(node)
+
+	case *ast.Return:
+		return f.CompileReturn(node)
+
+	case *ast.If:
+		return f.CompileIf(node)
+
+	case *ast.Loop:
+		return f.CompileLoop(node)
+
+	default:
+		panic("unknown AST type")
+	}
 }