示例#1
0
文件: interface.c 项目: 3man/devlang
DVM_ExecutableList *
DKC_compile(DKC_Compiler *compiler, FILE *fp, char *path)
{
    extern FILE *yyin;
    DVM_ExecutableList *list;
    DVM_Executable *exe;

    DBG_assert(st_compiler_list == NULL,
               ("st_compiler_list != NULL(%p)", st_compiler_list));
    set_path_to_compiler(compiler, path);
    compiler->input_mode = FILE_INPUT_MODE;

    yyin = fp;

    list = MEM_malloc(sizeof(DVM_ExecutableList));
    list->list = NULL;
    
    exe = do_compile(compiler, list, NULL, DVM_FALSE);
    exe->path = MEM_strdup(path);
    list->top_level = exe;

    /* dvm_disassemble(exe);*/

    dispose_compiler_list();
    dkc_reset_string_literal_buffer();

    return list;
}
示例#2
0
void
MVM_add_native_function(MVM_VirtualMachine *mvm, char *func_name,
                        MVM_NativeFunctionProc *proc, int arg_count)
{
    mvm->function = MEM_realloc(mvm->function,
                                sizeof(Function) * (mvm->function_count + 1));

    mvm->function[mvm->function_count].name = MEM_strdup(func_name);
    mvm->function[mvm->function_count].kind = NATIVE_FUNCTION;
    mvm->function[mvm->function_count].u.native_f.proc = proc;
    mvm->function[mvm->function_count].u.native_f.arg_count = arg_count;
    mvm->function_count++;
}
示例#3
0
文件: heap.c 项目: MrAiki/LL1LL
/* 文字列srcをヒープ領域へ割り当てる. 文字列はヒープ領域へディープコピーされる. */
LL1LL_Object* alloc_string(char *src, LL1LL_Boolean is_literal)
{
  /* 領域確保 */
  LL1LL_Object *new_entry       = (LL1LL_Object *)MEM_malloc(sizeof(LL1LL_Object));
  /* オブジェクトの種類と, マークの初期化 */
  new_entry->type               = STRING_OBJECT;
  new_entry->marked             = LL1LL_FALSE;
  /* 内容を埋める */
  new_entry->u.str.string_value = MEM_strdup(src);
  new_entry->u.str.is_literal   = is_literal;
  /* ヒープ管理リストへ追加 */
  addHeapEntry(new_entry);

  return new_entry;
}
示例#4
0
文件: generate.c 项目: BluePanM/code
static void
add_global_variable(DKC_Compiler *compiler, DVM_Executable *exe)
{
    DeclarationList *dl;
    int i;
    int var_count = 0;

    for (dl = compiler->declaration_list; dl; dl = dl->next) {
        var_count++;
    }
    exe->global_variable_count = var_count;
    exe->global_variable = MEM_malloc(sizeof(DVM_Variable) * var_count);

    for (dl = compiler->declaration_list, i = 0; dl; dl = dl->next, i++) {
        exe->global_variable[i].name = MEM_strdup(dl->declaration->name);
        exe->global_variable[i].type
            = copy_type_specifier(dl->declaration->type);
    }
}
示例#5
0
文件: generate.c 项目: BluePanM/code
static DVM_LocalVariable *
copy_local_variables(FunctionDefinition *fd, int param_count)
{
    int i;
    int local_variable_count;
    DVM_LocalVariable *dest;

    local_variable_count = fd->local_variable_count - param_count;

    dest = MEM_malloc(sizeof(DVM_LocalVariable) * local_variable_count);

    for (i = 0; i < local_variable_count; i++) {
        dest[i].name
            = MEM_strdup(fd->local_variable[i+param_count]->name);
        dest[i].type
            = copy_type_specifier(fd->local_variable[i+param_count]->type);
    }

    return dest;
}
示例#6
0
文件: generate.c 项目: BluePanM/code
static DVM_LocalVariable *
copy_parameter_list(ParameterList *src, int *param_count_p)
{
    int param_count = 0;
    ParameterList *param;
    DVM_LocalVariable *dest;
    int i;

    for (param = src; param; param = param->next) {
        param_count++;
    }
    *param_count_p = param_count;
    dest = MEM_malloc(sizeof(DVM_LocalVariable) * param_count);
    
    for (param = src, i = 0; param; param = param->next, i++) {
        dest[i].name = MEM_strdup(param->name);
        dest[i].type = copy_type_specifier(param->type);
    }

    return dest;
}
示例#7
0
Statement *
Asm_create_statement(char *label, Bytecode *code, Constant *const_opt)
{
	NameSpace *name_space;
	Statement *ret;

	name_space = &Asm_get_current_compiler()->name_space[Asm_get_current_compiler()->current_name_space_index];
	ret = ASM_malloc(sizeof(Statement));
	ret->label = label;
	ret->bytecode = code;
	ret->constant = const_opt;
	ret->line_number = get_current_line_number();

	if (code && code->name == NULL && code->next
		&& !strcmp(code->next->name, Loopr_CR_Info[LCR_FUNCTION].assembly_name)) {
		if (name_space->function_definition) {
			name_space->function_definition = MEM_realloc(name_space->function_definition,
														sizeof(FunctionDefinition) * (name_space->function_count + 1));
		} else {
			name_space->function_definition = MEM_malloc(sizeof(FunctionDefinition) * (name_space->function_count + 1));
		}

		name_space->function_definition[name_space->function_count].is_void = LPR_False;
		while (const_opt && const_opt->type == CONST_KEYWORD) {
			switch (const_opt->u.keyword_value) {
				case ASM_VOID:
					name_space->function_definition[name_space->function_count].is_void = LPR_True;
					const_opt = const_opt->next;
					break;
				default:
					DBG_panic(("line %d: Unknown keyword %d\n", const_opt->line_number, const_opt->u.keyword_value));
					break;
			}
		}
		name_space->function_definition[name_space->function_count].name = MEM_strdup(const_opt->u.string_value);
		name_space->function_count++;
	}

	return ret;
}
示例#8
0
static void
add_functions(MVM_VirtualMachine *mvm, MVM_Executable *executable)
{
    int src_idx;
    int dest_idx;
    int func_count = 0;

    for (src_idx = 0; src_idx < executable->function_count; src_idx++) {
        if (executable->function[src_idx].is_implemented) {
            func_count++;
            for (dest_idx = 0; dest_idx < mvm->function_count; dest_idx++) {
                if (!strcmp(mvm->function[dest_idx].name,
                            executable->function[src_idx].name)) {
                    /*
                    mvm_error(NULL, NULL, NO_LINE_NUMBER_PC,
                          FUNCTION_MULTIPLE_DEFINE_ERR,
                          STRING_MESSAGE_ARGUMENT, "name",
                          mvm->function[dest_idx].name,
                          MESSAGE_ARGUMENT_END); */
                }
            }
        }
    }
    mvm->function = MEM_realloc(mvm->function,
                                sizeof(Function) * (mvm->function_count + func_count));

    for (src_idx = 0, dest_idx = mvm->function_count;
            src_idx < executable->function_count; src_idx++) {
        if (!executable->function[src_idx].is_implemented)
            continue;
        mvm->function[dest_idx].name
            = MEM_strdup(executable->function[src_idx].name);
        mvm->function[dest_idx].u.minic_f.executable
            = executable;
        mvm->function[dest_idx].u.minic_f.index = src_idx;
        dest_idx++;
    }
    mvm->function_count += func_count;
}
示例#9
0
文件: interface.c 项目: 3man/devlang
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;
}
示例#10
0
CRB_Value
crb_eval_binary_expression(CRB_Interpret *inter, LocalEnvironment *env,
        ExpressionType operator,
        Expression *left, Expression *right)
{
    CRB_Value left_val;
    CRB_Value right_val;
    CRB_Value result;

    left_val = eval_expression(inter, env, left);
    right_val = eval_expression(inter, env, right);

    if(left_val.type == CRB_INT_VALUE
            && right_val.type == CRB_INT_VALUE){
        eval_binary_int(inter, operator,
                left_val.u.int_value, right_val.u.int_value,
                &result, letf->line_number);
    } else if(left_val.type == CRB_DOUBLE_VALUE
            && right_val.type == CRB_DOUBLE_VALUE){
        eval_binary_double(inter, operator,
                left_val.u.double_value, right_val.u.double_value,
                &result, left->line_number);
    } else if(left_val.type == CRB_INT_VALUE
            && right_val.type == CRB_DOUBLE_VALUE){
        right_val.u.double_value = right_val.u.int_value;
        eval_binary_double(inter, operator, 
                left_val.u.double_value, right_val.u.double_value,
                &result, left->line_number);
    } else if(left_val.type == CRB_DOUBLE_VALUE 
            && right_val.type == CRB_INT_VALUE){
        right_val.u.double_value = right_val.u.int_value;
        eval_binary_double(inter, operator,
                left_val.u.double_value, right_val.u.double_value,
                &result, left->line_number);
    } else if(left_val.type == CRB_BOOLEAN_VALUE
            && right_val.type == CRB_BOOLEAN_VALUE){
        result.type = CRB_BOOLEAN_VALUE;
        result.u.boolean_value
            = eval_binary_boolean(inter, operator,
                    left_val.u.doublean_value,
                    right_val.u.double_value,
                    left->line_number);
    }else if(left_val.type == CRB_STRING_VALUE
            && operator == ADD_EXPRESSION){
        char buf[LINE_BUF_SIZE];
        CRB_String *right_str;

        if(right_val.type == CRB_INT_VALUE){
            sprintf(buf, "%d", right_val.u.int_value);
            right_str = crb_create_crowbar_string(inter, MEM_strdup(buf));
        } else if(right_val.tpye == CRB_DOUBLE_VALUE){
            sprintf(buf, "%f", right_val.u.double_value);
            right_str = crb_create_crowbar_string(inter, MEM_strdup(buf));
        } else if(right_val.type == CRB_BOOLEAN_VALUE){
            if(right_val.u.boolean_value){
                right_str = crb_create_crowbar_str(inter,
                        MEM_strdup("true"));
            } else {
                right_str = crb_create_crowbar_string(inter,
                        MEM_strdup("false"));
            }
        }else if(right_val.type == CRB_STRING_VALUE){
            right_str = right_val.u.tring_value;
        } else if(right_val.type == CRB_NATIVE_POINTER_VALUE){
            sprintf(buf, "%s:%p)",
                    right_val.u.native_pointer.info->name, 
                    right_val.u.native_pointer.pointer);
            right_str = crb_create_crowbar_string(inter, MEM_strdup(buf));
        } else if(right_val.type == CRB_NULL_VALUE){
            right_str = crb_create_crowbar_string(inter, MEM_strdup("null"));
        }
        result.type = CRB_STRING_VALUE;
        result.u.string_value = chain_string(inter,
                left_val.u.string_value,
                right_str);
    } else if(left_val.type == CRB_STRING_VALUE
            && right_val.type == CRB_STRING_VALUE){
        resultr.type = CRB_BOOLEAN_VALUE;
        result.u.boolean_value
             = eval_compare_string(operator, &left_val, &right_val,
                     left->line_number);
    } else if(left_val.type == CRB_NULL_VALUE
            || right_val.type == CRB_NULL_VALUE){
        result.type = CRB_BOOLEAN_VALUE;
        result.u.boolean_value 
            = eval_binary_null(inter, operator,&left_val, &right_val,
                    left->line_number);
    } else {
        char *op_str = crb_get_operator_string(operator);
        crb_runtime_error(left->line_number, BAD_OPERAND_TYPE_ERR,
                STRING_MESSAGE_ARGUMENT, "operator", op_str,
                MESSAGE_ARGUMENT_END);
    }

    return result;
}