Simplified Evaluate function

src/core/CompileAssign.go

@@ -23,7 +23,7 @@ func (f *Function) CompileAssign(node *ast.Assign) error {
 		return f.Execute(node.Expression.Token, variable.Register, right)
 	}
 
-	if left.Token.Kind == token.Period {
+	if left.Token.Kind == token.Dot {
 		return f.CompileAssignField(node)
 	}
 

src/core/CompileLen.go

@@ -1,10 +1,12 @@
 package core
 
 import (
+	"fmt"
 	"math"
 
 	"git.urbach.dev/cli/q/src/asm"
 	"git.urbach.dev/cli/q/src/errors"
+	"git.urbach.dev/cli/q/src/eval"
 	"git.urbach.dev/cli/q/src/expression"
 	"git.urbach.dev/cli/q/src/types"
 )
@@ -23,8 +25,26 @@ func (f *Function) CompileLen(root *expression.Expression) error {
 		return errors.New(&errors.TypeMismatch{Encountered: value.Type.Name(), Expected: types.AnyArray.Name(), ParameterName: "array"}, f.File, root.Children[1].Token.Position)
 	}
 
-	f.SaveRegister(f.CPU.Output[0])
+	memory := asm.Memory{
-	f.MemoryRegister(asm.LOAD, asm.Memory{Base: value.Register, Offset: -8, OffsetRegister: math.MaxUint8, Length: 8}, f.CPU.Output[0])
+		Offset:         -8,
+		OffsetRegister: math.MaxUint8,
+		Length:         8,
+	}
+
+	output := f.CPU.Output[0]
+	f.SaveRegister(output)
+
+	switch value.Kind {
+	case eval.Register:
+		memory.Base = value.Register
+	case eval.Label:
+		f.RegisterLabel(asm.MOVE, output, value.Label)
+		memory.Base = output
+	default:
+		panic(fmt.Errorf("%s: not implemented: %d", f.UniqueName, value.Kind))
+	}
+
+	f.MemoryRegister(asm.LOAD, memory, output)
 	f.FreeRegister(value.Register)
 	return nil
 }

src/core/DotToRegister.go

@@ -11,8 +11,8 @@ import (
 	"git.urbach.dev/cli/q/src/types"
 )
 
