Declaration *
dkc_search_declaration(char *identifier, Block *block)
{
Block *b_pos;
DeclarationList *d_pos;
DKC_Compiler *compiler;
for (b_pos = block; b_pos; b_pos = b_pos->outer_block) {
for (d_pos = b_pos->declaration_list; d_pos; d_pos = d_pos->next) {
if (!strcmp(identifier, d_pos->declaration->name)) {
return d_pos->declaration;
}
}
}
compiler = dkc_get_current_compiler();
for (d_pos = compiler->declaration_list; d_pos; d_pos = d_pos->next) {
if (!strcmp(identifier, d_pos->declaration->name)) {
return d_pos->declaration;
}
}
return NULL;
}
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;
}
int
yyerror(char const *str)
{
dkc_compile_error(dkc_get_current_compiler()->current_line_number,
PARSE_ERR,
STRING_MESSAGE_ARGUMENT, "token", yytext,
MESSAGE_ARGUMENT_END);
return 0;
}
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;
}
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;
}
int
dkc_close_character_literal(void)
{
DVM_Char buf[16];
int new_str_len;
dkc_add_string_literal('\0');
new_str_len = dvm_mbstowcs_len(st_string_literal_buffer);
if (new_str_len < 0) {
dkc_compile_error(dkc_get_current_compiler()->current_line_number,
BAD_MULTIBYTE_CHARACTER_ERR,
MESSAGE_ARGUMENT_END);
} else if (new_str_len > 1) {
dkc_compile_error(dkc_get_current_compiler()->current_line_number,
TOO_LONG_CHARACTER_LITERAL_ERR,
MESSAGE_ARGUMENT_END);
}
dvm_mbstowcs(st_string_literal_buffer, buf);
return buf[0];
}
DVM_Char *
dkc_close_string_literal(void)
{
DVM_Char *new_str;
int new_str_len;
dkc_add_string_literal('\0');
new_str_len = dvm_mbstowcs_len(st_string_literal_buffer);
if (new_str_len < 0) {
dkc_compile_error(dkc_get_current_compiler()->current_line_number,
BAD_MULTIBYTE_CHARACTER_ERR,
MESSAGE_ARGUMENT_END);
}
new_str = MEM_malloc(sizeof(DVM_Char) * (new_str_len+1));
dvm_mbstowcs(st_string_literal_buffer, new_str);
return new_str;
}
void
dkc_compile_error(int line_number, CompileError id, ...)
{
va_list ap;
VWString message;
self_check();
va_start(ap, id);
dkc_vwstr_clear(&message);
format_message(line_number,
&dkc_error_message_format[id],
&message, ap);
fprintf(stderr, "%s:%3d:", dkc_get_current_compiler()->path,
line_number);
dvm_print_wcs_ln(stderr, message.string);
va_end(ap);
exit(1);
}
FunctionDefinition *
dkc_search_function(char *name)
{
DKC_Compiler *compiler;
RenameList *ren_pos;
CompilerList *comp_pos;
FunctionDefinition *func_pos;
compiler = dkc_get_current_compiler();
for (func_pos = compiler->function_list; func_pos;
func_pos = func_pos->next) {
if (!strcmp(func_pos->name, name)
&& func_pos->class_definition == NULL) {
return func_pos;
}
}
for (ren_pos = compiler->rename_list; ren_pos; ren_pos = ren_pos->next) {
if (!strcmp(ren_pos->renamed_name, name)) {
FunctionDefinition * fd
= search_renamed_function(compiler, ren_pos);
if (fd) {
return fd;
}
}
}
for (comp_pos = compiler->required_list; comp_pos;
comp_pos = comp_pos->next) {
for (func_pos = comp_pos->compiler->function_list; func_pos;
func_pos = func_pos->next) {
if (!strcmp(func_pos->name, name)
&& func_pos->class_definition == NULL) {
return func_pos;
}
}
}
return NULL;
}
ClassDefinition *
dkc_search_class(char *identifier)
{
DKC_Compiler *compiler;
RenameList *ren_pos;
CompilerList *comp_pos;
ClassDefinition *class_def;
compiler = dkc_get_current_compiler();
for (class_def = compiler->class_definition_list;
class_def; class_def = class_def->next) {
if (!strcmp(class_def->name, identifier)) {
return class_def;
}
}
for (ren_pos = compiler->rename_list; ren_pos; ren_pos = ren_pos->next) {
if (!strcmp(ren_pos->renamed_name, identifier)) {
class_def = search_renamed_class(compiler, ren_pos);
if (class_def) {
return class_def;
}
}
}
for (comp_pos = compiler->required_list; comp_pos;
comp_pos = comp_pos->next) {
for (class_def = comp_pos->compiler->class_definition_list;
class_def; class_def = class_def->next) {
if (!strcmp(class_def->name, identifier)) {
return class_def;
}
}
}
return NULL;
}
static DVM_Executable *
do_compile(DKC_Compiler *compiler, DVM_ExecutableList *list,
char *path, DVM_Boolean is_required)
{
extern FILE *yyin;
extern int yyparse(void);
RequireList *req_pos;
DKC_Compiler *req_comp;
DVM_Executable *exe;
DVM_Executable *req_exe;
char found_path[FILENAME_MAX];
DKC_Compiler *compiler_backup;
SourceInput source_input;
compiler_backup = dkc_get_current_compiler();
dkc_set_current_compiler(compiler);
if (yyparse()) {
fprintf(stderr, "Error ! Error ! Error !\n");
exit(1);
}
for (req_pos = compiler->require_list; req_pos;
req_pos = req_pos->next) {
req_comp = search_compiler(st_compiler_list, req_pos->package_name);
if (req_comp) {
compiler->required_list
= add_compiler_to_list(compiler->required_list, req_comp);
continue;
}
req_comp = DKC_create_compiler();
/* BUGBUG req_comp references parent compiler's MEM_storage */
req_comp->package_name = req_pos->package_name;
req_comp->source_suffix = DKH_SOURCE;
compiler->required_list
= add_compiler_to_list(compiler->required_list, req_comp);
st_compiler_list = add_compiler_to_list(st_compiler_list, req_comp);
get_require_input(req_pos, found_path, &source_input);
set_path_to_compiler(req_comp, found_path);
req_comp->input_mode = source_input.input_mode;
if (source_input.input_mode == FILE_INPUT_MODE) {
yyin = source_input.u.file.fp;
} else {
dkc_set_source_string(source_input.u.string.lines);
}
req_exe = do_compile(req_comp, list, found_path, DVM_TRUE);
}
dkc_fix_tree(compiler);
exe = dkc_generate(compiler);
if (path) {
exe->path = MEM_strdup(path);
} else {
exe->path = NULL;
}
/* dvm_disassemble(exe);*/
exe->is_required = is_required;
if (!add_exe_to_list(exe, list)) {
dvm_dispose_executable(exe);
}
dkc_set_current_compiler(compiler_backup);
return exe;
}
