Add all the files from the interpreter repo
Signed-off-by: jmug <u.g.a.mariano@gmail.com>
This commit is contained in:
parent
230fe61b12
commit
0acd1d41e8
34 changed files with 3784 additions and 0 deletions
358
pkg/evaluator/evaluator.go
Normal file
358
pkg/evaluator/evaluator.go
Normal file
|
|
@ -0,0 +1,358 @@
|
|||
package evaluator
|
||||
|
||||
import (
|
||||
"fmt"
|
||||
|
||||
"code.jmug.me/jmug/interpreter-in-go/pkg/ast"
|
||||
"code.jmug.me/jmug/interpreter-in-go/pkg/object"
|
||||
)
|
||||
|
||||
var (
|
||||
_NULL = &object.Null{}
|
||||
_TRUE = &object.Boolean{Value: true}
|
||||
_FALSE = &object.Boolean{Value: false}
|
||||
)
|
||||
|
||||
func Eval(node ast.Node, env *object.Environment) object.Object {
|
||||
switch node := node.(type) {
|
||||
// Statements.
|
||||
case *ast.Program:
|
||||
return evalProgram(node.Statements, env)
|
||||
case *ast.ExpressionStatement:
|
||||
return Eval(node.Expression, env)
|
||||
// Expressions.
|
||||
case *ast.IntegerLiteral:
|
||||
return &object.Integer{Value: node.Value}
|
||||
case *ast.Boolean:
|
||||
return nativeBoolToBooleanObject(node.Value)
|
||||
case *ast.StringLiteral:
|
||||
return &object.String{Value: node.Value}
|
||||
case *ast.PrefixExpression:
|
||||
right := Eval(node.Right, env)
|
||||
if isError(right) {
|
||||
return right
|
||||
}
|
||||
return evalPrefixExpression(node.Operator, right)
|
||||
case *ast.InfixExpression:
|
||||
left := Eval(node.Left, env)
|
||||
if isError(left) {
|
||||
return left
|
||||
}
|
||||
right := Eval(node.Right, env)
|
||||
if isError(right) {
|
||||
return right
|
||||
}
|
||||
return evalInfixExpression(node.Operator, left, right)
|
||||
case *ast.BlockStatement:
|
||||
return evalBlockStatement(node.Statements, env)
|
||||
case *ast.IfExpression:
|
||||
return evalIfExpression(node, env)
|
||||
case *ast.ReturnStatement:
|
||||
ret := Eval(node.ReturnValue, env)
|
||||
if isError(ret) {
|
||||
return ret
|
||||
}
|
||||
return &object.ReturnValue{Value: ret}
|
||||
case *ast.LetStatement:
|
||||
val := Eval(node.Value, env)
|
||||
if isError(val) {
|
||||
return val
|
||||
}
|
||||
env.Set(node.Name.Value, val)
|
||||
case *ast.Identifier:
|
||||
return evalIdentifier(node, env)
|
||||
case *ast.FunctionLiteral:
|
||||
params := node.Parameters
|
||||
body := node.Body
|
||||
return &object.Function{Parameters: params, Body: body, Env: env}
|
||||
case *ast.CallExpression:
|
||||
fn := Eval(node.Function, env)
|
||||
if isError(fn) {
|
||||
return fn
|
||||
}
|
||||
args := evalExpressions(node.Arguments, env)
|
||||
if len(args) == 1 && isError(args[0]) {
|
||||
return args[0]
|
||||
}
|
||||
return applyFunction(fn, args)
|
||||
case *ast.ArrayLiteral:
|
||||
els := evalExpressions(node.Elements, env)
|
||||
if len(els) == 1 && isError(els[0]) {
|
||||
return els[0]
|
||||
}
|
||||
return &object.Array{Elements: els}
|
||||
case *ast.IndexExpression:
|
||||
left := Eval(node.Left, env)
|
||||
if isError(left) {
|
||||
return left
|
||||
}
|
||||
index := Eval(node.Index, env)
|
||||
if isError(index) {
|
||||
return index
|
||||
}
|
||||
return evalIndexExpression(left, index)
|
||||
case *ast.HashLiteral:
|
||||
return evalHashLiteral(node, env)
|
||||
}
|
||||
return nil
|
||||
}
|
||||
|
||||
func evalProgram(stmts []ast.Statement, env *object.Environment) object.Object {
|
||||
var res object.Object
|
||||
for _, stmt := range stmts {
|
||||
res = Eval(stmt, env)
|
||||
switch res := res.(type) {
|
||||
case *object.ReturnValue:
|
||||
return res.Value
|
||||
case *object.Error:
|
||||
return res
|
||||
}
|
||||
}
|
||||
return res
|
||||
}
|
||||
|
||||
func evalBlockStatement(stmts []ast.Statement, env *object.Environment) object.Object {
|
||||
var res object.Object
|
||||
for _, stmt := range stmts {
|
||||
res = Eval(stmt, env)
|
||||
if res != nil && (res.Type() == object.RETURN_VALUE_OBJ || res.Type() == object.ERROR_OBJ) {
|
||||
return res
|
||||
}
|
||||
}
|
||||
return res
|
||||
}
|
||||
|
||||
func evalPrefixExpression(op string, right object.Object) object.Object {
|
||||
switch op {
|
||||
case "!":
|
||||
return evalBangOperatorExpression(right)
|
||||
case "-":
|
||||
return evalMinusPrefixOperatorExpression(right)
|
||||
default:
|
||||
return newError("unknown operator: %s%s", op, right.Type())
|
||||
}
|
||||
}
|
||||
|
||||
func evalBangOperatorExpression(obj object.Object) object.Object {
|
||||
switch obj {
|
||||
case _TRUE:
|
||||
return _FALSE
|
||||
case _FALSE:
|
||||
return _TRUE
|
||||
case _NULL:
|
||||
return _TRUE
|
||||
default:
|
||||
return _FALSE
|
||||
}
|
||||
}
|
||||
|
||||
func evalMinusPrefixOperatorExpression(obj object.Object) object.Object {
|
||||
if obj.Type() != object.INTEGER_OBJ {
|
||||
return newError("unknown operator: -%s", obj.Type())
|
||||
}
|
||||
val := obj.(*object.Integer).Value
|
||||
return &object.Integer{Value: -val}
|
||||
}
|
||||
|
||||
func evalInfixExpression(op string, left, right object.Object) object.Object {
|
||||
switch {
|
||||
case left.Type() == object.INTEGER_OBJ && right.Type() == object.INTEGER_OBJ:
|
||||
return evalIntegerInfixExpression(op, left, right)
|
||||
case left.Type() == object.STRING_OBJ && right.Type() == object.STRING_OBJ:
|
||||
return evalStringInfixExpression(op, left, right)
|
||||
case op == "==":
|
||||
return nativeBoolToBooleanObject(left == right)
|
||||
case op == "!=":
|
||||
return nativeBoolToBooleanObject(left != right)
|
||||
case left.Type() != right.Type():
|
||||
return newError("type mismatch: %s %s %s",
|
||||
left.Type(), op, right.Type())
|
||||
default:
|
||||
return newError("unknown operator: %s %s %s",
|
||||
left.Type(), op, right.Type())
|
||||
}
|
||||
}
|
||||
|
||||
func evalIntegerInfixExpression(op string, left, right object.Object) object.Object {
|
||||
l := left.(*object.Integer).Value
|
||||
r := right.(*object.Integer).Value
|
||||
switch op {
|
||||
case "+":
|
||||
return &object.Integer{Value: l + r}
|
||||
case "-":
|
||||
return &object.Integer{Value: l - r}
|
||||
case "*":
|
||||
return &object.Integer{Value: l * r}
|
||||
case "/":
|
||||
return &object.Integer{Value: l / r}
|
||||
case "<":
|
||||
return nativeBoolToBooleanObject(l < r)
|
||||
case ">":
|
||||
return nativeBoolToBooleanObject(l > r)
|
||||
case "==":
|
||||
return nativeBoolToBooleanObject(l == r)
|
||||
case "!=":
|
||||
return nativeBoolToBooleanObject(l != r)
|
||||
default:
|
||||
return newError("unknown operator: %s %s %s",
|
||||
left.Type(), op, right.Type())
|
||||
}
|
||||
}
|
||||
|
||||
func evalStringInfixExpression(op string, left, right object.Object) object.Object {
|
||||
if op != "+" {
|
||||
return newError(
|
||||
"unknown operator: %s %s %s",
|
||||
left.Type(), op, right.Type(),
|
||||
)
|
||||
}
|
||||
l := left.(*object.String).Value
|
||||
r := right.(*object.String).Value
|
||||
return &object.String{Value: l + r}
|
||||
}
|
||||
|
||||
func evalIfExpression(ifExp *ast.IfExpression, env *object.Environment) object.Object {
|
||||
cond := Eval(ifExp.Condition, env)
|
||||
if isError(cond) {
|
||||
return cond
|
||||
}
|
||||
if isTruthy(cond) {
|
||||
return Eval(ifExp.Consequence, env)
|
||||
} else if ifExp.Alternative != nil {
|
||||
return Eval(ifExp.Alternative, env)
|
||||
}
|
||||
return _NULL
|
||||
}
|
||||
|
||||
func evalIdentifier(exp *ast.Identifier, env *object.Environment) object.Object {
|
||||
if val, ok := env.Get(exp.Value); ok {
|
||||
return val
|
||||
}
|
||||
if val, ok := builtins[exp.Value]; ok {
|
||||
return val
|
||||
}
|
||||
return newError("identifier not found: " + exp.Value)
|
||||
}
|
||||
|
||||
func evalExpressions(
|
||||
exps []ast.Expression,
|
||||
env *object.Environment,
|
||||
) []object.Object {
|
||||
var res []object.Object
|
||||
for _, exp := range exps {
|
||||
ev := Eval(exp, env)
|
||||
if isError(ev) {
|
||||
return []object.Object{ev}
|
||||
}
|
||||
res = append(res, ev)
|
||||
}
|
||||
return res
|
||||
}
|
||||
|
||||
func evalIndexExpression(left, index object.Object) object.Object {
|
||||
switch {
|
||||
case left.Type() == object.ARRAY_OBJ && index.Type() == object.INTEGER_OBJ:
|
||||
return evalArrayIndexExpression(left, index)
|
||||
case left.Type() == object.HASH_OBJ:
|
||||
return evalHashIndexExpression(left, index)
|
||||
default:
|
||||
return newError("index operator not supported: %s", left.Type())
|
||||
}
|
||||
}
|
||||
|
||||
func evalArrayIndexExpression(arrayObj, indexObj object.Object) object.Object {
|
||||
array := arrayObj.(*object.Array).Elements
|
||||
index := indexObj.(*object.Integer).Value
|
||||
if index < 0 || index >= int64(len(array)) {
|
||||
return _NULL
|
||||
}
|
||||
return array[index]
|
||||
}
|
||||
|
||||
func evalHashIndexExpression(hashObj, index object.Object) object.Object {
|
||||
hash := hashObj.(*object.Hash)
|
||||
hashable, okHash := index.(object.Hashable)
|
||||
if !okHash {
|
||||
return newError("unusable as hash key: %s", index.Type())
|
||||
}
|
||||
pair, okPair := hash.Pairs[hashable.HashKey()]
|
||||
if !okPair {
|
||||
return _NULL
|
||||
}
|
||||
return pair.Value
|
||||
}
|
||||
|
||||
func evalHashLiteral(hash *ast.HashLiteral, env *object.Environment) object.Object {
|
||||
pairs := map[object.HashKey]object.HashPair{}
|
||||
for ke, ve := range hash.Pairs {
|
||||
k := Eval(ke, env)
|
||||
if isError(k) {
|
||||
return k
|
||||
}
|
||||
hashable, ok := k.(object.Hashable)
|
||||
if !ok {
|
||||
return newError("unusable as hash key: %s", k.Type())
|
||||
}
|
||||
v := Eval(ve, env)
|
||||
if isError(v) {
|
||||
return v
|
||||
}
|
||||
hashKey := hashable.HashKey()
|
||||
pairs[hashKey] = object.HashPair{Key: k, Value: v}
|
||||
}
|
||||
return &object.Hash{Pairs: pairs}
|
||||
}
|
||||
|
||||
func applyFunction(fnObj object.Object, args []object.Object) object.Object {
|
||||
switch fn := fnObj.(type) {
|
||||
case *object.Function:
|
||||
env := extendFunctionEnv(fn, args)
|
||||
ret := Eval(fn.Body, env)
|
||||
return unwrapReturnValue(ret)
|
||||
case *object.Builtin:
|
||||
return fn.Fn(args...)
|
||||
}
|
||||
return newError("not a function: %s", fnObj.Type())
|
||||
}
|
||||
|
||||
func extendFunctionEnv(fn *object.Function, args []object.Object) *object.Environment {
|
||||
env := object.NewEnclosedEnvironment(fn.Env)
|
||||
for pi, param := range fn.Parameters {
|
||||
env.Set(param.Value, args[pi])
|
||||
}
|
||||
return env
|
||||
}
|
||||
|
||||
func unwrapReturnValue(obj object.Object) object.Object {
|
||||
if ret, ok := obj.(*object.ReturnValue); ok {
|
||||
return ret.Value
|
||||
}
|
||||
return obj
|
||||
}
|
||||
|
||||
func isTruthy(obj object.Object) bool {
|
||||
switch obj {
|
||||
case _TRUE:
|
||||
return true
|
||||
case _FALSE:
|
||||
return false
|
||||
case _NULL:
|
||||
return false
|
||||
}
|
||||
return true
|
||||
}
|
||||
|
||||
func nativeBoolToBooleanObject(b bool) object.Object {
|
||||
if b {
|
||||
return _TRUE
|
||||
}
|
||||
return _FALSE
|
||||
}
|
||||
|
||||
func newError(format string, a ...any) *object.Error {
|
||||
return &object.Error{Message: fmt.Sprintf(format, a...)}
|
||||
}
|
||||
|
||||
func isError(obj object.Object) bool {
|
||||
return obj != nil && obj.Type() == object.ERROR_OBJ
|
||||
}
|
||||
Loading…
Add table
Add a link
Reference in a new issue