cli/q
Code Issues 1 Pull Requests Activity

Simplified expression evaluation

Browse Source
This commit is contained in:
Eduard Urbach 2025-02-28 16:07:10 +01:00
parent b67361c035
commit a5a8f0f503
Signed by: akyoto
GPG Key ID: C874F672B1AF20C0
17 changed files with 153 additions and 322 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

75
src/core/ArrayElementToRegister.go
View File

@ -1,75 +0,0 @@
package core
import (
"math"
"git.urbach.dev/cli/q/src/asm"
"git.urbach.dev/cli/q/src/cpu"
"git.urbach.dev/cli/q/src/errors"
"git.urbach.dev/cli/q/src/expression"
"git.urbach.dev/cli/q/src/token"
"git.urbach.dev/cli/q/src/types"
)
// ArrayElementToRegister moves the value of an array element into the given register.
func (f *Function) ArrayElementToRegister(node *expression.Expression, register cpu.Register) (types.Type, error) {
name := node.Children[0].Token.Text(f.File.Bytes)
array := f.VariableByName(name)
if array == nil {
return nil, errors.New(&errors.UnknownIdentifier{Name: name}, f.File, node.Children[0].Token.Position)
}
defer f.UseVariable(array)
index := node.Children[1]
memory := asm.Memory{
Base: array.Value.Register,
Offset: 0,
OffsetRegister: math.MaxUint8,
Length: byte(1),
}
switch {
case index.Token.IsNumeric():
offset, err := f.ToNumber(index.Token)
if err != nil {
return nil, err
}
memory.Offset = int8(offset)
case index.Token.Kind == token.Identifier:
indexName := index.Token.Text(f.File.Bytes)
indexVariable := f.VariableByName(indexName)
if indexVariable == nil {
return nil, errors.New(&errors.UnknownIdentifier{Name: indexName}, f.File, index.Token.Position)
}
defer f.UseVariable(indexVariable)
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.Value.Register
default:
typ, err := f.ExpressionToRegister(index, register)
if err != nil {
return nil, err
}
if !types.Is(typ, types.AnyInt) {
return nil, errors.New(&errors.TypeMismatch{Encountered: typ.Name(), Expected: types.AnyInt.Name()}, f.File, index.Token.Position)
}
memory.OffsetRegister = register
}
f.MemoryRegister(asm.LOAD, memory, register)
return types.Int, nil
}

27
src/core/CallToRegister.go
View File

@ -1,27 +0,0 @@
package core
import (
"git.urbach.dev/cli/q/src/asm"
"git.urbach.dev/cli/q/src/cpu"
"git.urbach.dev/cli/q/src/expression"
"git.urbach.dev/cli/q/src/types"
)
// CallToRegister moves the result of a function call into the given register.
func (f *Function) CallToRegister(node *expression.Expression, register cpu.Register) (types.Type, error) {
types, err := f.CompileCall(node)
if err != nil {
return nil, err
}
if register != f.CPU.Output[0] {
f.RegisterRegister(asm.MOVE, register, f.CPU.Output[0])
}
if len(types) == 0 {
return nil, nil
}
return types[0], err
}

2
src/core/Compare.go
View File

@ -31,7 +31,7 @@ func (f *Function) Compare(comparison *expression.Expression) error {
return err
}
return f.ExecuteLeaf(comparison.Token, f.CPU.Output[0], right.Token)
return f.ExecuteToken(comparison.Token, f.CPU.Output[0], right.Token)
}
tmp := f.NewRegister()

26
src/core/CompileDefinition.go
View File

@ -1,10 +1,8 @@
package core
import (
"git.urbach.dev/cli/q/src/asm"
"git.urbach.dev/cli/q/src/ast"
"git.urbach.dev/cli/q/src/errors"
"git.urbach.dev/cli/q/src/expression"
"git.urbach.dev/cli/q/src/token"
"git.urbach.dev/cli/q/src/types"
)
@ -48,27 +46,5 @@ func (f *Function) CompileDefinition(node *ast.Define) error {
return errors.New(errors.NotImplemented, f.File, node.Expression.Token.Position)
}
count := 0
types, err := f.CompileCall(right)
if err != nil {
return err
}
return left.EachLeaf(func(leaf *expression.Expression) error {
variable, err := f.Define(leaf)
if err != nil {
return err
}
if count < len(types) {
variable.Value.Typ = types[count]
}
f.RegisterRegister(asm.MOVE, variable.Value.Register, f.CPU.Output[count])
f.AddVariable(variable)
count++
return nil
})
return f.MultiDefine(left, right)
}

60
src/core/DotToRegister.go
View File

