From b67361c03503f090c4fe9350b03b5abb0e906a6d Mon Sep 17 00:00:00 2001 From: Eduard Urbach Date: Fri, 28 Feb 2025 12:15:19 +0100 Subject: [PATCH] Implemented Value interface --- src/core/ArrayElementToRegister.go | 8 +++--- src/core/Compare.go | 2 +- src/core/CompileAssign.go | 2 +- src/core/CompileAssignArray.go | 10 ++++---- src/core/CompileAssignDivision.go | 16 ++++++------ src/core/CompileAssignField.go | 4 +-- src/core/CompileCondition.go | 8 +++--- src/core/CompileDefinition.go | 8 +++--- src/core/CompileDelete.go | 4 +-- src/core/CompileFor.go | 10 ++++---- src/core/CompileLen.go | 10 ++++---- src/core/CompileMemoryStore.go | 2 +- src/core/Define.go | 3 +-- src/core/DotToRegister.go | 4 +-- src/core/Evaluate.go | 10 +++----- src/core/EvaluateArray.go | 19 +++++++------- src/core/EvaluateCall.go | 9 +++---- src/core/EvaluateDot.go | 23 ++++++++--------- src/core/EvaluateLeaf.go | 40 +++++++++++++----------------- src/core/ExecuteLeaf.go | 2 +- src/core/ExpressionToMemory.go | 6 ++--- src/core/ExpressionToRegister.go | 2 +- src/core/MultiAssign.go | 2 +- src/core/ResolveTypes.go | 5 ++-- src/core/TokenToRegister.go | 4 +-- src/core/UsesRegister.go | 2 +- src/eval/Kind.go | 11 -------- src/eval/Label.go | 17 +++++++++++++ src/eval/Memory.go | 20 +++++++++++++++ src/eval/Number.go | 17 +++++++++++++ src/eval/Register.go | 21 ++++++++++++++++ src/eval/Value.go | 21 ++++++---------- src/register/SaveRegister.go | 4 +-- src/scope/Scope.go | 2 +- src/scope/Stack.go | 15 ++++++----- src/scope/Variable.go | 4 +-- 36 files changed, 194 insertions(+), 153 deletions(-) delete mode 100644 src/eval/Kind.go create mode 100644 src/eval/Label.go create mode 100644 src/eval/Memory.go create mode 100644 src/eval/Number.go create mode 100644 src/eval/Register.go diff --git a/src/core/ArrayElementToRegister.go b/src/core/ArrayElementToRegister.go index 9e58f3e..8274a97 100644 --- a/src/core/ArrayElementToRegister.go +++ b/src/core/ArrayElementToRegister.go @@ -24,7 +24,7 @@ func (f *Function) ArrayElementToRegister(node *expression.Expression, register index := node.Children[1] memory := asm.Memory{ - Base: array.Register, + Base: array.Value.Register, Offset: 0, OffsetRegister: math.MaxUint8, Length: byte(1), @@ -50,11 +50,11 @@ func (f *Function) ArrayElementToRegister(node *expression.Expression, register defer f.UseVariable(indexVariable) - if !types.Is(indexVariable.Type, types.AnyInt) { - return nil, errors.New(&errors.TypeMismatch{Encountered: indexVariable.Type.Name(), Expected: types.AnyInt.Name()}, f.File, index.Token.Position) + if !types.Is(indexVariable.Value.Typ, types.AnyInt) { + return nil, errors.New(&errors.TypeMismatch{Encountered: indexVariable.Value.Typ.Name(), Expected: types.AnyInt.Name()}, f.File, index.Token.Position) } - memory.OffsetRegister = indexVariable.Register + memory.OffsetRegister = indexVariable.Value.Register default: typ, err := f.ExpressionToRegister(index, register) diff --git a/src/core/Compare.go b/src/core/Compare.go index 731165f..f367020 100644 --- a/src/core/Compare.go +++ b/src/core/Compare.go @@ -21,7 +21,7 @@ func (f *Function) Compare(comparison *expression.Expression) error { } defer f.UseVariable(variable) - return f.Execute(comparison.Token, variable.Register, right) + return f.Execute(comparison.Token, variable.Value.Register, right) } if ast.IsFunctionCall(left) && right.IsLeaf() { diff --git a/src/core/CompileAssign.go b/src/core/CompileAssign.go index 910cda0..2126f45 100644 --- a/src/core/CompileAssign.go +++ b/src/core/CompileAssign.go @@ -20,7 +20,7 @@ func (f *Function) CompileAssign(node *ast.Assign) error { } defer f.UseVariable(variable) - return f.Execute(node.Expression.Token, variable.Register, right) + return f.Execute(node.Expression.Token, variable.Value.Register, right) } if left.Token.Kind == token.Dot { diff --git a/src/core/CompileAssignArray.go b/src/core/CompileAssignArray.go index 740c42b..46a02e0 100644 --- a/src/core/CompileAssignArray.go +++ b/src/core/CompileAssignArray.go @@ -25,7 +25,7 @@ func (f *Function) CompileAssignArray(node *ast.Assign) error { defer f.UseVariable(variable) memory := asm.Memory{ - Base: variable.Register, + Base: variable.Value.Register, Offset: 0, OffsetRegister: math.MaxUint8, Length: byte(1), @@ -38,18 +38,18 @@ func (f *Function) CompileAssignArray(node *ast.Assign) error { return err } - if !types.Is(index.Type, types.AnyInt) { - return errors.New(&errors.TypeMismatch{Encountered: index.Type.Name(), Expected: types.AnyInt.Name()}, f.File, indexExpr.Token.Position) + if !types.Is(index.Type(), types.AnyInt) { + return errors.New(&errors.TypeMismatch{Encountered: index.Type().Name(), Expected: types.AnyInt.Name()}, f.File, indexExpr.Token.Position) } - switch index.Kind { + switch index := index.(type) { 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)) + panic(fmt.Errorf("%s: not implemented: %v", f.UniqueName, index)) } _, err = f.ExpressionToMemory(right, memory) diff --git a/src/core/CompileAssignDivision.go b/src/core/CompileAssignDivision.go index fd16573..cf4be7b 100644 --- a/src/core/CompileAssignDivision.go +++ b/src/core/CompileAssignDivision.go @@ -36,8 +36,8 @@ func (f *Function) CompileAssignDivision(expr *expression.Expression) error { return err } - quotientVariable.Type = types.Int - remainderVariable.Type = types.Int + quotientVariable.Value.Typ = types.Int + remainderVariable.Value.Typ = types.Int f.AddVariable(quotientVariable) f.AddVariable(remainderVariable) } else { @@ -68,13 +68,13 @@ func (f *Function) CompileAssignDivision(expr *expression.Expression) error { return err } - if !types.Is(dividend.Type, types.AnyInt) { - return errors.New(&errors.TypeMismatch{Encountered: dividend.Type.Name(), Expected: types.AnyInt.Name()}, f.File, dividendExpr.Token.Position) + if !types.Is(dividend.Type(), types.AnyInt) { + return errors.New(&errors.TypeMismatch{Encountered: dividend.Type().Name(), Expected: types.AnyInt.Name()}, f.File, dividendExpr.Token.Position) } divisor := division.Children[1] - switch dividend.Kind { + switch dividend := dividend.(type) { case eval.Number: f.SaveRegister(x86.RAX) f.RegisterNumber(asm.MOVE, x86.RAX, dividend.Number) @@ -83,10 +83,10 @@ func (f *Function) CompileAssignDivision(expr *expression.Expression) error { err = f.Execute(division.Token, dividend.Register, divisor) defer f.FreeRegister(dividend.Register) default: - panic(fmt.Errorf("%s: not implemented: %d", f.UniqueName, dividend.Kind)) + panic(fmt.Errorf("%s: not implemented: %v", f.UniqueName, dividend)) } - f.RegisterRegister(asm.MOVE, quotientVariable.Register, x86.RAX) - f.RegisterRegister(asm.MOVE, remainderVariable.Register, x86.RDX) + f.RegisterRegister(asm.MOVE, quotientVariable.Value.Register, x86.RAX) + f.RegisterRegister(asm.MOVE, remainderVariable.Value.Register, x86.RDX) return err } diff --git a/src/core/CompileAssignField.go b/src/core/CompileAssignField.go index 31310d2..bc965c6 100644 --- a/src/core/CompileAssignField.go +++ b/src/core/CompileAssignField.go @@ -22,7 +22,7 @@ func (f *Function) CompileAssignField(node *ast.Assign) error { } defer f.UseVariable(variable) - pointer := variable.Type.(*types.Pointer) + pointer := variable.Value.Typ.(*types.Pointer) structure := pointer.To.(*types.Struct) field := structure.FieldByName(fieldName) @@ -31,7 +31,7 @@ func (f *Function) CompileAssignField(node *ast.Assign) error { } memory := asm.Memory{ - Base: variable.Register, + Base: variable.Value.Register, Offset: int8(field.Offset), OffsetRegister: math.MaxUint8, Length: byte(field.Type.Size()), diff --git a/src/core/CompileCondition.go b/src/core/CompileCondition.go index 087731e..19451a9 100644 --- a/src/core/CompileCondition.go +++ b/src/core/CompileCondition.go @@ -75,11 +75,11 @@ func (f *Function) CompileCondition(condition *expression.Expression, successLab return err } - if !types.Is(value.Type, types.Bool) { - return errors.New(&errors.TypeMismatch{Encountered: value.Type.Name(), Expected: types.Bool.Name()}, f.File, condition.Token.Position) + if !types.Is(value.Type(), types.Bool) { + return errors.New(&errors.TypeMismatch{Encountered: value.Type().Name(), Expected: types.Bool.Name()}, f.File, condition.Token.Position) } - switch value.Kind { + switch value := value.(type) { case eval.Number: if value.Number == 0 { f.Jump(asm.JUMP, failLabel) @@ -89,7 +89,7 @@ func (f *Function) CompileCondition(condition *expression.Expression, successLab f.FreeRegister(value.Register) f.Jump(asm.JE, failLabel) default: - panic(fmt.Errorf("%s: not implemented: %d", f.UniqueName, value.Kind)) + panic(fmt.Errorf("%s: not implemented: %v", f.UniqueName, value)) } return nil diff --git a/src/core/CompileDefinition.go b/src/core/CompileDefinition.go index af96b46..58b89be 100644 --- a/src/core/CompileDefinition.go +++ b/src/core/CompileDefinition.go @@ -21,7 +21,7 @@ func (f *Function) CompileDefinition(node *ast.Define) error { return err } - typ, err := f.ExpressionToRegister(right, variable.Register) + typ, err := f.ExpressionToRegister(right, variable.Value.Register) if err != nil { return err @@ -35,7 +35,7 @@ func (f *Function) CompileDefinition(node *ast.Define) error { typ = types.Int } - variable.Type = typ + variable.Value.Typ = typ f.AddVariable(variable) return nil } @@ -63,10 +63,10 @@ func (f *Function) CompileDefinition(node *ast.Define) error { } if count < len(types) { - variable.Type = types[count] + variable.Value.Typ = types[count] } - f.RegisterRegister(asm.MOVE, variable.Register, f.CPU.Output[count]) + f.RegisterRegister(asm.MOVE, variable.Value.Register, f.CPU.Output[count]) f.AddVariable(variable) count++ return nil diff --git a/src/core/CompileDelete.go b/src/core/CompileDelete.go index 05966d9..ad01ee7 100644 --- a/src/core/CompileDelete.go +++ b/src/core/CompileDelete.go @@ -20,8 +20,8 @@ func (f *Function) CompileDelete(root *expression.Expression) error { defer f.UseVariable(variable) f.SaveRegister(f.CPU.Input[0]) f.SaveRegister(f.CPU.Input[1]) - f.RegisterRegister(asm.MOVE, f.CPU.Input[0], variable.Register) - f.RegisterNumber(asm.MOVE, f.CPU.Input[1], variable.Type.(*types.Pointer).To.Size()) + f.RegisterRegister(asm.MOVE, f.CPU.Input[0], variable.Value.Register) + f.RegisterNumber(asm.MOVE, f.CPU.Input[1], variable.Value.Typ.(*types.Pointer).To.Size()) f.CallSafe(f.All.Functions["mem.free"], f.CPU.Input[:2]) return nil } diff --git a/src/core/CompileFor.go b/src/core/CompileFor.go index 1eafd68..414a166 100644 --- a/src/core/CompileFor.go +++ b/src/core/CompileFor.go @@ -40,7 +40,7 @@ func (f *Function) CompileFor(loop *ast.For) error { return err } - counter = variable.Register + counter = variable.Value.Register from = loop.Head.Children[1].Children[0] to = loop.Head.Children[1].Children[1] f.AddVariable(variable) @@ -67,20 +67,20 @@ func (f *Function) CompileFor(loop *ast.For) error { return err } - if !types.Is(value.Type, types.AnyInt) { - return errors.New(&errors.TypeMismatch{Encountered: value.Type.Name(), Expected: types.AnyInt.Name()}, f.File, to.Token.Position) + if !types.Is(value.Type(), types.AnyInt) { + return errors.New(&errors.TypeMismatch{Encountered: value.Type().Name(), Expected: types.AnyInt.Name()}, f.File, to.Token.Position) } f.AddLabel(label) - switch value.Kind { + switch value := value.(type) { case eval.Number: f.RegisterNumber(asm.COMPARE, counter, value.Number) case eval.Register: f.RegisterRegister(asm.COMPARE, counter, value.Register) defer f.FreeRegister(value.Register) default: - panic(fmt.Errorf("%s: not implemented: %d", f.UniqueName, value.Kind)) + panic(fmt.Errorf("%s: not implemented: %v", f.UniqueName, value)) } f.Jump(asm.JGE, labelEnd) diff --git a/src/core/CompileLen.go b/src/core/CompileLen.go index b1d117c..3a0fb79 100644 --- a/src/core/CompileLen.go +++ b/src/core/CompileLen.go @@ -21,8 +21,8 @@ func (f *Function) CompileLen(root *expression.Expression) error { return err } - if !types.Is(value.Type, types.AnyArray) { - return errors.New(&errors.TypeMismatch{Encountered: value.Type.Name(), Expected: types.AnyArray.Name(), ParameterName: "array"}, f.File, root.Children[1].Token.Position) + if !types.Is(value.Type(), types.AnyArray) { + return errors.New(&errors.TypeMismatch{Encountered: value.Type().Name(), Expected: types.AnyArray.Name(), ParameterName: "array"}, f.File, root.Children[1].Token.Position) } memory := asm.Memory{ @@ -34,17 +34,17 @@ func (f *Function) CompileLen(root *expression.Expression) error { output := f.CPU.Output[0] f.SaveRegister(output) - switch value.Kind { + switch value := value.(type) { case eval.Register: memory.Base = value.Register + defer f.FreeRegister(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)) + panic(fmt.Errorf("%s: not implemented: %v", f.UniqueName, value)) } f.MemoryRegister(asm.LOAD, memory, output) - f.FreeRegister(value.Register) return nil } diff --git a/src/core/CompileMemoryStore.go b/src/core/CompileMemoryStore.go index a1bb856..ff6d59f 100644 --- a/src/core/CompileMemoryStore.go +++ b/src/core/CompileMemoryStore.go @@ -28,7 +28,7 @@ func (f *Function) CompileMemoryStore(root *expression.Expression) error { defer f.UseVariable(variable) memory := asm.Memory{ - Base: variable.Register, + Base: variable.Value.Register, OffsetRegister: math.MaxUint8, Length: byte(numBytes), } diff --git a/src/core/Define.go b/src/core/Define.go index 16ccdd6..c5c6cef 100644 --- a/src/core/Define.go +++ b/src/core/Define.go @@ -25,8 +25,7 @@ func (f *Function) Define(leaf *expression.Expression) (*scope.Variable, error) variable = &scope.Variable{ Name: name, - Value: eval.Value{ - Kind: eval.Register, + Value: eval.Register{ Register: f.NewRegister(), Alive: uses, }, diff --git a/src/core/DotToRegister.go b/src/core/DotToRegister.go index d76ac81..b3c617c 100644 --- a/src/core/DotToRegister.go +++ b/src/core/DotToRegister.go @@ -20,10 +20,10 @@ func (f *Function) DotToRegister(node *expression.Expression, register cpu.Regis variable := f.VariableByName(leftText) if variable != nil { - field := variable.Type.(*types.Pointer).To.(*types.Struct).FieldByName(rightText) + field := variable.Value.Typ.(*types.Pointer).To.(*types.Struct).FieldByName(rightText) memory := asm.Memory{ - Base: variable.Register, + Base: variable.Value.Register, Offset: int8(field.Offset), OffsetRegister: math.MaxUint8, Length: byte(field.Type.Size()), diff --git a/src/core/Evaluate.go b/src/core/Evaluate.go index 05e5a54..b13cd17 100644 --- a/src/core/Evaluate.go +++ b/src/core/Evaluate.go @@ -10,9 +10,8 @@ import ( // Evaluate evaluates an expression and returns a value. func (f *Function) Evaluate(expr *expression.Expression) (eval.Value, error) { if expr.IsFolded { - value := eval.Value{ - Kind: eval.Number, - Type: types.AnyInt, + value := eval.Number{ + Typ: types.AnyInt, Number: expr.Value, } @@ -37,9 +36,8 @@ func (f *Function) Evaluate(expr *expression.Expression) (eval.Value, error) { tmp := f.NewRegister() typ, err := f.ExpressionToRegister(expr, tmp) - value := eval.Value{ - Kind: eval.Register, - Type: typ, + value := eval.Register{ + Typ: typ, Register: tmp, } diff --git a/src/core/EvaluateArray.go b/src/core/EvaluateArray.go index 8457dcd..857b542 100644 --- a/src/core/EvaluateArray.go +++ b/src/core/EvaluateArray.go @@ -17,13 +17,13 @@ func (f *Function) EvaluateArray(expr *expression.Expression) (eval.Value, error array := f.VariableByName(name) if array == nil { - return eval.Value{}, errors.New(&errors.UnknownIdentifier{Name: name}, f.File, expr.Children[0].Token.Position) + return nil, errors.New(&errors.UnknownIdentifier{Name: name}, f.File, expr.Children[0].Token.Position) } defer f.UseVariable(array) memory := asm.Memory{ - Base: array.Register, + Base: array.Value.Register, Offset: 0, OffsetRegister: math.MaxUint8, Length: byte(1), @@ -33,26 +33,25 @@ func (f *Function) EvaluateArray(expr *expression.Expression) (eval.Value, error index, err := f.Evaluate(indexExpr) if err != nil { - return eval.Value{}, err + return nil, 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) + if !types.Is(index.Type(), types.AnyInt) { + return nil, errors.New(&errors.TypeMismatch{Encountered: index.Type().Name(), Expected: types.AnyInt.Name()}, f.File, indexExpr.Token.Position) } - switch index.Kind { + switch index := index.(type) { 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)) + panic(fmt.Errorf("%s: not implemented: %v", f.UniqueName, index)) } - value := eval.Value{ - Kind: eval.Memory, - Type: array.Type.(*types.Array).Of, + value := eval.Memory{ + Typ: array.Value.Typ.(*types.Array).Of, Memory: memory, } diff --git a/src/core/EvaluateCall.go b/src/core/EvaluateCall.go index e5a1eef..a35c2f0 100644 --- a/src/core/EvaluateCall.go +++ b/src/core/EvaluateCall.go @@ -11,16 +11,15 @@ func (f *Function) EvaluateCall(expr *expression.Expression) (eval.Value, error) types, err := f.CompileCall(expr) if err != nil { - return eval.Value{}, err + return nil, err } if len(types) == 0 { - return eval.Value{}, errors.New(errors.UntypedExpression, f.File, expr.Token.Position) + return nil, errors.New(errors.UntypedExpression, f.File, expr.Token.Position) } - value := eval.Value{ - Kind: eval.Register, - Type: types[0], + value := eval.Register{ + Typ: types[0], Register: f.CPU.Output[0], } diff --git a/src/core/EvaluateDot.go b/src/core/EvaluateDot.go index 46b68ec..71aeebe 100644 --- a/src/core/EvaluateDot.go +++ b/src/core/EvaluateDot.go @@ -20,13 +20,12 @@ func (f *Function) EvaluateDot(expr *expression.Expression) (eval.Value, error) variable := f.VariableByName(leftText) if variable != nil { - field := variable.Type.(*types.Pointer).To.(*types.Struct).FieldByName(rightText) + field := variable.Value.Typ.(*types.Pointer).To.(*types.Struct).FieldByName(rightText) - value := eval.Value{ - Kind: eval.Memory, - Type: field.Type, + value := eval.Memory{ + Typ: field.Type, Memory: asm.Memory{ - Base: variable.Register, + Base: variable.Value.Register, Offset: int8(field.Offset), OffsetRegister: math.MaxUint8, Length: byte(field.Type.Size()), @@ -42,12 +41,11 @@ func (f *Function) EvaluateDot(expr *expression.Expression) (eval.Value, error) number, err := ToNumber(constant.Token, constant.File) if err != nil { - return eval.Value{}, err + return nil, err } - value := eval.Value{ - Kind: eval.Number, - Type: types.AnyInt, + value := eval.Number{ + Typ: types.AnyInt, Number: number, } @@ -60,14 +58,13 @@ func (f *Function) EvaluateDot(expr *expression.Expression) (eval.Value, error) if exists { f.File.Imports[leftText].Used = true - value := eval.Value{ - Kind: eval.Label, - Type: types.AnyPointer, + value := eval.Label{ + Typ: types.AnyPointer, Label: function.UniqueName, } return value, nil } - return eval.Value{}, errors.New(&errors.UnknownIdentifier{Name: uniqueName}, f.File, left.Token.Position) + return nil, errors.New(&errors.UnknownIdentifier{Name: uniqueName}, f.File, left.Token.Position) } diff --git a/src/core/EvaluateLeaf.go b/src/core/EvaluateLeaf.go index af9446e..86b3629 100644 --- a/src/core/EvaluateLeaf.go +++ b/src/core/EvaluateLeaf.go @@ -18,9 +18,8 @@ func (f *Function) EvaluateLeaf(expr *expression.Expression) (eval.Value, error) name := expr.Token.Text(f.File.Bytes) if name == "true" { - value := eval.Value{ - Kind: eval.Number, - Type: types.Bool, + value := eval.Number{ + Typ: types.Bool, Number: 1, } @@ -28,9 +27,8 @@ func (f *Function) EvaluateLeaf(expr *expression.Expression) (eval.Value, error) } if name == "false" { - value := eval.Value{ - Kind: eval.Number, - Type: types.Bool, + value := eval.Number{ + Typ: types.Bool, Number: 0, } @@ -42,16 +40,15 @@ func (f *Function) EvaluateLeaf(expr *expression.Expression) (eval.Value, error) if variable != nil { f.UseVariable(variable) - if variable.Alive == 0 { + if variable.Value.Alive == 0 { return variable.Value, nil } tmp := f.NewRegister() - f.RegisterRegister(asm.MOVE, tmp, variable.Register) + f.RegisterRegister(asm.MOVE, tmp, variable.Value.Register) - value := eval.Value{ - Kind: eval.Register, - Type: variable.Type, + value := eval.Register{ + Typ: variable.Value.Typ, Register: tmp, } @@ -59,27 +56,25 @@ func (f *Function) EvaluateLeaf(expr *expression.Expression) (eval.Value, error) } if function != nil { - value := eval.Value{ - Kind: eval.Label, - Type: types.AnyPointer, + value := eval.Label{ + Typ: types.AnyPointer, Label: function.UniqueName, } return value, nil } - return eval.Value{}, errors.New(&errors.UnknownIdentifier{Name: name}, f.File, expr.Token.Position) + return nil, 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 + return nil, err } - value := eval.Value{ - Kind: eval.Number, - Type: types.AnyInt, + value := eval.Number{ + Typ: types.AnyInt, Number: number, } @@ -94,14 +89,13 @@ func (f *Function) EvaluateLeaf(expr *expression.Expression) (eval.Value, error) copy(slice[8:], data) label := f.AddBytes(slice) - value := eval.Value{ - Kind: eval.Label, - Type: types.String, + value := eval.Label{ + Typ: types.String, Label: label, } return value, nil } - return eval.Value{}, errors.New(errors.InvalidExpression, f.File, expr.Token.Position) + return nil, errors.New(errors.InvalidExpression, f.File, expr.Token.Position) } diff --git a/src/core/ExecuteLeaf.go b/src/core/ExecuteLeaf.go index 06310ae..6ee59af 100644 --- a/src/core/ExecuteLeaf.go +++ b/src/core/ExecuteLeaf.go @@ -18,7 +18,7 @@ func (f *Function) ExecuteLeaf(operation token.Token, register cpu.Register, ope } defer f.UseVariable(variable) - return f.ExecuteRegisterRegister(operation, register, variable.Register) + return f.ExecuteRegisterRegister(operation, register, variable.Value.Register) case token.Number, token.Rune: number, err := f.ToNumber(operand) diff --git a/src/core/ExpressionToMemory.go b/src/core/ExpressionToMemory.go index be9811f..8ec2efa 100644 --- a/src/core/ExpressionToMemory.go +++ b/src/core/ExpressionToMemory.go @@ -17,7 +17,7 @@ func (f *Function) ExpressionToMemory(node *expression.Expression, memory asm.Me return nil, err } - switch value.Kind { + switch value := value.(type) { case eval.Number: f.MemoryNumber(asm.STORE, memory, value.Number) case eval.Register: @@ -31,8 +31,8 @@ func (f *Function) ExpressionToMemory(node *expression.Expression, memory asm.Me case eval.Label: f.MemoryLabel(asm.STORE, memory, value.Label) default: - panic(fmt.Errorf("%s: not implemented: %d", f.UniqueName, value.Kind)) + panic(fmt.Errorf("%s: not implemented: %v", f.UniqueName, value)) } - return value.Type, err + return value.Type(), err } diff --git a/src/core/ExpressionToRegister.go b/src/core/ExpressionToRegister.go index b81d5cd..a5bfcdc 100644 --- a/src/core/ExpressionToRegister.go +++ b/src/core/ExpressionToRegister.go @@ -71,7 +71,7 @@ func (f *Function) ExpressionToRegister(node *expression.Expression, register cp } else if right.Token.Kind == token.Identifier { rightVariable := f.VariableByName(right.Token.Text(f.File.Bytes)) leftPointer, leftIsPointer := typ.(*types.Pointer) - rightPointer, rightIsPointer := rightVariable.Type.(*types.Pointer) + rightPointer, rightIsPointer := rightVariable.Value.Typ.(*types.Pointer) if leftIsPointer && rightIsPointer && leftPointer.To == rightPointer.To { typ = types.Int diff --git a/src/core/MultiAssign.go b/src/core/MultiAssign.go index e6c3f13..fab3d6c 100644 --- a/src/core/MultiAssign.go +++ b/src/core/MultiAssign.go @@ -23,7 +23,7 @@ func (f *Function) MultiAssign(left *expression.Expression, right *expression.Ex return errors.New(&errors.UnknownIdentifier{Name: name}, f.File, left.Token.Position) } - f.RegisterRegister(asm.MOVE, variable.Register, f.CPU.Output[count]) + f.RegisterRegister(asm.MOVE, variable.Value.Register, f.CPU.Output[count]) f.UseVariable(variable) count++ return nil diff --git a/src/core/ResolveTypes.go b/src/core/ResolveTypes.go index 7db5a6c..6df48c1 100644 --- a/src/core/ResolveTypes.go +++ b/src/core/ResolveTypes.go @@ -32,9 +32,8 @@ func (f *Function) ResolveTypes() error { f.AddVariable(&scope.Variable{ Name: param.name, - Value: eval.Value{ - Kind: eval.Register, - Type: param.typ, + Value: eval.Register{ + Typ: param.typ, Register: x86.InputRegisters[i], Alive: uses, }, diff --git a/src/core/TokenToRegister.go b/src/core/TokenToRegister.go index fce74e1..70989e1 100644 --- a/src/core/TokenToRegister.go +++ b/src/core/TokenToRegister.go @@ -32,8 +32,8 @@ func (f *Function) TokenToRegister(t token.Token, register cpu.Register) (types. if variable != nil { f.UseVariable(variable) f.SaveRegister(register) - f.RegisterRegister(asm.MOVE, register, variable.Register) - return variable.Type, nil + f.RegisterRegister(asm.MOVE, register, variable.Value.Register) + return variable.Value.Typ, nil } if function != nil { diff --git a/src/core/UsesRegister.go b/src/core/UsesRegister.go index df66b67..cd4ab79 100644 --- a/src/core/UsesRegister.go +++ b/src/core/UsesRegister.go @@ -16,7 +16,7 @@ func (f *Function) UsesRegister(expr *expression.Expression, register cpu.Regist variable := f.VariableByName(expr.Token.Text(f.File.Bytes)) - if variable == nil || variable.Register != register { + if variable == nil || variable.Value.Register != register { return false } diff --git a/src/eval/Kind.go b/src/eval/Kind.go deleted file mode 100644 index 4a41f05..0000000 --- a/src/eval/Kind.go +++ /dev/null @@ -1,11 +0,0 @@ -package eval - -type Kind uint8 - -const ( - Invalid Kind = iota // Invalid is an invalid value. - Number // Number is an immediately encoded value stored together with the instruction. - Register // Register is a CPU register. - Memory // Memory is an area in the RAM. - Label // Label is a reference to a name that can only be resolved once the program is fully compiled. -) diff --git a/src/eval/Label.go b/src/eval/Label.go new file mode 100644 index 0000000..a74afe0 --- /dev/null +++ b/src/eval/Label.go @@ -0,0 +1,17 @@ +package eval + +import "git.urbach.dev/cli/q/src/types" + +// Label is a named pointer to a code or data section. +type Label struct { + Typ types.Type + Label string +} + +func (v Label) String() string { + return "Label" +} + +func (v Label) Type() types.Type { + return v.Typ +} diff --git a/src/eval/Memory.go b/src/eval/Memory.go new file mode 100644 index 0000000..0afd09e --- /dev/null +++ b/src/eval/Memory.go @@ -0,0 +1,20 @@ +package eval + +import ( + "git.urbach.dev/cli/q/src/asm" + "git.urbach.dev/cli/q/src/types" +) + +// Memory is a region in memory that can be addressed by an instruction. +type Memory struct { + Typ types.Type + Memory asm.Memory +} + +func (v Memory) String() string { + return "Memory" +} + +func (v Memory) Type() types.Type { + return v.Typ +} diff --git a/src/eval/Number.go b/src/eval/Number.go new file mode 100644 index 0000000..e9dc2d7 --- /dev/null +++ b/src/eval/Number.go @@ -0,0 +1,17 @@ +package eval + +import "git.urbach.dev/cli/q/src/types" + +// Number is an immediate value that is stored next to the instruction. +type Number struct { + Typ types.Type + Number int +} + +func (v Number) String() string { + return "Number" +} + +func (v Number) Type() types.Type { + return v.Typ +} diff --git a/src/eval/Register.go b/src/eval/Register.go new file mode 100644 index 0000000..088593f --- /dev/null +++ b/src/eval/Register.go @@ -0,0 +1,21 @@ +package eval + +import ( + "git.urbach.dev/cli/q/src/cpu" + "git.urbach.dev/cli/q/src/types" +) + +// Register is a value that is stored inside a CPU register. +type Register struct { + Typ types.Type + Alive uint8 + Register cpu.Register +} + +func (v Register) String() string { + return "Register" +} + +func (v Register) Type() types.Type { + return v.Typ +} diff --git a/src/eval/Value.go b/src/eval/Value.go index 1205a98..681cc18 100644 --- a/src/eval/Value.go +++ b/src/eval/Value.go @@ -1,29 +1,22 @@ package eval import ( - "git.urbach.dev/cli/q/src/asm" - "git.urbach.dev/cli/q/src/cpu" "git.urbach.dev/cli/q/src/types" ) -// Value combines a register with its data type. -type Value struct { - Type types.Type - Label string - Number int - Memory asm.Memory - Register cpu.Register - Alive uint8 - Kind Kind +// Value abstracts all data storage types like immediates, registers and memory. +type Value interface { + String() string + Type() types.Type } -// IsAlive returns true if the Value is still alive. -func (v *Value) IsAlive() bool { +// IsAlive returns true if the register value is still alive. +func (v *Register) IsAlive() bool { return v.Alive > 0 } // Use reduces the lifetime counter by one. -func (v *Value) Use() { +func (v *Register) Use() { if v.Alive == 0 { panic("incorrect number of value use calls") } diff --git a/src/register/SaveRegister.go b/src/register/SaveRegister.go index 9f9bd0a..1e4ec20 100644 --- a/src/register/SaveRegister.go +++ b/src/register/SaveRegister.go @@ -19,12 +19,12 @@ func (f *Machine) SaveRegister(register cpu.Register) { variable := f.VariableByRegister(register) - if variable == nil || variable.Alive == 0 { + if variable == nil || variable.Value.Alive == 0 { return } newRegister := f.NewRegister() f.RegisterRegister(asm.MOVE, newRegister, register) - variable.Register = newRegister + variable.Value.Register = newRegister f.FreeRegister(register) } diff --git a/src/scope/Scope.go b/src/scope/Scope.go index 20efebc..490ae2c 100644 --- a/src/scope/Scope.go +++ b/src/scope/Scope.go @@ -15,7 +15,7 @@ type Scope struct { // AddVariable adds a new variable to the current scope. func (s *Scope) AddVariable(variable *Variable) { s.Variables = append(s.Variables, variable) - s.Use(variable.Register) + s.Use(variable.Value.Register) } // VariableByName returns the variable with the given name or `nil` if it doesn't exist. diff --git a/src/scope/Stack.go b/src/scope/Stack.go index c2c1e9d..9b06334 100644 --- a/src/scope/Stack.go +++ b/src/scope/Stack.go @@ -46,11 +46,10 @@ func (stack *Stack) PushScope(body ast.AST, buffer []byte) *Scope { s.Variables = append(s.Variables, &Variable{ Name: v.Name, - Value: eval.Value{ - Kind: eval.Register, - Register: v.Register, + Value: eval.Register{ + Typ: v.Value.Typ, Alive: count, - Type: v.Type, + Register: v.Value.Register, }, }) } @@ -73,10 +72,10 @@ func (stack *Stack) UseVariable(variable *Variable) { continue } - local.Use() + local.Value.Use() - if !local.IsAlive() { - scope.Free(local.Register) + if !local.Value.IsAlive() { + scope.Free(local.Value.Register) } } } @@ -89,7 +88,7 @@ func (stack *Stack) VariableByName(name string) *Variable { // VariableByRegister returns the variable that occupies the given register or `nil` if none occupy the register. func (stack *Stack) VariableByRegister(register cpu.Register) *Variable { for _, v := range stack.CurrentScope().Variables { - if v.Register == register { + if v.Value.Register == register { return v } } diff --git a/src/scope/Variable.go b/src/scope/Variable.go index 72ea61b..522e2f4 100644 --- a/src/scope/Variable.go +++ b/src/scope/Variable.go @@ -4,6 +4,6 @@ import "git.urbach.dev/cli/q/src/eval" // Variable is a named value. type Variable struct { - Name string - eval.Value + Name string + Value eval.Register }