static void
show_error_stack_trace(CRB_Interpreter *inter)
{
int error_code;
CRB_Object *exception;
CRB_Value *func;
if ((error_code = setjmp(inter->current_recovery_environment.environment))
== 0) {
if (inter->current_exception.type != CRB_ASSOC_VALUE) {
crb_runtime_error(inter, NULL, 0,
EXCEPTION_IS_NOT_ASSOC_ERR,
CRB_MESSAGE_ARGUMENT_END);
}
exception = inter->current_exception.u.object;
func = CRB_search_assoc_member(exception,
EXCEPTION_MEMBER_PRINT_STACK_TRACE);
if (func == NULL) {
crb_runtime_error(inter, NULL, 0,
EXCEPTION_HAS_NO_PRINT_STACK_TRACE_METHOD_ERR,
CRB_MESSAGE_ARGUMENT_END);
}
if (func->type != CRB_CLOSURE_VALUE) {
crb_runtime_error(inter, NULL, 0,
PRINT_STACK_TRACE_IS_NOT_CLOSURE_ERR,
CRB_MESSAGE_ARGUMENT_END);
}
CRB_call_function(inter, NULL, 0, func, 0, NULL);
} else {
fprintf(stderr, "Exception occured in print_stack_trace.\n");
show_error_stack_trace(inter);
}
}
SIMCAR_Value *
get_array_element_lvalue(SIMCAR_Interpreter *inter, SIMCAR_LocalEnvironment *env,
Expression *expr)
{
SIMCAR_Value array;
SIMCAR_Value index;
eval_expression(inter, env, expr->u.index_expression.array);
eval_expression(inter, env, expr->u.index_expression.index);
index = pop_value(inter);
array = pop_value(inter);
if (array.type != SIMCAR_ARRAY_VALUE) {
crb_runtime_error(expr->line_number, INDEX_OPERAND_NOT_ARRAY_ERR,
MESSAGE_ARGUMENT_END);
}
if (index.type != SIMCAR_INT_VALUE) {
crb_runtime_error(expr->line_number, INDEX_OPERAND_NOT_INT_ERR,
MESSAGE_ARGUMENT_END);
}
if (index.u.int_value < 0
|| index.u.int_value >= array.u.object->u.array.size) {
crb_runtime_error(expr->line_number, ARRAY_INDEX_OUT_OF_BOUNDS_ERR,
INT_MESSAGE_ARGUMENT,
"size", array.u.object->u.array.size,
INT_MESSAGE_ARGUMENT, "index", index.u.int_value,
MESSAGE_ARGUMENT_END);
}
return &array.u.object->u.array.array[index.u.int_value];
}
static void
check_argument_count(int arg_count, int true_count)
{
if (arg_count < true_count) {
crb_runtime_error(0, ARGUMENT_TOO_FEW_ERR,
MESSAGE_ARGUMENT_END);
} else if (arg_count > true_count) {
crb_runtime_error(0, ARGUMENT_TOO_MANY_ERR,
MESSAGE_ARGUMENT_END);
}
}
CRB_Value
crb_nv_fgets_proc(CRB_Interpreter *interpreter,
CRB_LocalEnvironment *env,
int arg_count, CRB_Value *args)
{
CRB_Value value;
FILE *fp;
char buf[LINE_BUF_SIZE];
char *mb_buf = NULL;
int ret_len = 0;
CRB_Char *wc_str;
check_argument_count(arg_count, 1);
if (args[0].type != CRB_NATIVE_POINTER_VALUE
|| !check_native_pointer(&args[0])) {
crb_runtime_error(0, FGETS_ARGUMENT_TYPE_ERR,
MESSAGE_ARGUMENT_END);
}
fp = args[0].u.native_pointer.pointer;
while (fgets(buf, LINE_BUF_SIZE, fp)) {
int new_len;
new_len = ret_len + strlen(buf);
mb_buf = MEM_realloc(mb_buf, new_len + 1);
if (ret_len == 0) {
strcpy(mb_buf, buf);
} else {
strcat(mb_buf, buf);
}
ret_len = new_len;
if (mb_buf[ret_len-1] == '\n')
break;
}
if (ret_len > 0) {
wc_str = CRB_mbstowcs_alloc(interpreter, env, __LINE__, mb_buf);
if (wc_str == NULL) {
MEM_free(mb_buf);
crb_runtime_error(0,
BAD_MULTIBYTE_CHARACTER_ERR,
MESSAGE_ARGUMENT_END);
}
value.type = CRB_STRING_VALUE;
value.u.object = CRB_create_crowbar_string(interpreter, env, wc_str);
} else {
value.type = CRB_NULL_VALUE;
}
MEM_free(mb_buf);
return value;
}
static SIMCAR_Boolean
eval_compare_string(ExpressionType operato,
SIMCAR_Value *left, SIMCAR_Value *right, int line_number)
{
SIMCAR_Boolean result;
int cmp;
cmp = strcmp(left->u.object->u.string.string,
right->u.object->u.string.string);
if (operato == EQ_EXPRESSION) {
result = (cmp == 0);
} else if (operato == NE_EXPRESSION) {
result = (cmp != 0);
} else if (operato == GT_EXPRESSION) {
result = (cmp > 0);
} else if (operato == GE_EXPRESSION) {
result = (cmp >= 0);
} else if (operato == LT_EXPRESSION) {
result = (cmp < 0);
} else if (operato == LE_EXPRESSION) {
result = (cmp <= 0);
} else {
char *op_str = crb_get_operator_string(operato);
crb_runtime_error(line_number, BAD_OPERATOR_FOR_STRING_ERR,
STRING_MESSAGE_ARGUMENT, "operator", op_str,
MESSAGE_ARGUMENT_END);
}
return result;
}
static void
eval_function_call_expression(SIMCAR_Interpreter *inter,
SIMCAR_LocalEnvironment *env,
Expression *expr)
{
FunctionDefinition *func;
SIMCAR_LocalEnvironment *local_env;
char *identifier = expr->u.function_call_expression.identifier;
func = crb_search_function(identifier);
if (func == NULL) {
crb_runtime_error(expr->line_number, FUNCTION_NOT_FOUND_ERR,
STRING_MESSAGE_ARGUMENT, "name", identifier,
MESSAGE_ARGUMENT_END);
}
local_env = alloc_local_environment(inter);
switch (func->type) {
case CROWBAR_FUNCTION_DEFINITION:
call_crowbar_function(inter, local_env, env, expr, func);
break;
case NATIVE_FUNCTION_DEFINITION:
call_native_function(inter, local_env, env, expr,
func->u.native_f.proc);
break;
case FUNCTION_DEFINITION_TYPE_COUNT_PLUS_1:
default:
DBG_panic(("bad case..%d\n", func->type));
}
dispose_local_environment(inter);
}
static StatementResult
execute_if_statement(CRB_Interpreter *inter, CRB_LocalEnvironment *env,
Statement *statement)
{
StatementResult result;
CRB_Value cond;
result.type = NORMAL_STATEMENT_RESULT;
cond = crb_eval_expression(inter, env, statement->u.if_s.condition);
if (cond.type != CRB_BOOLEAN_VALUE) {
crb_runtime_error(statement->u.if_s.condition->line_number,
NOT_BOOLEAN_TYPE_ERR, MESSAGE_ARGUMENT_END);
}
DBG_assert(cond.type == CRB_BOOLEAN_VALUE, ("cond.type..%d", cond.type));
if (cond.u.boolean_value) {
result = crb_execute_statement_list(inter, env,
statement->u.if_s.then_block
->statement_list);
} else {
CRB_Boolean elsif_executed;
result = execute_elsif(inter, env, statement->u.if_s.elsif_list,
&elsif_executed);
if (result.type != NORMAL_STATEMENT_RESULT)
goto FUNC_END;
if (!elsif_executed && statement->u.if_s.else_block) {
result = crb_execute_statement_list(inter, env,
statement->u.if_s.else_block
->statement_list);
}
}
FUNC_END:
return result;
}
CRB_Value
new_array_sub(CRB_Interpreter *inter, CRB_LocalEnvironment *env,
int arg_count, CRB_Value *args, int arg_idx)
{
CRB_Value ret;
int size;
int i;
if (args[arg_idx].type != CRB_INT_VALUE) {
crb_runtime_error(0, NEW_ARRAY_ARGUMENT_TYPE_ERR,
MESSAGE_ARGUMENT_END);
}
size = args[arg_idx].u.int_value;
ret.type = CRB_ARRAY_VALUE;
ret.u.object = CRB_create_array(inter, env, size);
if (arg_idx == arg_count-1) {
for (i = 0; i < size; i++) {
ret.u.object->u.array.array[i].type = CRB_NULL_VALUE;
}
} else {
for (i = 0; i < size; i++) {
ret.u.object->u.array.array[i]
= new_array_sub(inter, env, arg_count, args, arg_idx+1);
}
}
return ret;
}
static void
eval_inc_dec_expression(SIMCAR_Interpreter *inter,
SIMCAR_LocalEnvironment *env, Expression *expr)
{
SIMCAR_Value *operand;
SIMCAR_Value result;
int old_value;
operand = get_lvalue(inter, env, expr->u.inc_dec.operand);
if (operand->type != SIMCAR_INT_VALUE) {
crb_runtime_error(expr->line_number, INC_DEC_OPERAND_TYPE_ERR,
MESSAGE_ARGUMENT_END);
}
old_value = operand->u.int_value;
if (expr->type == INCREMENT_EXPRESSION) {
operand->u.int_value++;
} else {
DBG_assert(expr->type == DECREMENT_EXPRESSION,
("expr->type..%d\n", expr->type));
operand->u.int_value--;
}
result.type = SIMCAR_INT_VALUE;
result.u.int_value = old_value;
push_value(inter, &result);
}
void
CRB_interpret(CRB_Interpreter *interpreter)
{
int error_code;
StatementResult result;
crb_add_std_fp(interpreter);
if ((error_code = setjmp(interpreter
->current_recovery_environment.environment))
== 0) {
result = crb_execute_statement_list(interpreter, NULL,
interpreter->statement_list);
if (result.type != NORMAL_STATEMENT_RESULT) {
crb_runtime_error(interpreter, NULL, 0,
BREAK_OR_CONTINUE_REACHED_TOPLEVEL_ERR,
CRB_MESSAGE_ARGUMENT_END);
}
} else {
show_error_stack_trace(interpreter);
crb_set_stack_pointer(interpreter, 0);
interpreter->current_exception.type = CRB_NULL_VALUE;
}
DBG_assert(interpreter->stack.stack_pointer == 0,
("stack_pointer..%d\n", interpreter->stack.stack_pointer));
crb_garbage_collect(interpreter);
}
CRB_Value
crb_nv_fopen_proc(CRB_Interpreter *interpreter,
CRB_LocalEnvironment *env,
int arg_count, CRB_Value *args)
{
CRB_Value value;
char *filename;
char *mode;
FILE *fp;
check_argument_count(arg_count, 2);
if (args[0].type != CRB_STRING_VALUE
|| args[1].type != CRB_STRING_VALUE) {
crb_runtime_error(0, FOPEN_ARGUMENT_TYPE_ERR,
MESSAGE_ARGUMENT_END);
}
filename = CRB_wcstombs_alloc(args[0].u.object->u.string.string);
mode = CRB_wcstombs_alloc(args[1].u.object->u.string.string);
fp = fopen(filename, mode);
if (fp == NULL) {
value.type = CRB_NULL_VALUE;
} else {
value.type = CRB_NATIVE_POINTER_VALUE;
value.u.native_pointer.info = &st_native_lib_info;
value.u.native_pointer.pointer = fp;
}
MEM_free(filename);
MEM_free(mode);
return value;
}
static StatementResult
execute_while_statement(CRB_Interpreter *inter, CRB_LocalEnvironment *env,
Statement *statement)
{
StatementResult result;
CRB_Value cond;
result.type = NORMAL_STATEMENT_RESULT;
for (;;) {
cond = crb_eval_expression(inter, env, statement->u.while_s.condition);
if (cond.type != CRB_BOOLEAN_VALUE) {
crb_runtime_error(statement->u.while_s.condition->line_number,
NOT_BOOLEAN_TYPE_ERR, MESSAGE_ARGUMENT_END);
}
DBG_assert(cond.type == CRB_BOOLEAN_VALUE,
("cond.type..%d", cond.type));
if (!cond.u.boolean_value)
break;
result = crb_execute_statement_list(inter, env,
statement->u.while_s.block
->statement_list);
if (result.type == RETURN_STATEMENT_RESULT) {
break;
} else if (result.type == BREAK_STATEMENT_RESULT) {
result.type = NORMAL_STATEMENT_RESULT;
break;
}
}
return result;
}
static CRB_Boolean
eval_compare_string(ExpressionType operator,
CRB_Value *left, CRB_Value *right, int line_number)
{
CRB_Boolean result;
int cmp;
cmp = strcmp(left->u.string_value->string, right->u.string_value->string);
if(operator == EQ_EXPRESSION){
result = (cmp == 0);
} else if(operator == NE_EXPRESSION){
result = (cmp != 0);
} else if(operator == GT_EXPRESSION){
result = (cmp > 0);
} else if(operator == GE_EXPRESSION){
result = (cmp >= 0);
} else if(operator == LT_EXPRESSION){
result = (cmp < 0);
} else if(operator == LE_EXPRESSION){
result = (cmp <= 0);
} else {
char *op_str = crb_get_operator_string(operator);
crb_runtime_error(line_number, BAD_OPERATOR_FRO_STRING_ERR,
STRING_MESSAGE_ARGUMENT, "operator", op_str,
MESSAGE_ARGUMENT_END);
}
crb_release_string(left->u.string_value);
crb_release_string(right->u.string_value);
return result;
}
static StatementResult
execute_elsif(CRB_Interpreter *inter, CRB_LocalEnvironment *env,
Elsif *elsif_list, CRB_Boolean *executed)
{
StatementResult result;
CRB_Value cond;
Elsif *pos;
*executed = CRB_FALSE;
result.type = NORMAL_STATEMENT_RESULT;
for (pos = elsif_list; pos; pos = pos->next) {
cond = crb_eval_expression(inter, env, pos->condition);
if (cond.type != CRB_BOOLEAN_VALUE) {
crb_runtime_error(pos->condition->line_number,
NOT_BOOLEAN_TYPE_ERR, MESSAGE_ARGUMENT_END);
}
if (cond.u.boolean_value) {
result = crb_execute_statement_list(inter, env,
pos->block->statement_list);
*executed = CRB_TRUE;
if (result.type != NORMAL_STATEMENT_RESULT)
goto FUNC_END;
}
}
FUNC_END:
return result;
}
static CRB_Value
eval_identifier_expression(CRB_Interpreter *inter,
LocalEnvironment *env, Expression *expr)
{
CRB_Value v;
Variable *vp;
vp = crb_search_local_variable(env, expr->u.identifier);
if(vp != NULL){
v = vp->value;
} else {
vp = search_global_variable_from_env(inter, env, expr->u.identifier);
if(vp != NULL){
v = vp->value;
} else {
crb_runtime_error(expr->line_number, VARIABLE_NOT_FOUND_ERR,
STRING_MESSAGE_ARGUMENT,
"name", expr->u.identifier,
MESSAGE_ARGUMENT_END);
}
}
refer_if_string(&v);
return v;
}
static CRB_Value
eval_function_call_expression(CRB_Interpreter *inter, LcoalEnvriroment *env,
Expression *expr)
{
CRB_Value value;
FunctionDefinition *func;
char *identifier = expr->u.function_call_expression.identifier;
func = crb_search_function(identifier);
if(func == NULL){
crb_runtime_error(expr->line_number, FUNCTION_NOT_FOUND_ERR,
STRING_MESSAGE_ARGUMENT, "name", identifier,
MESSAGE_ARGUMENT_END);
}
switch(func->type){
case CROWBAR_FUNCTION_DEFINITION:
value = call_crowbar_function(inter, env, expr, func);
break;
case NATIVE_FUNCTION_DEFINITION:
value = call_native_function(inter, env, expr, func->u.native_f.proc);
break;
default:
DBG_panic(("bad case..%d\n", func->type));
}
return value;
}
static void
check_method_argument_count(int line_number,
ArgumentList *arg_list, int arg_count)
{
ArgumentList *arg_p;
int count = 0;
for (arg_p = arg_list; arg_p; arg_p = arg_p->next) {
count++;
}
if (count < arg_count) {
crb_runtime_error(line_number, ARGUMENT_TOO_FEW_ERR,
MESSAGE_ARGUMENT_END);
} else if (count > arg_count) {
crb_runtime_error(line_number, ARGUMENT_TOO_MANY_ERR,
MESSAGE_ARGUMENT_END);
}
}
static void
call_crowbar_function(SIMCAR_Interpreter *inter, SIMCAR_LocalEnvironment *env,
SIMCAR_LocalEnvironment *caller_env,
Expression *expr, FunctionDefinition *func)
{
SIMCAR_Value value;
StatementResult result;
ArgumentList *arg_p;
ParameterList *param_p;
for (arg_p = expr->u.function_call_expression.argument,
param_p = func->u.crowbar_f.parameter;
arg_p;
arg_p = arg_p->next, param_p = param_p->next) {
Variable *new_var;
SIMCAR_Value arg_val;
if (param_p == NULL) {
crb_runtime_error(expr->line_number, ARGUMENT_TOO_MANY_ERR,
MESSAGE_ARGUMENT_END);
}
eval_expression(inter, caller_env, arg_p->expression);
arg_val = pop_value(inter);
new_var = crb_add_local_variable(env, param_p->name);
new_var->value = arg_val;
}
if (param_p) {
crb_runtime_error(expr->line_number, ARGUMENT_TOO_FEW_ERR,
MESSAGE_ARGUMENT_END);
}
result = crb_execute_statement_list(inter, env,
func->u.crowbar_f.block
->statement_list);
if (result.type == RETURN_STATEMENT_RESULT) {
value = result.u.return_value;
} else {
value.type = SIMCAR_NULL_VALUE;
}
push_value(inter, &value);
}
static CRB_Value
call_crowbar_function(CRB_Interpreter *inter, LocalEnvironment *env,
Expression *expr, FunctionDefinition *func)
{
CRB_Value value;
StatementList result;
ArgumentList *arg_p;
ParamenterList *param_p;
LocalEnvironment *local_env;
local_env = alloc_local_envroment();
for(arg_p = expr->u.function_call_expression.argument,
param_p = func->u.crowbar_f.parameter;
arg_p;
arg_p = arg->next, param_p = param_p->next){
CRB_Value arg_val;
if(param_p == NULL){
crb_runtime_error(expr->line_number, ARGUMENT_TOO_MANY_ERR,
MESSAGE_ARGUMENT_END);
}
arg_val = eval_expression(inter, env, arg_p->expression);
crb_add_local_variable(local_env, param_p->name, &arg_val);
}
if(param_p){
crb_runtime_error(expr->line_number, ARGUMENT_TOO_FEW_ERR,
MESSAGE_ARUMENT_END);
}
result = crb_execute_statement_list(inter, local_env,
func->u.crowbar_f.block
->statement_list);
if(result.type == RETURN_STATEMENT_RESULT){
value.type = result.u.return_value;
} else {
value.type = CRB_NULL_VALUE;
}
dispose_local_enviroment(inter, local_env);
return value;
}
static StatementResult
execute_global_statement(CRB_Interpreter *inter, CRB_LocalEnvironment *env,
Statement *statement)
{
IdentifierList *pos;
StatementResult result;
result.type = NORMAL_STATEMENT_RESULT;
if (env == NULL) {
crb_runtime_error(statement->line_number,
GLOBAL_STATEMENT_IN_TOPLEVEL_ERR,
MESSAGE_ARGUMENT_END);
}
for (pos = statement->u.global_s.identifier_list; pos; pos = pos->next) {
GlobalVariableRef *ref_pos;
GlobalVariableRef *new_ref;
Variable *variable;
for (ref_pos = env->global_variable; ref_pos;
ref_pos = ref_pos->next) {
if (!strcmp(ref_pos->variable->name, pos->name))
goto NEXT_IDENTIFIER;
}
variable = crb_search_global_variable(inter, pos->name);
if (variable == NULL) {
crb_runtime_error(statement->line_number,
GLOBAL_VARIABLE_NOT_FOUND_ERR,
STRING_MESSAGE_ARGUMENT, "name", pos->name,
MESSAGE_ARGUMENT_END);
}
new_ref = MEM_malloc(sizeof(GlobalVariableRef));
new_ref->variable = variable;
new_ref->next = env->global_variable;
env->global_variable = new_ref;
NEXT_IDENTIFIER:
;
}
return result;
}
static CRB_Value
eval_logical_and_or_expression(CRB_Interpreter *inter,
LocalEnviroment *env,
ExpressionType operator,
Expression *left, Expression *right)
{
CRB_Value left_val;
CRB_Value right_val;
CRB_Value result;
result.type = CRB_BOOLEAN_VALUE;
left_val = eval_expression(inter, env , left);
if(left_val.type != CRB_BOOLEAN_VALUE){
crb_runtime_error(left->line_nmber, NOT_BOOLEAN_OPERATOR_ERR,
MESSAGE_ARGUMENT_END);
}
if(operator == LOGICAL_AND_EXPRESSION){
if(!left_val.u.boolean_value){
result.u.boolean_value = CRB_FALSE;
return result;
}
} else if(operator == LOGICAL_OR_EXPRESSION){
if(left_val.u.boolean_value){
result.u.booelean_value = CRB_TRUE;
return result;
}
} else {
DBG_panic(("bad operator..%d\n＂, operator"));
}
right_val = eval_expression(inter, env, rihgt);
if(right_val.type != CRB_BOOLEAN_VALUE){
crb_runtime_error(right->line_number, NOT_BOOLEAN_TYPE_ERR,
MESSAGE_ARGUGMENT_END);
}
result.u.boolean_value = right_val.u.boolean_value;
return result;
}
CRB_Value
crb_nv_new_array_proc(CRB_Interpreter *interpreter,
CRB_LocalEnvironment *env,
int arg_count, CRB_Value *args)
{
CRB_Value value;
if (arg_count < 1) {
crb_runtime_error(0, ARGUMENT_TOO_FEW_ERR,
MESSAGE_ARGUMENT_END);
}
value = new_array_sub(interpreter, env, arg_count, args, 0);
return value;
}
SIMCAR_Value *
get_lvalue(SIMCAR_Interpreter *inter, SIMCAR_LocalEnvironment *env,
Expression *expr)
{
SIMCAR_Value *dest;
if (expr->type == IDENTIFIER_EXPRESSION) {
dest = get_identifier_lvalue(inter, env, expr->u.identifier);
} else if (expr->type == INDEX_EXPRESSION) {
dest = get_array_element_lvalue(inter, env, expr);
} else {
crb_runtime_error(expr->line_number, NOT_LVALUE_ERR,
MESSAGE_ARGUMENT_END);
}
return dest;
}
static CRB_Boolean
eval_binary_boolean(CRB_Interpreter *inter, ExpressionType operator,
CRB_Boolean left, CRB_Boolean right, int line_number)
{
CRB_Boolean result;
if(operator == EQ_EXPRESSION){
result = left == right;
} else if(operator == NE_EXPERSSION){
result = left != right;
} else {
char *op_str = crb_get_operator_string(operator);
crb_runtime_error(line_number, NOT_BOOLEAN_OPERATOR_ERR,
STRING_MESSAGE_ARGUMENT, "operator", op_str,
MESSAGE_ARGUMENT_END);
}
return result;
}
static SIMCAR_Boolean
eval_binary_null(SIMCAR_Interpreter *inter, ExpressionType operato,
SIMCAR_Value *left, SIMCAR_Value *right, int line_number)
{
SIMCAR_Boolean result;
if (operato == EQ_EXPRESSION) {
result = left->type == SIMCAR_NULL_VALUE && right->type == SIMCAR_NULL_VALUE;
} else if (operato == NE_EXPRESSION) {
result = !(left->type == SIMCAR_NULL_VALUE
&& right->type == SIMCAR_NULL_VALUE);
} else {
char *op_str = crb_get_operator_string(operato);
crb_runtime_error(line_number, NOT_NULL_OPERATOR_ERR,
STRING_MESSAGE_ARGUMENT, "operator", op_str,
MESSAGE_ARGUMENT_END);
}
return result;
}
CRB_Value
crb_eval_minus_expression(CRB_Interpreter *inter, LocalEnviroment *env,
Expression *operand)
{
CBR_Value operand_val;
CRB_Value result;
operand_val = eval_expression(inter, env, operand);
if(operand_val.type == CRB_INT_VALUE){
resul.type = CRB_INT_VALUE;
result.u.int_value = -oprand_val.u.int_value;
} else if(oeprand_val.type == CRB_DOUBLE_VALUE){
result.type = CRB_DOUBLE_VALUE;
result.u.double_value = -operand_val.u.double_value;
} else {
crb_runtime_error(operand->line_number, MINUS_OPERAND_TYPE_ERR,
MESSAGE_ARGUMENT_END);
}
return result;
}
CRB_Value
crb_nv_fclose_proc(CRB_Interpreter *interpreter,
CRB_LocalEnvironment *env,
int arg_count, CRB_Value *args)
{
CRB_Value value;
FILE *fp;
check_argument_count(arg_count, 1);
value.type = CRB_NULL_VALUE;
if (args[0].type != CRB_NATIVE_POINTER_VALUE
|| !check_native_pointer(&args[0])) {
crb_runtime_error(0, FCLOSE_ARGUMENT_TYPE_ERR,
MESSAGE_ARGUMENT_END);
}
fp = args[0].u.native_pointer.pointer;
fclose(fp);
return value;
}
static void
eval_minus_expression(SIMCAR_Interpreter *inter, SIMCAR_LocalEnvironment *env,
Expression *operand)
{
SIMCAR_Value operand_val;
SIMCAR_Value result;
eval_expression(inter, env, operand);
operand_val = pop_value(inter);
if (operand_val.type == SIMCAR_INT_VALUE) {
result.type = SIMCAR_INT_VALUE;
result.u.int_value = -operand_val.u.int_value;
} else if (operand_val.type == SIMCAR_DOUBLE_VALUE) {
result.type = SIMCAR_DOUBLE_VALUE;
result.u.double_value = -operand_val.u.double_value;
} else {
crb_runtime_error(operand->line_number, MINUS_OPERAND_TYPE_ERR,
MESSAGE_ARGUMENT_END);
}
push_value(inter, &result);
}
static CRB_Boolean
eval_binary_null(CRB_Interpreter *inter, ExpressionType operator,
CRB_Value *left, CRB_Value *right, int line_number)
{
CRB_Boolean result;
if(operator == EQ_EXPRESSION){
result = left->type = CRB_NULL_VALUE && right->type == CRB_NULL_VALUE;
} else if(operator == NE_PRESSION){
result = !(left->type == CRB_NULL_VALUE
&& right->type == CRB_NULL_VALUE);
} else {
char *op_str = crb_get_operator_string(operator);
crb_runtime_error(line_number, NOT_NULL_OPERATOR_ERR,
STRING_MESSAGE_ARGUMENT, "operator", op_str,
MESSAGE_ARGUMENT_END);
}
release_if_string(left);
release_fi_string(right);
return result;
}
CRB_Value
crb_nv_fputs_proc(CRB_Interpreter *interpreter,
CRB_LocalEnvironment *env,
int arg_count, CRB_Value *args)
{
CRB_Value value;
FILE *fp;
check_argument_count(arg_count, 2);
value.type = CRB_NULL_VALUE;
if (args[0].type != CRB_STRING_VALUE
|| (args[1].type != CRB_NATIVE_POINTER_VALUE
|| !check_native_pointer(&args[1]))) {
crb_runtime_error(0, FPUTS_ARGUMENT_TYPE_ERR,
MESSAGE_ARGUMENT_END);
}
fp = args[1].u.native_pointer.pointer;
CRB_print_wcs(fp, args[0].u.object->u.string.string);
return value;
}
