UnflavoredMeson/monkey
1
0
Fork 0
Code Issues Pull Requests Actions Packages Projects Releases Wiki Activity

optimizations
Some checks failed
Build / build (push) Successful in 10m29s
Details
Publish Image / publish (push) Failing after 31s
Details
Test / build (push) Failing after 6m34s
Details

Browse Source
This commit is contained in:
Chuck Smith
2024-04-02 14:08:08 -04:00
parent 4c9ec5aaaa
commit 07fd82b261
23 changed files with 296 additions and 265 deletions
Download Patch File Download Diff File Expand all files Collapse all files

104
internal/evaluator/evaluator.go
View File

@@ -26,37 +26,37 @@ func isError(obj object.Object) bool {
return false
}
func Eval(node ast.Node, ctx context.Context, env *object.Environment) object.Object {
func Eval(ctx context.Context, node ast.Node, env *object.Environment) object.Object {
switch node := node.(type) {
// Statements
case *ast.Program:
return evalProgram(node, ctx, env)
return evalProgram(ctx, node, env)
case *ast.ExpressionStatement:
return Eval(node.Expression, ctx, env)
return Eval(ctx, node.Expression, env)
case *ast.BlockStatement:
return evalBlockStatements(node, ctx, env)
return evalBlockStatements(ctx, node, env)
case *ast.IfExpression:
return evalIfExpression(node, ctx, env)
return evalIfExpression(ctx, node, env)
case *ast.WhileExpression:
return evalWhileExpression(node, ctx, env)
return evalWhileExpression(ctx, node, env)
case *ast.ImportExpression:
return evalImportExpression(node, ctx, env)
return evalImportExpression(ctx, node, env)
case *ast.ReturnStatement:
val := Eval(node.ReturnValue, ctx, env)
val := Eval(ctx, node.ReturnValue, env)
if isError(val) {
return val
}
return object.ReturnValue{Value: val}
case *ast.BindExpression:
value := Eval(node.Value, ctx, env)
value := Eval(ctx, node.Value, env)
if isError(value) {
return value
}
@@ -73,12 +73,12 @@ func Eval(node ast.Node, ctx context.Context, env *object.Environment) object.Ob
return newError("expected identifier on left got=%T", node.Left)
case *ast.AssignmentExpression:
left := Eval(node.Left, ctx, env)
left := Eval(ctx, node.Left, env)
if isError(left) {
return left
}
value := Eval(node.Value, ctx, env)
value := Eval(ctx, node.Value, env)
if isError(value) {
return value
}
@@ -86,13 +86,13 @@ func Eval(node ast.Node, ctx context.Context, env *object.Environment) object.Ob
if ident, ok := node.Left.(*ast.Identifier); ok {
env.Set(ident.Value, value)
} else if ie, ok := node.Left.(*ast.IndexExpression); ok {
obj := Eval(ie.Left, ctx, env)
obj := Eval(ctx, ie.Left, env)
if isError(obj) {
return obj
}
if array, ok := obj.(*object.Array); ok {
index := Eval(ie.Index, ctx, env)
index := Eval(ctx, ie.Index, env)
if isError(index) {
return index
}
@@ -102,7 +102,7 @@ func Eval(node ast.Node, ctx context.Context, env *object.Environment) object.Ob
return newError("cannot index array with %#v", index)
}
} else if hash, ok := obj.(*object.Hash); ok {
key := Eval(ie.Index, ctx, env)
key := Eval(ctx, ie.Index, env)
if isError(key) {
return key
}
@@ -140,29 +140,29 @@ func Eval(node ast.Node, ctx context.Context, env *object.Environment) object.Ob
return NULL
case *ast.PrefixExpression:
right := Eval(node.Right, ctx, env)
right := Eval(ctx, node.Right, env)
if isError(right) {
return right
}
return evalPrefixExpression(node.Operator, right)
case *ast.InfixExpression:
left := Eval(node.Left, ctx, env)
left := Eval(ctx, node.Left, env)
if isError(left) {
return left
}
right := Eval(node.Right, ctx, env)
right := Eval(ctx, node.Right, env)
if isError(right) {
return right
}
return evalInfixExpression(node.Operator, left, right)
case *ast.CallExpression:
function := Eval(node.Function, ctx, env)
function := Eval(ctx, node.Function, env)
if isError(function) {
return function
}
args := evalExpressions(node.Arguments, ctx, env)
args := evalExpressions(ctx, node.Arguments, env)
if len(args) == 1 && isError(args[0]) {
return args[0]
}
@@ -173,39 +173,39 @@ func Eval(node ast.Node, ctx context.Context, env *object.Environment) object.Ob
return object.String{Value: node.Value}
case *ast.ArrayLiteral:
elements := evalExpressions(node.Elements, ctx, env)
elements := evalExpressions(ctx, node.Elements, env)
if len(elements) == 1 && isError(elements[0]) {
return elements[0]
}
return &object.Array{Elements: elements}
case *ast.IndexExpression:
left := Eval(node.Left, ctx, env)
left := Eval(ctx, node.Left, env)
if isError(left) {
return left
}
index := Eval(node.Index, ctx, env)
index := Eval(ctx, node.Index, env)
if isError(index) {
return index
}
return evalIndexExpression(left, index)
case *ast.HashLiteral:
return evalHashLiteral(node, ctx, env)
return evalHashLiteral(ctx, node, env)
}
return nil
}
func evalImportExpression(ie *ast.ImportExpression, ctx context.Context, env *object.Environment) object.Object {
name := Eval(ie.Name, ctx, env)
func evalImportExpression(ctx context.Context, ie *ast.ImportExpression, env *object.Environment) object.Object {
name := Eval(ctx, ie.Name, env)
if isError(name) {
return name
}
if s, ok := name.(object.String); ok {
attrs := EvalModule(ctx, s.Value)
attrs := Module(ctx, s.Value)
if isError(attrs) {
return attrs
}
@@ -214,17 +214,17 @@ func evalImportExpression(ie *ast.ImportExpression, ctx context.Context, env *ob
return newError("ImportError: invalid import path '%s'", name)
}
func evalWhileExpression(we *ast.WhileExpression, ctx context.Context, env *object.Environment) object.Object {
func evalWhileExpression(ctx context.Context, we *ast.WhileExpression, env *object.Environment) object.Object {
var result object.Object
for {
condition := Eval(we.Condition, ctx, env)
condition := Eval(ctx, we.Condition, env)
if isError(condition) {
return condition
}
if isTruthy(condition) {
result = Eval(we.Consequence, ctx, env)
result = Eval(ctx, we.Consequence, env)
} else {
break
}
@@ -237,11 +237,11 @@ func evalWhileExpression(we *ast.WhileExpression, ctx context.Context, env *obje
return NULL
}
func evalProgram(program *ast.Program, ctx context.Context, env *object.Environment) object.Object {
func evalProgram(ctx context.Context, program *ast.Program, env *object.Environment) object.Object {
var result object.Object
for _, statement := range program.Statements {
result = Eval(statement, ctx, env)
result = Eval(ctx, statement, env)
switch result := result.(type) {
case object.ReturnValue:
@@ -255,11 +255,11 @@ func evalProgram(program *ast.Program, ctx context.Context, env *object.Environm
return result
}
func evalBlockStatements(block *ast.BlockStatement, ctx context.Context, env *object.Environment) object.Object {
func evalBlockStatements(ctx context.Context, block *ast.BlockStatement, env *object.Environment) object.Object {
var result object.Object
for _, statement := range block.Statements {
result = Eval(statement, ctx, env)
result = Eval(ctx, statement, env)
if result != nil {
rt := result.Type()
@@ -385,17 +385,17 @@ func evalInfixExpression(operator string, left, right object.Object) object.Obje
return object.String{Value: strings.Repeat(rightVal, int(leftVal))}
case operator == "==":
return nativeBoolToBooleanObject(left.(object.Comparable).Compare(right) == 0)
return nativeBoolToBooleanObject(left.Compare(right) == 0)
case operator == "!=":
return nativeBoolToBooleanObject(left.(object.Comparable).Compare(right) != 0)
return nativeBoolToBooleanObject(left.Compare(right) != 0)
case operator == "<=":
return nativeBoolToBooleanObject(left.(object.Comparable).Compare(right) < 1)
return nativeBoolToBooleanObject(left.Compare(right) < 1)
case operator == ">=":
return nativeBoolToBooleanObject(left.(object.Comparable).Compare(right) > -1)
return nativeBoolToBooleanObject(left.Compare(right) > -1)
case operator == "<":
return nativeBoolToBooleanObject(left.(object.Comparable).Compare(right) == -1)
return nativeBoolToBooleanObject(left.Compare(right) == -1)
case operator == ">":
return nativeBoolToBooleanObject(left.(object.Comparable).Compare(right) == 1)
return nativeBoolToBooleanObject(left.Compare(right) == 1)
case left.Type() == object.BooleanType && right.Type() == object.BooleanType:
return evalBooleanInfixExpression(operator, left, right)
@@ -477,16 +477,16 @@ func evalIntegerInfixExpression(operator string, left, right object.Object) obje
}
}
func evalIfExpression(ie *ast.IfExpression, ctx context.Context, env *object.Environment) object.Object {
condition := Eval(ie.Condition, ctx, env)
func evalIfExpression(ctx context.Context, ie *ast.IfExpression, env *object.Environment) object.Object {
condition := Eval(ctx, ie.Condition, env)
if isError(condition) {
return condition
}
if isTruthy(condition) {
return Eval(ie.Consequence, ctx, env)
return Eval(ctx, ie.Consequence, env)
} else if ie.Alternative != nil {
return Eval(ie.Alternative, ctx, env)
return Eval(ctx, ie.Alternative, env)
} else {
return NULL
}
@@ -509,8 +509,8 @@ func newError(format string, a ...interface{}) object.Error {
return object.Error{Message: fmt.Sprintf(format, a...)}
}
// EvalModule evaluates the named module and returns a object.Module objec
func EvalModule(ctx context.Context, name string) object.Object {
// Module evaluates the named module and returns a object.Module object
func Module(ctx context.Context, name string) object.Object {
filename := utils.FindModule(name)
b, err := os.ReadFile(filename)
@@ -527,7 +527,7 @@ func EvalModule(ctx context.Context, name string) object.Object {
}
env := object.NewEnvironment()
Eval(module, ctx, env)
Eval(ctx, module, env)
return env.ExportedHash()
}
@@ -544,11 +544,11 @@ func evalIdentifier(node *ast.Identifier, env *object.Environment) object.Object
return newError("identifier not found: " + node.Value)
}
func evalExpressions(exps []ast.Expression, ctx context.Context, env *object.Environment) []object.Object {
func evalExpressions(ctx context.Context, exps []ast.Expression, env *object.Environment) []object.Object {
var result []object.Object
for _, e := range exps {
evaluated := Eval(e, ctx, env)
evaluated := Eval(ctx, e, env)
if isError(evaluated) {
return []object.Object{evaluated}
}
@@ -563,7 +563,7 @@ func applyFunction(ctx context.Context, fn object.Object, args []object.Object)
case object.Function:
extendedEnv := extendFunctionEnv(fn, args)
evaluated := Eval(fn.Body, ctx, extendedEnv)
evaluated := Eval(ctx, fn.Body, extendedEnv)
return unwrapReturnValue(evaluated)
case object.Builtin:
@@ -656,11 +656,11 @@ func evalArrayIndexExpression(array, index object.Object) object.Object {
return arrayObject.Elements[idx]
}
func evalHashLiteral(node *ast.HashLiteral, ctx context.Context, env *object.Environment) object.Object {
func evalHashLiteral(ctx context.Context, node *ast.HashLiteral, env *object.Environment) object.Object {
pairs := make(map[object.HashKey]object.HashPair)
for keyNode, valueNode := range node.Pairs {
key := Eval(keyNode, ctx, env)
key := Eval(ctx, keyNode, env)
if isError(key) {
return key
}
@@ -670,7 +670,7 @@ func evalHashLiteral(node *ast.HashLiteral, ctx context.Context, env *object.Env
return newError("unusable as hash key: %s", key.Type())
}
value := Eval(valueNode, ctx, env)
value := Eval(ctx, valueNode, env)
if isError(value) {
return value
}

2
internal/evaluator/evaluator_test.go
View File

@@ -800,7 +800,7 @@ func testEval(input string) object.Object {
program := p.ParseProgram()
env := object.NewEnvironment()
return Eval(program, context.New(), env)
return Eval(context.New(), program, env)
}
func testIntegerObject(t *testing.T, obj object.Object, expected int64) bool {