hussar-lang/hussar

package evaluator

import (
    "fmt"
    "os"
    "strconv"

    "github.com/hussar-lang/hussar/ast"
    "github.com/hussar-lang/hussar/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, env)

    case *ast.ExpressionStatement:
        return Eval(node.Expression, env)

    case *ast.BlockStatement:
        return evalBlockStatement(node, env)

    case *ast.ReturnStatement:
        val := Eval(node.ReturnValue, env)
        if isError(val) {
            return val
        }
        return &object.ReturnValue{Value: val}

    case *ast.LetStatement:
        val := Eval(node.Value, env)
        if isError(val) {
            return val
        }
        env.Set(node.Name.Value, val)

    // Expressions
    case *ast.IntegerLiteral:
        return &object.Integer{Value: node.Value}

    case *ast.StringLiteral:
        return &object.String{Value: node.Value}

    case *ast.Boolean:
        return nativeBoolToBooleanObject(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.IfExpression:
        return evalIfExpression(node, env)

    case *ast.WhileExpression:
        return evalWhileExpression(node, env)

    case *ast.Identifier:
        return evalIdentifier(node, env)

    case *ast.FunctionLiteral:
        params := node.Parameters
        body := node.Body
        return &object.Function{Parameters: params, Env: env, Body: body}

    case *ast.CallExpression:
        function := Eval(node.Function, env)
        if isError(function) {
            return function
        }
        args := evalExpressions(node.Arguments, env)
        if len(args) == 1 && isError(args[0]) {
            return args[0]
        }
        return applyFunction(function, args)

    case *ast.ArrayLiteral:
        elements := evalExpressions(node.Elements, env)
        if len(elements) == 1 && isError(elements[0]) {
            return elements[0]
        }
        return &object.Array{Elements: elements}

    case *ast.ExitLiteral:
        return evalExitLiteral(node, env)
    }
    return nil
}

func evalProgram(program *ast.Program, env *object.Environment) object.Object {
    var result object.Object

    for _, statement := range program.Statements {
        result = Eval(statement, env)

        switch result := result.(type) {
        case *object.ReturnValue:
            return result.Value
        case *object.Error:
            return result
        }
    }

    return result
}

func evalBlockStatement(block *ast.BlockStatement, env *object.Environment) object.Object {
    var result object.Object

    for _, statement := range block.Statements {
        result = Eval(statement, env)

        if result != nil {
            rt := result.Type()
            if rt == object.RETURN_VALUE_OBJ || rt == object.ERROR_OBJ {
                return result
            }
        }
    }

    return result
}

func evalPrefixExpression(operator string, right object.Object) object.Object {
    switch operator {
    case "!":
        return evalBangOperatorExpression(right)
    case "-":
        return evalMinusPrefixOperatorExpression(right)
    default:
        return newError("error", "Unknown operator: %s%s", operator, right.Type())
    }
}

func evalInfixExpression(operator string, left object.Object, right object.Object) object.Object {
    switch {
    case left.Type() == object.INTEGER_OBJ && right.Type() == object.INTEGER_OBJ:
        return evalIntegerInfixExpression(operator, left, right)
    case operator == "==":
        return nativeBoolToBooleanObject(left == right)
    case operator == "!=":
        return nativeBoolToBooleanObject(left != right)
    case left.Type() == object.STRING_OBJ || right.Type() == object.STRING_OBJ:
        return evalStringInfixExpression(operator, left, right)
    case left.Type() != right.Type():
        return newError("error", "Type mismatch: %s %s %s", left.Type(), operator, right.Type())
    default:
        return newError("error", "Unknown operator: %s %s %s", left.Type(), operator, right.Type())
    }
}

func evalBangOperatorExpression(right object.Object) object.Object {
    switch right {
    case TRUE:
        return FALSE
    case FALSE:
        return TRUE
    case NULL:
        return TRUE
    default:
        return FALSE
    }
}

func evalMinusPrefixOperatorExpression(right object.Object) object.Object {
    if right.Type() != object.INTEGER_OBJ {
        return newError("error", "Unknown operator: -%s", right.Type())
    }

    value := right.(*object.Integer).Value
    return &object.Integer{Value: -value}
}

func evalIntegerInfixExpression(operator string, left object.Object, right object.Object) object.Object {
    leftVal := left.(*object.Integer).Value
    rightVal := right.(*object.Integer).Value

    switch operator {
    case "+":
        return &object.Integer{Value: leftVal + rightVal}
    case "-":
        return &object.Integer{Value: leftVal - rightVal}
    case "*":
        return &object.Integer{Value: leftVal * rightVal}
    case "/":
        if rightVal == 0 {
            return newError("error", "Cannot divide by zero (%d %s %d)", leftVal, operator, rightVal)
        }
        return &object.Integer{Value: leftVal / rightVal}
    case "<":
        return nativeBoolToBooleanObject(leftVal < rightVal)
    case ">":
        return nativeBoolToBooleanObject(leftVal > rightVal)
    case "==":
        return nativeBoolToBooleanObject(leftVal == rightVal)
    case "!=":
        return nativeBoolToBooleanObject(leftVal != rightVal)
    default:
        return newError("error", "Unknown operator: %s %s %s", left.Type(), operator, right.Type())
    }
}