@ -1,60 +0,0 @@
package core
import (
"fmt"
"math"
"git.urbach.dev/cli/q/src/asm"
"git.urbach.dev/cli/q/src/cpu"
"git.urbach.dev/cli/q/src/errors"
"git.urbach.dev/cli/q/src/expression"
"git.urbach.dev/cli/q/src/types"
)
// DotToRegister moves a constant or a function address into the given register.
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)
rightText := right.Token.Text(f.File.Bytes)
variable := f.VariableByName(leftText)
if variable != nil {
field := variable.Value.Typ.(*types.Pointer).To.(*types.Struct).FieldByName(rightText)
memory := asm.Memory{
Base: variable.Value.Register,
Offset: int8(field.Offset),
OffsetRegister: math.MaxUint8,
Length: byte(field.Type.Size()),
}
f.MemoryRegister(asm.LOAD, memory, register)
return field.Type, nil
}
constant, isConst := f.All.Constants[f.Package+"."+leftText+"."+rightText]
if isConst {
number, err := ToNumber(constant.Token, constant.File)
if err != nil {
return nil, err
}
f.SaveRegister(register)
f.RegisterNumber(asm.MOVE, register, number)
return types.AnyInt, nil
}
uniqueName := fmt.Sprintf("%s.%s", leftText, rightText)
function, exists := f.All.Functions[uniqueName]
if exists {
f.File.Imports[leftText].Used = true
f.RegisterLabel(asm.MOVE, register, function.UniqueName)
return types.AnyPointer, nil
}
return nil, errors.New(&errors.UnknownIdentifier{Name: uniqueName}, f.File, left.Token.Position)
}

2
src/core/Evaluate.go
View File

