Refactored code structure

src/build/core/CompileDefinition.go

@@ -0,0 +1,145 @@
+package core
+
+import (
+	"fmt"
+
+	"git.akyoto.dev/cli/q/src/build/ast"
+	"git.akyoto.dev/cli/q/src/build/config"
+	"git.akyoto.dev/cli/q/src/build/errors"
+	"git.akyoto.dev/cli/q/src/build/expression"
+	"git.akyoto.dev/cli/q/src/build/token"
+)
+
+// CompileDefinition compiles a variable definition.
+func (f *Function) CompileDefinition(node *ast.Define) error {
+	name := node.Name.Text()
+
+	if f.identifierExists(name) {
+		return errors.New(&errors.VariableAlreadyExists{Name: name}, f.File, node.Name.Position)
+	}
+
+	uses := CountIdentifier(f.Body, name) - 1
+
+	if uses == 0 {
+		return errors.New(&errors.UnusedVariable{Name: name}, f.File, node.Name.Position)
+	}
+
+	value := node.Value
+
+	err := value.EachLeaf(func(leaf *expression.Expression) error {
+		if leaf.Token.Kind == token.Identifier && !f.identifierExists(leaf.Token.Text()) {
+			return errors.New(&errors.UnknownIdentifier{Name: leaf.Token.Text()}, f.File, leaf.Token.Position)
+		}
+
+		return nil
+	})
+
+	if err != nil {
+		return err
+	}
+
+	if uses == 1 {
+		f.definitions[name] = &Definition{
+			Name:  name,
+			Value: value,
+		}
+
+		return nil
+	}
+
+	return f.storeVariableInRegister(name, value, uses)
+}
+
+func (f *Function) AddVariable(variable *Variable) {
+	if config.Comments {
+		f.assembler.Comment(fmt.Sprintf("%s = %s (%s, %d uses)", variable.Name, variable.Value, variable.Register, variable.Alive))
+	}
+
+	f.variables[variable.Name] = variable
+	f.cpu.Use(variable.Register)
+}
+
+func (f *Function) addTemporary(root *expression.Expression) *Variable {
+	f.count.tmps++
+	name := fmt.Sprintf("t%d", f.count.tmps)
+	register := f.cpu.MustUseFree(f.cpu.General)
+
+	tmp := &Variable{
+		Name:     name,
+		Value:    root,
+		Alive:    1,
+		Register: register,
+	}
+
+	f.variables[name] = tmp
+
+	if config.Comments {
+		f.assembler.Comment(fmt.Sprintf("%s = %s (%s)", name, root, register))
+	}
+
+	return tmp
+}
+
+func (f *Function) useVariable(variable *Variable) {
+	variable.Alive--
+
+	if variable.Alive < 0 {
+		panic("incorrect number of variable use calls")
+	}
+
+	if variable.Alive == 0 {
+		if config.Comments {
+			f.assembler.Comment(fmt.Sprintf("%s died (%s)", variable.Name, variable.Register))
+		}
+
+		f.cpu.Free(variable.Register)
+	}
+}
+
+// identifierExists returns true if the identifier has been defined.
+func (f *Function) identifierExists(name string) bool {
+	_, exists := f.variables[name]
+
+	if exists {
+		return true
+	}
+
+	_, exists = f.definitions[name]
+
+	if exists {
+		return true
+	}
+
+	_, exists = f.functions[name]
+	return exists
+}
+
+func (f *Function) storeVariableInRegister(name string, value *expression.Expression, uses int) error {
+	reg, exists := f.cpu.FindFree(f.cpu.General)
+
+	if !exists {
+		panic("no free registers")
+	}
+
+	err := f.EvaluateTo(value, reg)
+
+	f.AddVariable(&Variable{
+		Name:     name,
+		Register: reg,
+		Alive:    uses,
+	})
+
+	return err
+}
+
+func CountIdentifier(tokens token.List, name string) int {
+	count := 0
+
+	for _, t := range tokens {
+		if t.Kind == token.Identifier && t.Text() == name {
+			count++
+		}
+	}
+
+	return count
+}