func evalStringInfixExpression(operator string, left object.Object, right object.Object) object.Object {
    if operator != "+" {
        return newError("error", "Unknown operator: %s %s %s", left.Type(), operator, right.Type())
    }

    left = getStringValue(left)
    if isError(left) {
        return left
    }
    leftVal := left.(*object.String).Value

    right = getStringValue(right)
    if isError(right) {
        return right
    }
    rightVal := right.(*object.String).Value

    return &object.String{Value: leftVal + rightVal}
}

func evalIfExpression(ie *ast.IfExpression, env *object.Environment) object.Object {
    condition := Eval(ie.Condition, env)

    if isError(condition) {
        return condition
    }

    if isTruthy(condition) {
        return Eval(ie.Consequence, env)
    } else if ie.Alternative != nil {
        return Eval(ie.Alternative, env)
    } else {
        return NULL
    }
}

// TODO: this is quite untested. To be verified and tested with bindings and functions
func evalWhileExpression(we *ast.WhileExpression, env *object.Environment) object.Object {
    condition := Eval(we.Condition, env)
    if isError(condition) {
        return condition
    }

    var result object.Object

    for {
        if isTruthy(Eval(we.Condition, env)) {
            e := Eval(we.Body, env)
            if isError(e) {
                return e
            }
            if ret, ok := e.(*object.ReturnValue); ok {
                return ret
            }
            result = e
        } else {
            break
        }
    }

    return NULL
    return unwrapReturnValue(result) //temp unused to test
}

func evalExitLiteral(node *ast.ExitLiteral, env *object.Environment) object.Object {
    // TODO: make the exit code code work in a less hacky way
    //code, err := strconv.Atoi(node.ExitCode.String())
    //if err == nil {
    //    os.Exit(code)
    //}

    exp := Eval(node.ExitCode, env)

    code, err := strconv.Atoi(exp.Inspect())
    if err == nil {
        os.Exit(code)
    }

    boolCode, err := strconv.ParseBool(exp.Inspect())
    if err == nil {
        if boolCode {
            os.Exit(0)
        } else {
            os.Exit(1)
        }
    }

    return newError("error", "Invalid argument given as exit code: %q\n%s", node.ExitCode, err.Error())
}

func evalIdentifier(node *ast.Identifier, env *object.Environment) object.Object {
    if val, ok := env.Get(node.Value); ok {
        return val
    }

    if builtin, ok := builtins[node.Value]; ok {
        return builtin
    }

    return newError("warn", "Identifier not found: %s", node.Value)
}

func evalExpressions(exps []ast.Expression, env *object.Environment) []object.Object {
    var result []object.Object

    for _, e := range exps {
        evaluated := Eval(e, env)
        if isError(evaluated) {
            return []object.Object{evaluated}
        }
        result = append(result, evaluated)
    }

    return result
}

func applyFunction(fn object.Object, args []object.Object) object.Object {
    switch fn := fn.(type) {

    case *object.Function:
        extendedEnv := extendFunctionEnv(fn, args)
        evaluated := Eval(fn.Body, extendedEnv)
        return unwrapReturnValue(evaluated)

    case *object.Builtin:
        return fn.Fn(args...)

    default:
        return newError("error", "Not a function: %s", fn.Type())
    }
}

func extendFunctionEnv(fn *object.Function, args []object.Object) *object.Environment {
    env := object.NewEnclosedEnvironment(fn.Env)

    for paramIdx, param := range fn.Parameters {
        env.Set(param.Value, args[paramIdx])
    }

    return env
}

func getStringValue(obj object.Object) object.Object {
    switch obj.Type() {
    case object.STRING_OBJ:
        str, ok := obj.(*object.String)
        if !ok {
            return newError("error", "Unable to convert to String: %T (%+v)", obj, obj)
        }
        return str
    case object.INTEGER_OBJ:
        val, ok := obj.(*object.Integer)
        if !ok {
            return newError("error", "Unable to convert to String: %T (%+v)", obj, obj)
        }
        str := strconv.FormatInt(val.Value, 10)
        return &object.String{Value: str}
    default:
        return newError("error", "Unable to convert to String: %T (%+v)", obj, obj)
    }
}

func unwrapReturnValue(obj object.Object) object.Object {
    if returnValue, ok := obj.(*object.ReturnValue); ok {
        return returnValue.Value
    }

    return obj
}

func isTruthy(obj object.Object) bool {
    // modify to possibly change conditionals to prefer falsy over truthy
    switch obj {
    case NULL:
        return false
    case TRUE:
        return true
    case FALSE:
        return false
    default:
        return true
    }
}

func nativeBoolToBooleanObject(input bool) *object.Boolean {
    if input {
        return TRUE
    }

    return FALSE
}

func isError(obj object.Object) bool {
    if obj != nil {
        return obj.Type() == object.ERROR_OBJ
    }
    return false
}

func newError(severity string, format string, a ...interface{}) *object.Error {
    return &object.Error{Severity: severity, Message: fmt.Sprintf(format, a...)}
}