@ -19,7 +19,7 @@ func (f *Function) Evaluate(expr *expression.Expression) (eval.Value, error) {
}
if expr.IsLeaf() {
return f.EvaluateLeaf(expr)
return f.EvaluateToken(expr.Token)
}
switch expr.Token.Kind {

10
src/core/EvaluateArray.go
View File

@ -11,13 +11,13 @@ import (
"git.urbach.dev/cli/q/src/types"
)
// EvaluateArray evaluates a function call.
func (f *Function) EvaluateArray(expr *expression.Expression) (eval.Value, error) {
// EvaluateArray evaluates an array access.
func (f *Function) EvaluateArray(expr *expression.Expression) (eval.Memory, error) {
name := expr.Children[0].Token.Text(f.File.Bytes)
array := f.VariableByName(name)
if array == nil {
return nil, errors.New(&errors.UnknownIdentifier{Name: name}, f.File, expr.Children[0].Token.Position)
return eval.Memory{}, errors.New(&errors.UnknownIdentifier{Name: name}, f.File, expr.Children[0].Token.Position)
}
defer f.UseVariable(array)
@ -33,11 +33,11 @@ func (f *Function) EvaluateArray(expr *expression.Expression) (eval.Value, error
index, err := f.Evaluate(indexExpr)
if err != nil {
return nil, err
return eval.Memory{}, err
}
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)
return eval.Memory{}, errors.New(&errors.TypeMismatch{Encountered: index.Type().Name(), Expected: types.AnyInt.Name()}, f.File, indexExpr.Token.Position)
}
switch index := index.(type) {

16
src/core/EvaluateCall.go
View File

@ -1,26 +1,22 @@
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)
func (f *Function) EvaluateCall(expr *expression.Expression) (eval.Register, error) {
typ, err := f.CompileCall(expr)
if err != nil {
return nil, err
return eval.Register{}, err
}
if len(types) == 0 {
return nil, errors.New(errors.UntypedExpression, f.File, expr.Token.Position)
}
value := eval.Register{Register: f.CPU.Output[0]}
value := eval.Register{
Typ: types[0],
Register: f.CPU.Output[0],
if len(typ) > 0 {
value.Typ = typ[0]
}
return value, nil

17
src/core/EvaluateLeaf.go → src/core/EvaluateToken.go
View File

@ -6,16 +6,15 @@ import (
"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 {
// EvaluateToken evaluates a single token.
func (f *Function) EvaluateToken(t token.Token) (eval.Value, error) {
switch t.Kind {
case token.Identifier:
name := expr.Token.Text(f.File.Bytes)
name := t.Text(f.File.Bytes)
if name == "true" {
value := eval.Number{
@ -64,10 +63,10 @@ func (f *Function) EvaluateLeaf(expr *expression.Expression) (eval.Value, error)
return value, nil
}
return nil, errors.New(&errors.UnknownIdentifier{Name: name}, f.File, expr.Token.Position)
return nil, errors.New(&errors.UnknownIdentifier{Name: name}, f.File, t.Position)
case token.Number, token.Rune:
number, err := f.ToNumber(expr.Token)
number, err := f.ToNumber(t)
if err != nil {
return nil, err
@ -81,7 +80,7 @@ func (f *Function) EvaluateLeaf(expr *expression.Expression) (eval.Value, error)
return value, nil
case token.String:
data := expr.Token.Bytes(f.File.Bytes)
data := t.Bytes(f.File.Bytes)
data = String(data)
slice := make([]byte, len(data)+8+1)
@ -97,5 +96,5 @@ func (f *Function) EvaluateLeaf(expr *expression.Expression) (eval.Value, error)
return value, nil
}
return nil, errors.New(errors.InvalidExpression, f.File, expr.Token.Position)
return nil, errors.New(errors.InvalidExpression, f.File, t.Position)
}

12
src/core/Execute.go
View File

@ -8,13 +8,13 @@ import (
)
// Execute executes an operation on a register with a value operand.
func (f *Function) Execute(operation token.Token, register cpu.Register, value *expression.Expression) error {
if value.IsLeaf() {
return f.ExecuteLeaf(operation, register, value.Token)
func (f *Function) Execute(operation token.Token, register cpu.Register, expr *expression.Expression) error {
if expr.IsLeaf() {
return f.ExecuteToken(operation, register, expr.Token)
}
if ast.IsFunctionCall(value) {
_, err := f.CompileCall(value)
if ast.IsFunctionCall(expr) {
_, err := f.CompileCall(expr)
if err != nil {
return err
@ -26,7 +26,7 @@ func (f *Function) Execute(operation token.Token, register cpu.Register, value *
tmp := f.NewRegister()
defer f.FreeRegister(tmp)
_, err := f.ExpressionToRegister(value, tmp)
_, err := f.ExpressionToRegister(expr, tmp)
if err != nil {
return err

12
src/core/ExecuteLeaf.go → src/core/ExecuteToken.go
View File

@ -6,8 +6,8 @@ import (
"git.urbach.dev/cli/q/src/token"
)
// ExecuteLeaf performs an operation on a register with the given leaf operand.
func (f *Function) ExecuteLeaf(operation token.Token, register cpu.Register, operand token.Token) error {
// ExecuteToken performs an operation on a register with the given leaf operand.
func (f *Function) ExecuteToken(operation token.Token, register cpu.Register, operand token.Token) error {
switch operand.Kind {
case token.Identifier:
name := operand.Text(f.File.Bytes)
@ -31,7 +31,13 @@ func (f *Function) ExecuteLeaf(operation token.Token, register cpu.Register, ope
case token.String:
if operation.Kind == token.Assign {
_, err := f.TokenToRegister(operand, register)
value, err := f.EvaluateToken(operand)
if err != nil {
return err
}
f.ValueToRegister(value, register)
return err
}
}

23
src/core/ExpressionToMemory.go
View File

@ -1,10 +1,7 @@
package core
import (
"fmt"
"git.urbach.dev/cli/q/src/asm"
"git.urbach.dev/cli/q/src/eval"
"git.urbach.dev/cli/q/src/expression"
"git.urbach.dev/cli/q/src/types"
)
@ -17,22 +14,6 @@ func (f *Function) ExpressionToMemory(node *expression.Expression, memory asm.Me
return nil, err
}
switch value := value.(type) {
case eval.Number:
f.MemoryNumber(asm.STORE, memory, value.Number)
case eval.Register:
f.MemoryRegister(asm.STORE, memory, value.Register)
f.FreeRegister(value.Register)
case eval.Memory:
tmp := f.NewRegister()
f.MemoryRegister(asm.LOAD, value.Memory, tmp)
f.MemoryRegister(asm.STORE, memory, tmp)
f.FreeRegister(tmp)
case eval.Label:
f.MemoryLabel(asm.STORE, memory, value.Label)
default:
panic(fmt.Errorf("%s: not implemented: %v", f.UniqueName, value))
}
return value.Type(), err
f.ValueToMemory(value, memory)
return value.Type(), nil
}

40
src/core/ExpressionToRegister.go
View File

@ -17,16 +17,46 @@ func (f *Function) ExpressionToRegister(node *expression.Expression, register cp
}
if node.IsLeaf() {
return f.TokenToRegister(node.Token, register)
value, err := f.EvaluateToken(node.Token)
if err != nil {
return nil, err
}
f.ValueToRegister(value, register)
return value.Type(), nil
}
switch node.Token.Kind {
case token.Call:
return f.CallToRegister(node, register)
case token.Array:
return f.ArrayElementToRegister(node, register)
value, err := f.EvaluateArray(node)
if err != nil {
return nil, err
}
f.ValueToRegister(value, register)
return value.Type(), nil
case token.Dot:
return f.DotToRegister(node, register)
value, err := f.EvaluateDot(node)
if err != nil {
return nil, err
}
f.ValueToRegister(value, register)
return value.Type(), nil
case token.Call:
value, err := f.EvaluateCall(node)
if err != nil {
return nil, err
}
f.ValueToRegister(value, register)
return value.Type(), nil
}
if len(node.Children) == 1 {

33
src/core/MultiDefine.go Normal file
View File

@ -0,0 +1,33 @@
package core
import (
"git.urbach.dev/cli/q/src/asm"
"git.urbach.dev/cli/q/src/expression"
)
// MultiDefine defines multiple variables at once.
func (f *Function) MultiDefine(left *expression.Expression, right *expression.Expression) error {
count := 0
types, err := f.CompileCall(right)
if err != nil {
return err
}
return left.EachLeaf(func(leaf *expression.Expression) error {
variable, err := f.Define(leaf)
if err != nil {
return err
}
if count < len(types) {
variable.Value.Typ = types[count]
}
f.RegisterRegister(asm.MOVE, variable.Value.Register, f.CPU.Output[count])
f.AddVariable(variable)
count++
return nil
})
}

74
src/core/TokenToRegister.go
View File

@ -1,74 +0,0 @@
package core
import (
"encoding/binary"
"git.urbach.dev/cli/q/src/asm"
"git.urbach.dev/cli/q/src/cpu"
"git.urbach.dev/cli/q/src/errors"
"git.urbach.dev/cli/q/src/token"
"git.urbach.dev/cli/q/src/types"
)
// TokenToRegister moves a token into a register.
// It only works with identifiers, numbers and strings.
func (f *Function) TokenToRegister(t token.Token, register cpu.Register) (types.Type, error) {
switch t.Kind {
case token.Identifier:
name := t.Text(f.File.Bytes)
if name == "true" {
f.RegisterNumber(asm.MOVE, register, 1)
return types.Bool, nil
}
if name == "false" {
f.RegisterNumber(asm.MOVE, register, 0)
return types.Bool, nil
}
variable, function := f.Identifier(name)
if variable != nil {
f.UseVariable(variable)
f.SaveRegister(register)
f.RegisterRegister(asm.MOVE, register, variable.Value.Register)
return variable.Value.Typ, nil
}
if function != nil {
f.SaveRegister(register)
f.RegisterLabel(asm.MOVE, register, function.UniqueName)
return types.AnyPointer, nil
}
return nil, errors.New(&errors.UnknownIdentifier{Name: name}, f.File, t.Position)
case token.Number, token.Rune:
number, err := f.ToNumber(t)
if err != nil {
return nil, err
}
f.SaveRegister(register)
f.RegisterNumber(asm.MOVE, register, number)
return types.AnyInt, nil
case token.String:
data := t.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)
f.SaveRegister(register)
f.RegisterLabel(asm.MOVE, register, label)
return types.String, nil
default:
return nil, errors.New(errors.InvalidExpression, f.File, t.Position)
}
}

24
src/core/ValueToMemory.go Normal file
View File

@ -0,0 +1,24 @@
package core
import (
"git.urbach.dev/cli/q/src/asm"
"git.urbach.dev/cli/q/src/eval"
)
// ValueToMemory moves a value into a memory region.
func (f *Function) ValueToMemory(value eval.Value, memory asm.Memory) {
switch value := value.(type) {
case eval.Number:
f.MemoryNumber(asm.STORE, memory, value.Number)
case eval.Register:
f.MemoryRegister(asm.STORE, memory, value.Register)
f.FreeRegister(value.Register)
case eval.Memory:
tmp := f.NewRegister()
f.MemoryRegister(asm.LOAD, value.Memory, tmp)
f.MemoryRegister(asm.STORE, memory, tmp)
f.FreeRegister(tmp)
case eval.Label:
f.MemoryLabel(asm.STORE, memory, value.Label)
}
}

22
src/core/ValueToRegister.go Normal file
View File

@ -0,0 +1,22 @@
package core
import (
"git.urbach.dev/cli/q/src/asm"
"git.urbach.dev/cli/q/src/cpu"
"git.urbach.dev/cli/q/src/eval"
)
// ValueToRegister moves a value into a register.
func (f *Function) ValueToRegister(value eval.Value, register cpu.Register) {
switch value := value.(type) {
case eval.Number:
f.RegisterNumber(asm.MOVE, register, value.Number)
case eval.Register:
f.RegisterRegister(asm.MOVE, register, value.Register)
f.FreeRegister(value.Register)
case eval.Memory:
f.MemoryRegister(asm.LOAD, value.Memory, register)
case eval.Label:
f.RegisterLabel(asm.MOVE, register, value.Label)
}
}