Improved division split

src/build/ast/Count.go

@@ -15,7 +15,7 @@ func Count(body AST, buffer []byte, kind token.Kind, name string) uint8 {
 			count += node.Expression.Count(buffer, kind, name)
 
 		case *Define:
-			count += node.Value.Count(buffer, kind, name)
+			count += node.Expression.Count(buffer, kind, name)
 
 		case *Return:
 			if node.Value != nil {

src/build/ast/Define.go

@@ -2,11 +2,9 @@ package ast
 
 import (
 	"git.akyoto.dev/cli/q/src/build/expression"
-	"git.akyoto.dev/cli/q/src/build/token"
 )
 
 // Define represents a variable definition.
 type Define struct {
-	Value *expression.Expression
-	Name  token.Token
+	Expression *expression.Expression
 }

src/build/ast/Parse.go

@@ -83,9 +83,7 @@ func toASTNode(tokens token.List, buffer []byte) (Node, error) {
 			return nil, errors.New(errors.MissingOperand, nil, expr.Token.End())
 		}
 
-		name := expr.Children[0].Token
-		value := expr.Children[1]
-		return &Define{Name: name, Value: value}, nil
+		return &Define{Expression: expr}, nil
 
 	case IsAssignment(expr):
 		if len(expr.Children) < 2 {

src/build/core/CompileAssignDivision.go

@@ -29,11 +29,14 @@ func (f *Function) CompileAssignDivision(node *ast.Assign) error {
 	}
 
 	dividend := right.Children[0]
-	name = dividend.Token.Text(f.File.Bytes)
-	dividendVariable := f.VariableByName(name)
+	dividendRegister, err := f.Evaluate(dividend)
+
+	if err != nil {
+		return err
+	}
 
 	divisor := right.Children[1]
-	err := f.Execute(right.Token, dividendVariable.Register, divisor)
+	err = f.Execute(right.Token, dividendRegister, divisor)
 	f.RegisterRegister(asm.MOVE, quotientVariable.Register, x64.RAX)
 	f.RegisterRegister(asm.MOVE, remainderVariable.Register, x64.RDX)
 	return err

src/build/core/CompileDefinition.go

@@ -9,20 +9,22 @@ import (
 
 // CompileDefinition compiles a variable definition.
 func (f *Function) CompileDefinition(node *ast.Define) error {
-	name := node.Name.Text(f.File.Bytes)
+	left := node.Expression.Children[0]
+	right := node.Expression.Children[1]
+	name := left.Token.Text(f.File.Bytes)
 
 	if f.IdentifierExists(name) {
-		return errors.New(&errors.VariableAlreadyExists{Name: name}, f.File, node.Name.Position)
+		return errors.New(&errors.VariableAlreadyExists{Name: name}, f.File, left.Token.Position)
 	}
 
 	uses := token.Count(f.Body, f.File.Bytes, token.Identifier, name) - 1
 
 	if uses == 0 {
-		return errors.New(&errors.UnusedVariable{Name: name}, f.File, node.Name.Position)
+		return errors.New(&errors.UnusedVariable{Name: name}, f.File, left.Token.Position)
 	}
 
 	register := f.NewRegister()
-	err := f.ExpressionToRegister(node.Value, register)
+	err := f.ExpressionToRegister(right, register)
 
 	f.AddVariable(&scope.Variable{
 		Name:     name,

src/build/core/Evaluate.go

@@ -0,0 +1,24 @@
+package core
+
+import (
+	"git.akyoto.dev/cli/q/src/build/cpu"
+	"git.akyoto.dev/cli/q/src/build/expression"
+	"git.akyoto.dev/cli/q/src/build/token"
+)
+
+// Evaluate evaluates an expression and returns a register that contains the value of the expression.
+func (f *Function) Evaluate(expr *expression.Expression) (cpu.Register, error) {
+	if expr.Token.Kind == token.Identifier {
+		name := expr.Token.Text(f.File.Bytes)
+		variable := f.VariableByName(name)
+
+		if variable.Alive == 1 {
+			f.UseVariable(variable)
+			return variable.Register, nil
+		}
+	}
+
+	tmp := f.NewRegister()
+	err := f.ExpressionToRegister(expr, tmp)
+	return tmp, err
+}