slime/eval.c

/* Ast_Node* apply_to_lambda () {} */

/* Ast_Node* apply_to_built_in (Ast_Node* function, Ast_Node* arguments) { */

/* } */

Ast_Node* eval_expr(Ast_Node* node, Environment* env);

void eval_operands(Ast_Node* operands, Environment* env) {
    while (1) {
        if (operands->type == Ast_Node_Type_Cons_Cell) {
            operands->value.cons_cell->first = eval_expr(operands->value.cons_cell->first, env);
            operands = operands->value.cons_cell->rest;
        } else {
            break;
        }
    }
}

Ast_Node* eval_expr(Ast_Node* node, Environment* env) {
    Ast_Node* ret = new(Ast_Node);
    switch (node->type) {
    case Ast_Node_Type_Nil:
        ret->type = Ast_Node_Type_Nil;
        return ret;
    case Ast_Node_Type_Symbol:
        return lookup_symbol(node->value.symbol, env);
    case Ast_Node_Type_Number:
    case Ast_Node_Type_String:
        return node;

    case Ast_Node_Type_Cons_Cell: {
        Ast_Node* operator = eval_expr(node->value.cons_cell->first, env);
        Ast_Node* operands = node->value.cons_cell->rest;

        // check for built ins functions
        if (operator->type == Ast_Node_Type_Built_In_Function) {
            char* operator_name = operator->value.built_in_function->identifier;
            if (string_equal("quote", operator_name)) {
                return node->value.cons_cell->rest;
            } else if (string_equal("+", operator_name)) {
                eval_operands(operands, env);
                return built_in_add(operands);
            } else if (string_equal("-", operator_name)) {
                eval_operands(operands, env);
                return built_in_substract(operands);
            } else {
                log_message(Log_Level_Critical, "The operator is not yet implemented\n");
            }
        }

        // assume it's lambda function and evaluate the operands in
        // place
        eval_operands(operands, env);
    }

    default:
        return 0;
    }
}