Lexeme * evaluate(Lexeme * tree, Lexeme * env) {
char * type = getType(tree);
//fprintf(stdout, " >> "); printOut(tree);
if (is_a_primary(type)) {
return tree;
}
else if (type == CLOSURE) {
// If this is a new closure, link it to its defining scope (this one).
if (get_closure_environment(tree) == NULL) {
tree = set_closure_environment(tree, env);
}
return tree;
}
else if (type == IDENTIFIER) {
return look_up(env, tree);
}
else if (type == CALL) {
// Function calls are evaluated by the function evaluator module.
return evaluate_function_call(tree, env);
}
else if (type == BUILT_IN) {
// Built-ins are executed directly by the built-ins module.
return execute(tree, env);
}
else if (type == BINDING) {
return evaluate_binding(tree, env);
}
else if (type == REBINDING) {
return evaluate_rebinding(tree, env);
}
else if (type == IF_CLAUSE) {
return evaluate_if_control(tree, env);
}
else if (type == WHILE_LOOP) {
return evaluate_while_control(tree, env);
}
//else if (type == FOR_LOOP) {
// return evaluate_for_control(tree, env);
//}
else if (type == EXPRESSION_LIST) {
return evaluate_expression_list(tree, env);
}
else {
fprintf(stderr, "Evaluation error: I don't know what to do with type <%s>.\n", type);
exit(-1);
}
}
void
_interpreter::step(
__in_opt bool expect_next
)
{
node_factory_ptr node_fact;
token_factory_ptr tok_fact;
TRACE_ENTRY();
SERIALIZE_CALL_RECUR(m_lock);
if(!parser::has_next_statement()) {
THROW_LUNA_INTERPRETER_EXCEPTION(LUNA_INTERPRETER_EXCEPTION_NO_NEXT_STATEMENT);
}
if(parser::get_statement().front().get_id() == parser::get_begin_statement().front().get_id()) {
parser::move_next_statement();
}
if(parser::has_next_statement()) {
node_fact = parser::get_node_factory();
if(!node_fact) {
THROW_LUNA_INTERPRETER_EXCEPTION(LUNA_INTERPRETER_EXCEPTION_FACTORY_ALLOC_FAILED);
}
tok_fact = lexer::get_token_factory();
if(!tok_fact) {
THROW_LUNA_INTERPRETER_EXCEPTION(LUNA_INTERPRETER_EXCEPTION_FACTORY_ALLOC_FAILED);
}
node &stmt_nd = node_fact->get_node(parser::get_statement().front());
token &stmt_tok = tok_fact->get_token(stmt_nd.get_token_id());
if(!stmt_nd.get_child_count()
|| (stmt_tok.get_type() != TOKEN_STATEMENT)) {
THROW_LUNA_INTERPRETER_EXCEPTION_MESSAGE(LUNA_INTERPRETER_EXCEPTION_EXPECTING_STATEMENT,
"%s", stmt_tok.to_string().c_str());
}
node &left_child_nd = node_fact->get_node(parser::get_statement().at(stmt_nd.get_child(0)));
token &left_child_tok = tok_fact->get_token(left_child_nd.get_token_id());
switch(left_child_tok.get_type()) {
case TOKEN_CONTROL:
evaluate_control(node_fact, tok_fact, stmt_nd, stmt_tok);
break;
case TOKEN_IDENTIFIER: {
node &right_child_nd = node_fact->get_node(parser::get_statement().at(stmt_nd.get_child(1)));
token &right_child_tok = tok_fact->get_token(right_child_nd.get_token_id());
switch(right_child_tok.get_type()) {
case TOKEN_ASSIGNMENT:
evaluate_assignment(node_fact, tok_fact, stmt_nd, stmt_tok);
break;
case TOKEN_FUNCTION_CALL:
evaluate_function_call(node_fact, tok_fact, stmt_nd, stmt_tok);
break;
default:
THROW_LUNA_INTERPRETER_EXCEPTION_MESSAGE(LUNA_INTERPRETER_EXCEPTION_EXPECTING_ASSIGNMENT,
"%s", right_child_tok.to_string().c_str());
}
} break;
case TOKEN_KEYWORD:
switch(left_child_tok.get_subtype()) {
case KEYWORD_IF:
evaluate_conditional_if(node_fact, tok_fact, stmt_nd, stmt_tok);
break;
case KEYWORD_WHILE:
evaluate_conditional_while(node_fact, tok_fact, stmt_nd, stmt_tok);
break;
case KEYWORD_PRINT:
evaluate_print(node_fact, tok_fact, stmt_nd, stmt_tok);
break;
default:
THROW_LUNA_INTERPRETER_EXCEPTION_MESSAGE(LUNA_INTERPRETER_EXCEPTION_EXPECTING_CONDITIONAL,
"%s", left_child_tok.to_string().c_str());
}
break;
default:
THROW_LUNA_INTERPRETER_EXCEPTION_MESSAGE(LUNA_INTERPRETER_EXCEPTION_EXPECTING_STATEMENT,
"%s", left_child_tok.to_string().c_str());
}
if(parser::has_next_statement()) {
parser::move_next_statement();
} else if(expect_next) {
THROW_LUNA_INTERPRETER_EXCEPTION(LUNA_INTERPRETER_EXCEPTION_EXPECTING_NEXT_STATEMENT);
}
}
TRACE_EXIT("Return Value: 0x%x", NULL);
}
