DKC_Compiler *
DKC_create_compiler(void)
{
MEM_Storage storage;
DKC_Compiler *compiler;
storage = MEM_open_storage(0);
compiler = MEM_storage_malloc(storage,
sizeof(struct DKC_Compiler_tag));
compiler->compile_storage = storage;
compiler->function_list = NULL;
compiler->function_count = 0;
compiler->declaration_list = NULL;
compiler->statement_list = NULL;
compiler->current_block = NULL;
compiler->current_line_number = 1;
compiler->input_mode = DKC_FILE_INPUT_MODE;
#ifdef EUC_SOURCE
compiler->source_encoding = EUC_ENCODING;
#else
#ifdef SHIFT_JIS_SOURCE
compiler->source_encoding = SHIFT_JIS_ENCODING;
#else
#ifdef UTF_8_SOURCE
compiler->source_encoding = UTF_8_ENCODING;
#else
DBG_panic(("source encoding is not defined.\n"));
#endif
#endif
#endif
dkc_set_current_compiler(compiler);
return compiler;
}
static void
set_path_to_compiler(DKC_Compiler *compiler, char *path)
{
compiler->path = MEM_storage_malloc(compiler->compile_storage,
strlen(path) + 1);
strcpy(compiler->path, path);
}
DKC_Compiler *
DKC_create_compiler(void)
{
MEM_Storage storage;
DKC_Compiler *compiler;
DKC_Compiler *compiler_backup;
compiler_backup = dkc_get_current_compiler();
storage = MEM_open_storage(0);
compiler = MEM_storage_malloc(storage,
sizeof(struct DKC_Compiler_tag));
dkc_set_current_compiler(compiler);
compiler->compile_storage = storage;
compiler->package_name = NULL;
compiler->source_suffix = DKM_SOURCE;
compiler->require_list = NULL;
compiler->rename_list = NULL;
compiler->function_list = NULL;
compiler->dvm_function_count = 0;
compiler->dvm_function = NULL;
compiler->dvm_class_count = 0;
compiler->dvm_class = NULL;
compiler->declaration_list = NULL;
compiler->statement_list = NULL;
compiler->class_definition_list = NULL;
compiler->current_block = NULL;
compiler->current_line_number = 1;
compiler->current_class_definition = NULL;
compiler->current_catch_clause = NULL;
compiler->input_mode = FILE_INPUT_MODE;
compiler->required_list = NULL;
compiler->array_method_count = ARRAY_SIZE(st_array_method);
compiler->array_method
= create_built_in_method(st_array_method,
ARRAY_SIZE(st_array_method));
compiler->string_method_count = ARRAY_SIZE(st_string_method);
compiler->string_method
= create_built_in_method(st_string_method,
ARRAY_SIZE(st_string_method));
#ifdef EUC_SOURCE
compiler->source_encoding = EUC_ENCODING;
#else
#ifdef SHIFT_JIS_SOURCE
compiler->source_encoding = SHIFT_JIS_ENCODING;
#else
#ifdef UTF_8_SOURCE
compiler->source_encoding = UTF_8_ENCODING;
#else
DBG_panic(("source encoding is not defined.\n"));
#endif
#endif
#endif
dkc_set_current_compiler(compiler_backup);
return compiler;
}
void *
crb_execute_malloc(CRB_Interpreter *inter, size_t size)
{
void *p;
p = MEM_storage_malloc(inter->execute_storage, size);
return p;
}
PackageName *
create_one_package_name(DKC_Compiler *compiler,
char *str, int start_idx, int to_idx)
{
PackageName *pn;
int i;
MEM_Storage storage = compiler->compile_storage;
pn = MEM_storage_malloc(storage, sizeof(PackageName));
pn->name = MEM_storage_malloc(storage, to_idx - start_idx + 1);
for (i = 0; i < to_idx - start_idx; i++) {
pn->name[i] = str[start_idx + i];
}
pn->name[i] = '\0';
pn->next = NULL;
return pn;
}
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;
}
void *
dkc_malloc(size_t size)
{
void *p;
DKC_Compiler *compiler;
compiler = dkc_get_current_compiler();
p = MEM_storage_malloc(compiler->compile_storage, size);
return p;
}
CRB_Interpreter *
CRB_create_interpreter(void)
{
MEM_Storage storage;
CRB_Interpreter *interpreter;
#ifndef MINICROWBAR
extern void crb_compile_built_in_script(CRB_Interpreter *inter);
#endif /* MINICROWBAR */
storage = MEM_open_storage(0);
interpreter = MEM_storage_malloc(storage,
sizeof(struct CRB_Interpreter_tag));
interpreter->interpreter_storage = storage;
interpreter->execute_storage = MEM_open_storage(0);
interpreter->variable = NULL;
interpreter->function_list = NULL;
interpreter->statement_list = NULL;
interpreter->current_line_number = 1;
interpreter->stack.stack_alloc_size = 0;
interpreter->stack.stack_pointer = 0;
interpreter->stack.stack
= MEM_malloc(sizeof(CRB_Value) * STACK_ALLOC_SIZE);
interpreter->heap.current_heap_size = 0;
interpreter->heap.current_threshold = HEAP_THRESHOLD_SIZE;
interpreter->heap.header = NULL;
interpreter->top_environment = NULL;
interpreter->current_exception.type = CRB_NULL_VALUE;
interpreter->input_mode = CRB_FILE_INPUT_MODE;
interpreter->regexp_literals = NULL;
#ifdef EUC_SOURCE
interpreter->source_encoding = EUC_ENCODING;
#else
#ifdef SHIFT_JIS_SOURCE
interpreter->source_encoding = SHIFT_JIS_ENCODING;
#else
#ifdef UTF_8_SOURCE
interpreter->source_encoding = UTF_8_ENCODING;
#else
DBG_panic(("source encoding is not defined.\n"));
#endif
#endif
#endif
crb_set_current_interpreter(interpreter);
crb_add_native_functions(interpreter);
crb_add_regexp_functions(interpreter);
#ifndef MINICROWBAR
crb_compile_built_in_script(interpreter);
#endif /* MINICROWBAR */
return interpreter;
}
char *
dkc_strdup(char *src)
{
char *p;
DKC_Compiler *compiler;
compiler = dkc_get_current_compiler();
p = MEM_storage_malloc(compiler->compile_storage, strlen(src)+1);
strcpy(p, src);
return p;
}
CL_Interpreter *CL_create_interpreter(void)
{
MEM_Storage storage;
CL_Interpreter *interpreter;
storage = MEM_open_storage(0);
interpreter = MEM_storage_malloc(storage,
sizeof(struct CL_Interpreter_tag));
interpreter->interpreter_storage = storage;
interpreter->execute_storage = NULL;
interpreter->variable = NULL;
interpreter->function_list = NULL;
interpreter->statement_list = NULL;
interpreter->current_line_number = 1;
cl_set_current_interpreter(interpreter);
add_native_functions(interpreter);
return interpreter;
}
