// 用来分配标识符字符串空间, 功能相当与 strdup,
// 但是将分配空间置于 Storage 的管理之下
char *
crb_create_identifier(const char *str)
{
char *new_str = crb_malloc(strlen(str) + 1);
strcpy(new_str, str);
return new_str;
}
// 此时字符串空间已经固定了, 所以可以使用利用 Storage 的 crb_malloc 来分配
char *
crb_close_string_literal()
{
char *new_str = crb_malloc(st_string_literal_buffer_size + 1);
memcpy(new_str, st_string_literal_buffer, st_string_literal_buffer_size);
new_str[st_string_literal_buffer_size] = '\0';
return new_str;
}
CRB_Block *
crb_create_block(StatementList *statement_list)
{
CRB_Block *block;
block = crb_malloc(sizeof(CRB_Block));
block->statement_list = statement_list;
return block;
}
ArgumentList *
crb_create_argument_list(Expression *expression)
{
ArgumentList *al;
al = crb_malloc(sizeof(ArgumentList));
al->expression = expression;
al->next = NULL;
return al;
}
StatementList *
crb_create_statement_list(Statement *statement)
{
StatementList *sl;
sl = crb_malloc(sizeof(StatementList));
sl->statement = statement;
sl->next = NULL;
return sl;
}
ExpressionList *
crb_create_expression_list(Expression *expression)
{
ExpressionList *el;
el = crb_malloc(sizeof(ExpressionList));
el->expression = expression;
el->next = NULL;
return el;
}
CRB_ParameterList *
crb_create_parameter(char *identifier)
{
CRB_ParameterList *p;
p = crb_malloc(sizeof(CRB_ParameterList));
p->name = identifier;
p->next = NULL;
return p;
}
IdentifierList *
crb_create_global_identifier(char *identifier)
{
IdentifierList *i_list;
i_list = crb_malloc(sizeof(IdentifierList));
i_list->name = identifier;
i_list->next = NULL;
return i_list;
}
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;
}
Expression *
crb_alloc_expression(ExpressionType type)
{
Expression *exp;
exp = crb_malloc(sizeof(Expression));
exp->type = type;
exp->line_number = crb_get_current_interpreter()->current_line_number;
return exp;
}
Elsif *
crb_create_elsif(Expression *expr, CRB_Block *block)
{
Elsif *ei;
ei = crb_malloc(sizeof(Elsif));
ei->condition = expr;
ei->block = block;
ei->next = NULL;
return ei;
}
static CRB_FunctionDefinition *
create_function_definition(char *identifier, CRB_ParameterList *parameter_list,
CRB_Boolean is_closure, CRB_Block *block)
{
CRB_FunctionDefinition *f;
f = crb_malloc(sizeof(CRB_FunctionDefinition));
f->name = identifier;
f->type = CRB_CROWBAR_FUNCTION_DEFINITION;
f->is_closure = is_closure;
f->u.crowbar_f.parameter = parameter_list;
f->u.crowbar_f.block = block;
return f;
}
CRB_FunctionDefinition *
CRB_add_native_function(CRB_Interpreter *interpreter,
char *name, CRB_NativeFunctionProc *proc)
{
CRB_FunctionDefinition *fd;
fd = crb_malloc(sizeof(CRB_FunctionDefinition));
fd->name = name;
fd->type = CRB_NATIVE_FUNCTION_DEFINITION;
fd->is_closure = CRB_FALSE;
fd->u.native_f.proc = proc;
fd->next = interpreter->function_list;
interpreter->function_list = fd;
return fd;
}
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;
}