basic expression interpreter

runtime/interpreter.go

@@ -1,6 +1,9 @@
 package runtime
 
-import "git.red-panda.pet/pandaware/lox-go/ast"
+import (
+	"git.red-panda.pet/pandaware/lox-go/ast"
+	"git.red-panda.pet/pandaware/lox-go/lexer"
+)
 
 type Interpreter struct{}
 
@@ -10,22 +13,121 @@ func NewInterpreter() *Interpreter {
 	return new(Interpreter)
 }
 
+func (i *Interpreter) Evaluate(exp ast.Expr) *LoxValue {
+	result := exp.Accept(i)
+	if value, ok := result.(*LoxValue); ok {
+		return value
+	}
+
+	panic("badly implemented expression visitor")
+}
+
 // VisitBinaryExpr implements ast.ExprVisitor.
 func (i *Interpreter) VisitBinaryExpr(b *ast.BinaryExpr) any {
-	panic("unimplemented")
+	left := i.Evaluate(b.Left)
+	right := i.Evaluate(b.Right)
+
+	leftType := left.Type()
+	rightType := right.Type()
+
+	areNumbers := leftType == LoxTypeNumber &&
+		rightType == LoxTypeNumber
+
+	areStrings := leftType == LoxTypeString &&
+		rightType == LoxTypeString
+
+	switch b.Operator.Type {
+	case lexer.TokenTypeMinus:
+		if !areNumbers {
+			// todo: error here
+			return Value(nil)
+		}
+		return Value(left.Number() - right.Number())
+	case lexer.TokenTypeSlash:
+		if !areNumbers {
+			// todo: error here
+			return Value(nil)
+		}
+
+		if right.Number() == 0 {
+			// todo: error here
+			return Value(nil)
+		}
+
+		return Value(left.Number() / right.Number())
+	case lexer.TokenTypeStar:
+		if !areNumbers {
+			return Value(nil)
+		}
+
+		return Value(left.Number() * right.Number())
+	case lexer.TokenTypePlus:
+		if areNumbers {
+			return Value(left.Number() + right.Number())
+		}
+
+		if areStrings {
+			return Value(left.String() + right.String())
+		}
+
+		return Value(nil)
+	case lexer.TokenTypeGreater:
+		if !areNumbers {
+			return Value(nil)
+		}
+
+		return Value(left.Number() > right.Number())
+	case lexer.TokenTypeGreaterEq:
+		if !areNumbers {
+			return Value(nil)
+		}
+
+		return Value(left.Number() >= right.Number())
+
+	case lexer.TokenTypeLess:
+		if !areNumbers {
+			return Value(nil)
+		}
+
+		return Value(left.Number() < right.Number())
+	case lexer.TokenTypeLessEq:
+		if !areNumbers {
+			return Value(nil)
+		}
+
+		return Value(left.Number() <= right.Number())
+	case lexer.TokenTypeEqualEqual:
+		return Value(left.Equals(right))
+	case lexer.TokenTypeBangEq:
+		return Value(!left.Equals(right))
+	}
+
+	return Value(nil)
 }
 
 // VisitGroupingExpr implements ast.ExprVisitor.
 func (i *Interpreter) VisitGroupingExpr(g *ast.GroupingExpr) any {
-	panic("unimplemented")
+	return i.Evaluate(g.Expr)
 }
 
 // VisitLiteralExpr implements ast.ExprVisitor.
 func (i *Interpreter) VisitLiteralExpr(g *ast.LiteralExpr) any {
-	panic("unimplemented")
+	return Value(g.Value)
 }
 
 // VisitUnaryExpr implements ast.ExprVisitor.
 func (i *Interpreter) VisitUnaryExpr(g *ast.UnaryExpr) any {
-	panic("unimplemented")
+	right := i.Evaluate(g.Right)
+
+	switch g.Operator.Type {
+	case lexer.TokenTypeMinus:
+		if right.Type() != LoxTypeNumber {
+			// todo: error here
+		}
+		return Value(right)
+	case lexer.TokenTypeBang:
+		return Value(!right.IsTruthy())
+	}
+
+	return Value(nil)
 }

runtime/types.go

@@ -1,5 +1,7 @@
 package runtime
 
+import "fmt"
+
 //go:generate stringer -type LoxType -trimprefix LoxType
 type LoxType int
 
@@ -19,15 +21,81 @@ func (v *LoxValue) Type() LoxType {
 	switch v.raw.(type) {
 	case string:
 		return LoxTypeString
-	case float64, float32:
+	case float64:
 		return LoxTypeNumber
 	case bool:
 		return LoxTypeBoolean
+	case nil:
+		return LoxTypeNil
 	default:
 		return LoxTypeUndefined
 	}
 }
 
+func (v *LoxValue) Debug() string {
+	return fmt.Sprintf("%+v", v.raw)
+}
+
+func (v *LoxValue) String() string {
+	if string, ok := v.raw.(string); ok {
+		return string
+	}
+	return ""
+}
+
+func (v *LoxValue) Number() float64 {
+	if number, ok := v.raw.(float64); ok {
+		return number
+	}
+	return 0.0
+}
+
+func (v *LoxValue) IsString() bool {
+	return v.Type() == LoxTypeString
+}
+
+func (v *LoxValue) IsNumber() bool {
+	return v.Type() == LoxTypeNumber
+}
+func (v *LoxValue) IsTruthy() bool {
+	switch v.Type() {
+	case LoxTypeBoolean:
+		b, ok := v.raw.(bool)
+		return ok && b
+	case LoxTypeNumber, LoxTypeString:
+		return true
+	default:
+		return false
+	}
+}
+
+func (v *LoxValue) IsNil() bool {
+	return v.Type() == LoxTypeNil
+}
+
+func (v *LoxValue) IsUndefined() bool {
+	return v.Type() == LoxTypeUndefined
+}
+
+func (v *LoxValue) Equals(other *LoxValue) bool {
+	return AreEqual(v, other)
+}
+
 func Value(v any) *LoxValue {
 	return &LoxValue{v}
 }
+
+func AreEqual(a, b *LoxValue) bool {
+	typeA := a.Type()
+	typeB := b.Type()
+
+	if typeA != typeB {
+		return false
+	}
+
+	return a.raw == b.raw
+}
+
+func AreEqualValue(a, b *LoxValue) *LoxValue {
+	return Value(AreEqual(a, b))
+}