CRB_FunctionDefinition *
crb_search_function_in_compile(char *name)
{
CRB_Interpreter *inter;
inter = crb_get_current_interpreter();
return CRB_search_function(inter, name);
}
Expression *
crb_alloc_expression(ExpressionType type)
{
Expression *exp;
exp = crb_alloc(sizeof(Expression));
exp->type = type;
exp->line_number = crb_get_current_interpreter()->current_line_number;
return exp;
}
static Statement *
alloc_statement(StatementType type)
{
Statement *st;
st = crb_malloc(sizeof(Statement));
st->type = type;
st->line_number = crb_get_current_interpreter()->current_line_number;
return st;
}
void *
crb_malloc(size_t size)
{
void *p;
CRB_Interpreter *inter;
inter = crb_get_current_interpreter();
p = MEM_storage_malloc(inter->interpreter_storage, size);
return p;
}
FunctionDefinition *
crb_search_function(char *name)
{
FunctionDefinition *pos;
CRB_Interpreter *inter;
inter = crb_get_current_interpreter();
for (pos = inter->function_list; pos; pos = pos->next) {
if (!strcmp(pos->name, name))
break;
}
return pos;
}
Expression *
crb_create_minus_expression(Expression *operand)
{
if (operand->type == INT_EXPRESSION
|| operand->type == DOUBLE_EXPRESSION) {
CRB_Value v;
v = crb_eval_minus_expression(crb_get_current_interpreter(),
NULL, operand);
/* Notice! Overwriting operand expression. */
*operand = convert_value_to_expression(&v);
return operand;
} else {
Expression *exp;
exp = crb_alloc_expression(MINUS_EXPRESSION);
exp->u.minus_expression = operand;
return exp;
}
}
void
crb_compile_error(CompileError id, ...)
{
va_list ap;
VString message;
int line_number;
self_check();
va_start(ap, id);
line_number = crb_get_current_interpreter()->current_line_number;
clear_v_string(&message);
format_message(&crb_compile_error_message_format[id],
&message, ap);
fprintf(stderr, "%3d:%s\n", line_number, message.string);
va_end(ap);
exit(1);
}
void
crb_function_define(char *identifier, CRB_ParameterList *parameter_list,
CRB_Block *block)
{
CRB_FunctionDefinition *f;
CRB_Interpreter *inter;
if (crb_search_function_in_compile(identifier)) {
crb_compile_error(FUNCTION_MULTIPLE_DEFINE_ERR,
CRB_STRING_MESSAGE_ARGUMENT, "name", identifier,
CRB_MESSAGE_ARGUMENT_END);
return;
}
f = create_function_definition(identifier, parameter_list, CRB_FALSE,
block);
inter = crb_get_current_interpreter();
f->next = inter->function_list;
inter->function_list = f;
}
Expression *
crb_create_binary_expression(ExpressionType operator,
Expression *left, Expression *right)
{
if ((left->type == INT_EXPRESSION
|| left->type == DOUBLE_EXPRESSION)
&& (right->type == INT_EXPRESSION
|| right->type == DOUBLE_EXPRESSION)) {
CRB_Value v;
v = crb_eval_binary_expression(crb_get_current_interpreter(),
NULL, operator, left, right);
/* Overwriting left hand expression. */
*left = convert_value_to_expression(&v);
return left;
} else {
Expression *exp;
exp = crb_alloc_expression(operator);
exp->u.binary_expression.left = left;
exp->u.binary_expression.right = right;
return exp;
}
}
void
crb_function_define(char *identifier, ParameterList *parameter_list,
Block *block)
{
FunctionDefinition *f;
CRB_Interpreter *iter;
if (crb_search_function(identifier)) {
crb_compile_error(FUNCTION_MULTIPLE_DEFINE_ERR,
STRING_MESSAGE_ARGUMENT, "name", identifier,
MESSAGE_ARGUMENT_END);
return;
}
inter = crb_get_current_interpreter();
f = crb_malloc(sizeof(FunctionDefinition));
f->name = identifier;
f->type = CROWBAR_FUNCTION_DEFINITION;
f->u.crowbar_f.parameter = parameter_list;
f->u.crowbar_f.block = block;
f->next = inter->function_list;
inter->function_list = f;
}