-// PeriodToRegister moves a constant or a function address into the given register.
+// DotToRegister moves a constant or a function address into the given register.
-func (f *Function) PeriodToRegister(node *expression.Expression, register cpu.Register) (types.Type, error) {
+func (f *Function) DotToRegister(node *expression.Expression, register cpu.Register) (types.Type, error) {
 	left := node.Children[0]
 	right := node.Children[1]
 	leftText := left.Token.Text(f.File.Bytes)
@@ -56,5 +56,5 @@ func (f *Function) PeriodToRegister(node *expression.Expression, register cpu.Re
 		return types.AnyPointer, nil
 	}
 
-	return nil, errors.New(&errors.UnknownIdentifier{Name: leftText}, f.File, left.Token.Position)
+	return nil, errors.New(&errors.UnknownIdentifier{Name: uniqueName}, f.File, left.Token.Position)
 }

src/core/Evaluate.go

@@ -1,139 +1,37 @@
 package core
 
 import (
-	"math"
-
-	"git.urbach.dev/cli/q/src/asm"
-	"git.urbach.dev/cli/q/src/errors"
 	"git.urbach.dev/cli/q/src/eval"
 	"git.urbach.dev/cli/q/src/expression"
 	"git.urbach.dev/cli/q/src/token"
 	"git.urbach.dev/cli/q/src/types"
 )
 
-// Evaluate evaluates an expression and returns a register that contains the value of the expression.
+// Evaluate evaluates an expression and returns a value.
 func (f *Function) Evaluate(expr *expression.Expression) (eval.Value, error) {
-	if expr.IsLeaf() {
+	if expr.IsFolded {
-		if expr.Token.IsNumeric() {
-			number, err := f.ToNumber(expr.Token)
-
-			if err != nil {
-				return eval.Value{}, err
-			}
-
-			value := eval.Value{
-				Kind:   eval.Number,
-				Type:   types.AnyInt,
-				Number: number,
-				Alive:  1,
-			}
-
-			return value, nil
-		}
-
-		if expr.Token.Kind == token.Identifier {
-			name := expr.Token.Text(f.File.Bytes)
-			variable, function := f.Identifier(name)
-
-			if variable != nil {
-				f.UseVariable(variable)
-
-				if variable.Alive == 0 {
-					return variable.Value, nil
-				}
-
-				tmp := f.NewRegister()
-				f.RegisterRegister(asm.MOVE, tmp, variable.Register)
-
-				value := eval.Value{
-					Kind:     eval.Register,
-					Type:     variable.Type,
-					Register: tmp,
-					Alive:    1,
-				}
-
-				return value, nil
-			}
-
-			if function != nil {
-				value := eval.Value{
-					Kind:  eval.Label,
-					Type:  types.AnyPointer,
-					Label: function.UniqueName,
-					Alive: 1,
-				}
-
-				return value, nil
-			}
-
-			return eval.Value{}, errors.New(&errors.UnknownIdentifier{Name: name}, f.File, expr.Token.Position)
-		}
-	}
-
-	if expr.Token.Kind == token.Call {
-		types, err := f.CompileCall(expr)
-
-		if err != nil {
-			return eval.Value{}, err
-		}
-
-		if len(types) == 0 {
-			return eval.Value{}, errors.New(errors.UntypedExpression, f.File, expr.Token.Position)
-		}
-
 		value := eval.Value{
-			Kind:     eval.Register,
+			Kind:   eval.Number,
-			Type:     types[0],
+			Type:   types.AnyInt,
-			Register: f.CPU.Output[0],
+			Number: expr.Value,
-			Alive:    1,
 		}
 
 		return value, nil
 	}
 
-	if expr.Token.Kind == token.Period {
+	if expr.IsLeaf() {
-		left := expr.Children[0]
+		return f.EvaluateLeaf(expr)
-		right := expr.Children[1]
+	}
-		leftText := left.Token.Text(f.File.Bytes)
-		rightText := right.Token.Text(f.File.Bytes)
-		variable := f.VariableByName(leftText)
 
-		if variable != nil {
+	switch expr.Token.Kind {
-			field := variable.Type.(*types.Pointer).To.(*types.Struct).FieldByName(rightText)
+	case token.Call:
+		return f.EvaluateCall(expr)
 
-			value := eval.Value{
+	case token.Dot:
-				Kind:  eval.Memory,
+		return f.EvaluateDot(expr)
-				Type:  field.Type,
-				Alive: 1,
-				Memory: asm.Memory{
-					Base:           variable.Register,
-					Offset:         int8(field.Offset),
-					OffsetRegister: math.MaxUint8,
-					Length:         byte(field.Type.Size()),
-				},
-			}
 
-			return value, nil
+	case token.Array:
-		}
+		return f.EvaluateArray(expr)
-
-		constant, isConst := f.All.Constants[f.Package+"."+leftText+"."+rightText]
-
-		if isConst {
-			number, err := ToNumber(constant.Token, constant.File)
-
-			if err != nil {
-				return eval.Value{}, err
-			}
-
-			value := eval.Value{
-				Kind:   eval.Number,
-				Type:   types.AnyInt,
-				Number: number,
-				Alive:  1,
-			}
-
-			return value, nil
-		}
 	}
 
 	tmp := f.NewRegister()
@@ -143,7 +41,6 @@ func (f *Function) Evaluate(expr *expression.Expression) (eval.Value, error) {
 		Kind:     eval.Register,
 		Type:     typ,
 		Register: tmp,
-		Alive:    1,
 	}
 
 	return value, err

src/core/EvaluateArray.go

@@ -0,0 +1,60 @@
+package core
+
+import (
+	"fmt"
+	"math"
+
+	"git.urbach.dev/cli/q/src/asm"
+	"git.urbach.dev/cli/q/src/errors"
+	"git.urbach.dev/cli/q/src/eval"
+	"git.urbach.dev/cli/q/src/expression"
+	"git.urbach.dev/cli/q/src/types"
+)
+
+// EvaluateArray evaluates a function call.
+func (f *Function) EvaluateArray(expr *expression.Expression) (eval.Value, error) {
+	name := expr.Children[0].Token.Text(f.File.Bytes)
+	array := f.VariableByName(name)
+
+	if array == nil {
+		return eval.Value{}, errors.New(&errors.UnknownIdentifier{Name: name}, f.File, expr.Children[0].Token.Position)
+	}
+
+	defer f.UseVariable(array)
+
+	memory := asm.Memory{
+		Base:           array.Register,
+		Offset:         0,
+		OffsetRegister: math.MaxUint8,
+		Length:         byte(1),
+	}
+
+	indexExpr := expr.Children[1]
+	index, err := f.Evaluate(indexExpr)
+
+	if err != nil {
+		return eval.Value{}, err
+	}
+
+	if !types.Is(index.Type, types.AnyInt) {
+		return eval.Value{}, errors.New(&errors.TypeMismatch{Encountered: index.Type.Name(), Expected: types.AnyInt.Name()}, f.File, indexExpr.Token.Position)
+	}
+
+	switch index.Kind {
+	case eval.Number:
+		memory.Offset = int8(index.Number)
+	case eval.Register:
+		memory.OffsetRegister = index.Register
+		defer f.FreeRegister(index.Register)
+	default:
+		panic(fmt.Errorf("%s: not implemented: %d", f.UniqueName, index.Kind))
+	}
+
+	value := eval.Value{
+		Kind:   eval.Memory,
+		Type:   array.Type.(*types.Array).Of,
+		Memory: memory,
+	}
+
+	return value, nil
+}

src/core/EvaluateCall.go

@@ -0,0 +1,28 @@
+package core
+
+import (
+	"git.urbach.dev/cli/q/src/errors"
+	"git.urbach.dev/cli/q/src/eval"
+	"git.urbach.dev/cli/q/src/expression"
+)
+
+// EvaluateCall evaluates a function call.
+func (f *Function) EvaluateCall(expr *expression.Expression) (eval.Value, error) {
+	types, err := f.CompileCall(expr)
+
+	if err != nil {
+		return eval.Value{}, err
+	}
+
+	if len(types) == 0 {
+		return eval.Value{}, errors.New(errors.UntypedExpression, f.File, expr.Token.Position)
+	}
+
+	value := eval.Value{
+		Kind:     eval.Register,
+		Type:     types[0],
+		Register: f.CPU.Output[0],
+	}
+
+	return value, nil
+}

src/core/EvaluateDot.go

@@ -0,0 +1,73 @@
+package core
+
+import (
+	"fmt"
+	"math"
+
+	"git.urbach.dev/cli/q/src/asm"
+	"git.urbach.dev/cli/q/src/errors"
+	"git.urbach.dev/cli/q/src/eval"
+	"git.urbach.dev/cli/q/src/expression"
+	"git.urbach.dev/cli/q/src/types"
+)
+
+// EvaluateDot evaluates an access with the dot operator.
+func (f *Function) EvaluateDot(expr *expression.Expression) (eval.Value, error) {
+	left := expr.Children[0]
+	right := expr.Children[1]
+	leftText := left.Token.Text(f.File.Bytes)
+	rightText := right.Token.Text(f.File.Bytes)
+	variable := f.VariableByName(leftText)
+
+	if variable != nil {
+		field := variable.Type.(*types.Pointer).To.(*types.Struct).FieldByName(rightText)
+
+		value := eval.Value{
+			Kind: eval.Memory,
+			Type: field.Type,
+			Memory: asm.Memory{
+				Base:           variable.Register,
+				Offset:         int8(field.Offset),
+				OffsetRegister: math.MaxUint8,
+				Length:         byte(field.Type.Size()),
+			},
+		}
+
+		return value, nil
+	}
+
+	constant, isConst := f.All.Constants[f.Package+"."+leftText+"."+rightText]
+
+	if isConst {
+		number, err := ToNumber(constant.Token, constant.File)
+
+		if err != nil {
+			return eval.Value{}, err
+		}
+
+		value := eval.Value{
+			Kind:   eval.Number,
+			Type:   types.AnyInt,
+			Number: number,
+		}
+
+		return value, nil
+	}
+
+	uniqueName := fmt.Sprintf("%s.%s", leftText, rightText)
+	function, exists := f.All.Functions[uniqueName]
+
+	if exists {
+		f.File.Imports[leftText].Used = true
+
+		value := eval.Value{
+			Kind:  eval.Label,
+			Type:  types.AnyPointer,
+			Label: function.UniqueName,
+		}
+
+		return value, nil
+	}
+
+	return eval.Value{}, errors.New(&errors.UnknownIdentifier{Name: uniqueName}, f.File, left.Token.Position)
+}

src/core/EvaluateLeaf.go

@@ -0,0 +1,107 @@
+package core
+
+import (
+	"encoding/binary"
+
+	"git.urbach.dev/cli/q/src/asm"
+	"git.urbach.dev/cli/q/src/errors"
+	"git.urbach.dev/cli/q/src/eval"
+	"git.urbach.dev/cli/q/src/expression"
+	"git.urbach.dev/cli/q/src/token"
+	"git.urbach.dev/cli/q/src/types"
+)
+
+// EvaluateLeaf evaluates a leaf expression.
+func (f *Function) EvaluateLeaf(expr *expression.Expression) (eval.Value, error) {
+	switch expr.Token.Kind {
+	case token.Identifier:
+		name := expr.Token.Text(f.File.Bytes)
+
+		if name == "true" {
+			value := eval.Value{
+				Kind:   eval.Number,
+				Type:   types.Bool,
+				Number: 1,
+			}
+
+			return value, nil
+		}
+
+		if name == "false" {
+			value := eval.Value{
+				Kind:   eval.Number,
+				Type:   types.Bool,
+				Number: 0,
+			}
+
+			return value, nil
+		}
+
+		variable, function := f.Identifier(name)
+
+		if variable != nil {
+			f.UseVariable(variable)
+
+			if variable.Alive == 0 {
+				return variable.Value, nil
+			}
+
+			tmp := f.NewRegister()
+			f.RegisterRegister(asm.MOVE, tmp, variable.Register)
+
+			value := eval.Value{
+				Kind:     eval.Register,
+				Type:     variable.Type,
+				Register: tmp,
+			}
+
+			return value, nil
+		}
+
+		if function != nil {
+			value := eval.Value{
+				Kind:  eval.Label,
+				Type:  types.AnyPointer,
+				Label: function.UniqueName,
+			}
+
+			return value, nil
+		}
+
+		return eval.Value{}, errors.New(&errors.UnknownIdentifier{Name: name}, f.File, expr.Token.Position)
+
+	case token.Number, token.Rune:
+		number, err := f.ToNumber(expr.Token)
+
+		if err != nil {
+			return eval.Value{}, err
+		}
+
+		value := eval.Value{
+			Kind:   eval.Number,
+			Type:   types.AnyInt,
+			Number: number,
+		}
+
+		return value, nil
+
+	case token.String:
+		data := expr.Token.Bytes(f.File.Bytes)
+		data = String(data)
+
+		slice := make([]byte, len(data)+8+1)
+		binary.LittleEndian.PutUint64(slice, uint64(len(data)))
+		copy(slice[8:], data)
+		label := f.AddBytes(slice)
+
+		value := eval.Value{
+			Kind:  eval.Label,
+			Type:  types.String,
+			Label: label,
+		}
+
+		return value, nil
+	}
+
+	return eval.Value{}, errors.New(errors.InvalidExpression, f.File, expr.Token.Position)
+}

src/core/ExpressionToRegister.go

@@ -25,8 +25,8 @@ func (f *Function) ExpressionToRegister(node *expression.Expression, register cp
 		return f.CallToRegister(node, register)
 	case token.Array:
 		return f.ArrayElementToRegister(node, register)
-	case token.Period:
+	case token.Dot:
-		return f.PeriodToRegister(node, register)
+		return f.DotToRegister(node, register)
 	}
 
 	if len(node.Children) == 1 {

src/core/Fold.go

@@ -20,7 +20,7 @@ func (f *Function) Fold(expr *expression.Expression) error {
 		return f.FoldLeaf(expr)
 	}
 
-	if expr.Token.Kind == token.Period {
+	if expr.Token.Kind == token.Dot {
 		return f.FoldConstant(expr)
 	}
 

src/expression/Operator.go

@@ -16,7 +16,7 @@ type Operator struct {
 // Operators defines the operators used in the language.
 // The number corresponds to the operator priority and can not be zero.
 var Operators = [64]Operator{
-	token.Period: {".", 13, 2},
+	token.Dot:    {".", 13, 2},
 	token.Call:   {"λ", 12, 1},
 	token.Array:  {"@", 12, 2},
 	token.Negate: {"-", 11, 1},

src/token/Kind.go

@@ -33,7 +33,7 @@ const (
 	LogicalAnd                        // &&
 	LogicalOr                         // ||
 	Define                            // :=
-	Period                            // .
+	Dot                               // .
 	Range                             // ..
 	Call                              // x()
 	Array                             // [x]

src/token/Tokenize_test.go

@@ -216,14 +216,14 @@ func TestDefine(t *testing.T) {
 	}
 }
 
-func TestPeriod(t *testing.T) {
+func TestDot(t *testing.T) {
 	tokens := token.Tokenize([]byte(`a.b.c`))
 
 	expected := []token.Kind{
 		token.Identifier,
-		token.Period,
+		token.Dot,
 		token.Identifier,
-		token.Period,
+		token.Dot,
 		token.Identifier,
 		token.EOF,
 	}

src/token/operator.go

@@ -35,7 +35,7 @@ func operator(tokens List, buffer []byte, i Position) (List, Position) {
 	case "+=":
 		kind = AddAssign
 	case ".":
-		kind = Period
+		kind = Dot
 	case "..":
 		kind = Range
 	case ":=":