示例#1
0
文件: util.c 项目: BluePanM/code
void
dvm_initialize_value(DVM_TypeSpecifier *type, DVM_Value *value)
{
    if (type->derive_count > 0) {
        if (type->derive[0].tag == DVM_ARRAY_DERIVE) {
            value->object = dvm_null_object_ref;
        } else {
            DBG_assert(0, ("tag..%d", type->derive[0].tag));
        }
    } else {
        switch (type->basic_type) {
        case DVM_VOID_TYPE:  /* FALLTHRU */
        case DVM_BOOLEAN_TYPE: /* FALLTHRU */
        case DVM_INT_TYPE: /* FALLTHRU */
            value->int_value = 0;
            break;
        case DVM_DOUBLE_TYPE:
            value->double_value = 0.0;
            break;
        case DVM_STRING_TYPE: /* FALLTHRU */
        case DVM_CLASS_TYPE: /* FALLTHRU */
            value->object = dvm_null_object_ref;
            break;
        case DVM_NULL_TYPE: /* FALLTHRU */
        case DVM_BASE_TYPE: /* FALLTHRU */
        default:
            DBG_assert(0, ("basic_type..%d", type->basic_type));
        }
    }
}
示例#2
0
文件: nativeif.c 项目: BluePanM/code
CRB_Char *
CRB_object_get_string(CRB_Object *obj)
{
    DBG_assert(obj->type == STRING_OBJECT,
               ("obj->type..%d\n", obj->type));
    return obj->u.string.string;
}
示例#3
0
文件: execute.c 项目: BluePanM/code
static StatementResult
execute_if_statement(CRB_Interpreter *inter, CRB_LocalEnvironment *env,
                     Statement *statement)
{
    StatementResult result;
    CRB_Value   cond;

    result.type = NORMAL_STATEMENT_RESULT;
    cond = crb_eval_expression(inter, env, statement->u.if_s.condition);
    if (cond.type != CRB_BOOLEAN_VALUE) {
        crb_runtime_error(statement->u.if_s.condition->line_number,
                          NOT_BOOLEAN_TYPE_ERR, MESSAGE_ARGUMENT_END);
    }
    DBG_assert(cond.type == CRB_BOOLEAN_VALUE, ("cond.type..%d", cond.type));

    if (cond.u.boolean_value) {
        result = crb_execute_statement_list(inter, env,
                                            statement->u.if_s.then_block
                                            ->statement_list);
    } else {
        CRB_Boolean elsif_executed;
        result = execute_elsif(inter, env, statement->u.if_s.elsif_list,
                               &elsif_executed);
        if (result.type != NORMAL_STATEMENT_RESULT)
            goto FUNC_END;
        if (!elsif_executed && statement->u.if_s.else_block) {
            result = crb_execute_statement_list(inter, env,
                                                statement->u.if_s.else_block
                                                ->statement_list);
        }
    }

  FUNC_END:
    return result;
}
示例#4
0
文件: nativeif.c 项目: BluePanM/code
void *
CRB_object_get_native_pointer(CRB_Object *obj)
{
    DBG_assert(obj->type == NATIVE_POINTER_OBJECT,
               ("obj->type..%d\n", obj->type));
    return obj->u.native_pointer.pointer;
}
示例#5
0
文件: generate.c 项目: BluePanM/code
static void
fix_labels(OpcodeBuf *ob)
{
    int i;
    int j;
    OpcodeInfo *info;
    int label;
    int address;

    for (i = 0; i < ob->size; i++) {
        if (ob->code[i] == DVM_JUMP
            || ob->code[i] == DVM_JUMP_IF_TRUE
            || ob->code[i] == DVM_JUMP_IF_FALSE) {
            label = (ob->code[i+1] << 8) + (ob->code[i+2]);
            address = ob->label_table[label].label_address;
            ob->code[i+1] = (DVM_Byte)(address >> 8);
            ob->code[i+2] = (DVM_Byte)(address &0xff);
        }
        info = &dvm_opcode_info[ob->code[i]];
        for (j = 0; info->parameter[j] != '\0'; j++) {
            switch (info->parameter[j]) {
            case 'b':
                i++;
                break;
            case 's': /* FALLTHRU */
            case 'p':
                i += 2;
                break;
            default:
                DBG_assert(0, ("param..%s, j..%d", info->parameter, j));
            }
        }
    }
示例#6
0
文件: nativeif.c 项目: BluePanM/code
void
CRB_object_set_native_pointer(CRB_Object *obj, void *p)
{
    DBG_assert(obj->type == NATIVE_POINTER_OBJECT,
               ("obj->type..%d\n", obj->type));
    obj->u.native_pointer.pointer = p;
}
示例#7
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;
}
示例#8
0
文件: generate.c 项目: BluePanM/code
static void
generate_cast_expression(DVM_Executable *exe, Block *block,
                         Expression *expr, OpcodeBuf *ob)
{
    generate_expression(exe, block, expr->u.cast.operand, ob);
    switch (expr->u.cast.type) {
    case INT_TO_DOUBLE_CAST:
        generate_code(ob, expr->line_number, DVM_CAST_INT_TO_DOUBLE);
        break;
    case DOUBLE_TO_INT_CAST:
        generate_code(ob, expr->line_number, DVM_CAST_DOUBLE_TO_INT);
        break;
    case BOOLEAN_TO_STRING_CAST:
        generate_code(ob, expr->line_number, DVM_CAST_BOOLEAN_TO_STRING);
        break;
    case INT_TO_STRING_CAST:
        generate_code(ob, expr->line_number, DVM_CAST_INT_TO_STRING);
        break;
    case DOUBLE_TO_STRING_CAST:
        generate_code(ob, expr->line_number, DVM_CAST_DOUBLE_TO_STRING);
        break;
    default:
        DBG_assert(0, ("expr->u.cast.type..%d", expr->u.cast.type));
    }
}
示例#9
0
文件: util.c 项目: 3man/devlang
char *
dkc_get_type_name(TypeSpecifier *type)
{
    VString     vstr;
    TypeDerive  *derive_pos;

    dkc_vstr_clear(&vstr);

    if (type->basic_type == DVM_CLASS_TYPE) {
        dkc_vstr_append_string(&vstr, type->class_ref.identifier);
    } else {
        dkc_vstr_append_string(&vstr,
                               dkc_get_basic_type_name(type->basic_type));
    }

    for (derive_pos = type->derive; derive_pos;
         derive_pos = derive_pos->next) {
        switch (derive_pos->tag) {
        case FUNCTION_DERIVE:
            function_type_to_string(&vstr, derive_pos);
            break;
        case ARRAY_DERIVE:
            dkc_vstr_append_string(&vstr, "[]");
            break;
        default:
            DBG_assert(0, ("derive_tag..%d\n", derive_pos->tag));
        }
    }

    return vstr.string;
}
示例#10
0
文件: util.c 项目: 3man/devlang
char *
dkc_get_basic_type_name(DVM_BasicType type)
{
    switch (type) {
    case DVM_VOID_TYPE:
        return "void";
        break;
    case DVM_BOOLEAN_TYPE:
        return "boolean";
        break;
    case DVM_INT_TYPE:
        return "int";
        break;
    case DVM_DOUBLE_TYPE:
        return "double";
        break;
    case DVM_STRING_TYPE:
        return "string";
        break;
    case DVM_CLASS_TYPE:
        return "class";
        break;
    case DVM_NULL_TYPE:
        return "null";
        break;
    case DVM_BASE_TYPE: /* FALLTHRU */
    default:
        DBG_assert(0, ("bad case. type..%d\n", type));
    }
    return NULL;
}
示例#11
0
文件: execute.c 项目: BluePanM/code
static StatementResult
execute_while_statement(CRB_Interpreter *inter, CRB_LocalEnvironment *env,
                        Statement *statement)
{
    StatementResult result;
    CRB_Value   cond;

    result.type = NORMAL_STATEMENT_RESULT;
    for (;;) {
        cond = crb_eval_expression(inter, env, statement->u.while_s.condition);
        if (cond.type != CRB_BOOLEAN_VALUE) {
            crb_runtime_error(statement->u.while_s.condition->line_number,
                              NOT_BOOLEAN_TYPE_ERR, MESSAGE_ARGUMENT_END);
        }
        DBG_assert(cond.type == CRB_BOOLEAN_VALUE,
                   ("cond.type..%d", cond.type));
        if (!cond.u.boolean_value)
            break;

        result = crb_execute_statement_list(inter, env,
                                            statement->u.while_s.block
                                            ->statement_list);
        if (result.type == RETURN_STATEMENT_RESULT) {
            break;
        } else if (result.type == BREAK_STATEMENT_RESULT) {
            result.type = NORMAL_STATEMENT_RESULT;
            break;
        }
    }

    return result;
}
示例#12
0
文件: generate.c 项目: BluePanM/code
static DVM_TypeSpecifier *
copy_type_specifier(TypeSpecifier *src)
{
    DVM_TypeSpecifier *dest;
    int derive_count = 0;
    TypeDerive *derive;
    int param_count;
    int i;

    dest = MEM_malloc(sizeof(DVM_TypeSpecifier));

    dest->basic_type = src->basic_type;

    for (derive = src->derive; derive; derive = derive->next) {
        derive_count++;
    }
    dest->derive_count = derive_count;
    dest->derive = MEM_malloc(sizeof(DVM_TypeDerive) * derive_count);
    for (i = 0, derive = src->derive; derive;
         derive = derive->next, i++) {
        switch (derive->tag) {
        case DVM_FUNCTION_DERIVE:
            dest->derive[i].tag = DVM_FUNCTION_DERIVE;
            dest->derive[i].u.function_d.parameter
                = copy_parameter_list(derive->u.function_d.parameter_list,
                                      &param_count);
            dest->derive[i].u.function_d.parameter_count = param_count;
            break;
        default:
            DBG_assert(0, ("derive->tag..%d\n", derive->tag));
        }
    }

    return dest;
}
示例#13
0
文件: eval.c 项目: lyyyuna/sim_car
static void
eval_inc_dec_expression(SIMCAR_Interpreter *inter,
                        SIMCAR_LocalEnvironment *env, Expression *expr)
{
    SIMCAR_Value   *operand;
    SIMCAR_Value   result;
    int         old_value;
    
    operand = get_lvalue(inter, env, expr->u.inc_dec.operand);
    if (operand->type != SIMCAR_INT_VALUE) {
        crb_runtime_error(expr->line_number, INC_DEC_OPERAND_TYPE_ERR,
                          MESSAGE_ARGUMENT_END);
    }
    old_value = operand->u.int_value;
    if (expr->type == INCREMENT_EXPRESSION) {
        operand->u.int_value++;
    } else {
        DBG_assert(expr->type == DECREMENT_EXPRESSION,
                   ("expr->type..%d\n", expr->type));
        operand->u.int_value--;
    }

    result.type = SIMCAR_INT_VALUE;
    result.u.int_value = old_value;
    push_value(inter, &result);
}
示例#14
0
文件: create.c 项目: rod-lin/Ivory
ClassOrMemberModifierList
Ivyc_create_class_or_member_modifier(ClassOrMemberModifierKind modifier)
{
    ClassOrMemberModifierList ret;

    ret.is_abstract = NOT_SPECIFIED_MODIFIER;
    ret.access_modifier = NOT_SPECIFIED_MODIFIER;
    ret.is_override = NOT_SPECIFIED_MODIFIER;
    ret.is_virtual = NOT_SPECIFIED_MODIFIER;

    switch (modifier) {
    case ABSTRACT_MODIFIER:
        ret.is_abstract = ABSTRACT_MODIFIER;
        break;
    case PUBLIC_MODIFIER:
        ret.access_modifier = PUBLIC_MODIFIER;
        break;
    case PRIVATE_MODIFIER:
        ret.access_modifier = PRIVATE_MODIFIER;
        break;
    case OVERRIDE_MODIFIER:
        ret.is_override = OVERRIDE_MODIFIER;
        break;
    case VIRTUAL_MODIFIER:
        ret.is_virtual = VIRTUAL_MODIFIER;
        break;
    case NOT_SPECIFIED_MODIFIER: /* FALLTHRU */
    default:
        DBG_assert(0, ("modifier..%d", modifier));
    }

    return ret;
}
示例#15
0
文件: create.c 项目: rod-lin/Ivory
void Ivyc_class_define(MemberDeclaration *member_list)
{
    Ivyc_Compiler *compiler;
    ClassDefinition *cd;
    ClassDefinition *pos;

    compiler = Ivyc_get_current_compiler();
    cd = compiler->current_class_definition;
    DBG_assert(cd != NULL, ("current_class_definition is NULL."));

	cd->member = member_list;

	if (cd->is_generic == ISandBox_TRUE) {
		if (compiler->template_class_definition_list == NULL) {
        	compiler->template_class_definition_list = cd;
    	} else {
        	for (pos = compiler->template_class_definition_list; pos->next;
             	pos = pos->next)
            	;
        	pos->next = cd;
    	}
	} else {
    	if (compiler->class_definition_list == NULL) {
        	compiler->class_definition_list = cd;
    	} else {
        	for (pos = compiler->class_definition_list; pos->next;
             	pos = pos->next)
            	;
        	pos->next = cd;
    	}
	}

    compiler->current_class_definition = NULL;
}
示例#16
0
文件: interface.c 项目: BluePanM/code
void
CRB_interpret(CRB_Interpreter *interpreter)
{
    int error_code;
    StatementResult result;

    crb_add_std_fp(interpreter);

    if ((error_code = setjmp(interpreter
                             ->current_recovery_environment.environment))
        == 0) {
        result = crb_execute_statement_list(interpreter, NULL,
                                            interpreter->statement_list);
        if (result.type != NORMAL_STATEMENT_RESULT) {
            crb_runtime_error(interpreter, NULL, 0,
                              BREAK_OR_CONTINUE_REACHED_TOPLEVEL_ERR,
                              CRB_MESSAGE_ARGUMENT_END);
        }
    } else {
        show_error_stack_trace(interpreter);

        crb_set_stack_pointer(interpreter, 0);
        interpreter->current_exception.type = CRB_NULL_VALUE;
    }
    DBG_assert(interpreter->stack.stack_pointer == 0,
               ("stack_pointer..%d\n", interpreter->stack.stack_pointer));
    crb_garbage_collect(interpreter);
}
示例#17
0
文件: nativeif.c 项目: BluePanM/code
void
CRB_array_set(CRB_Interpreter *inter, CRB_LocalEnvironment *env,
              CRB_Object *obj, int index, CRB_Value *value)
{
    DBG_assert(obj->type == ARRAY_OBJECT,
               ("obj->type..%d\n", obj->type));
    obj->u.array.array[index] = *value;
}
示例#18
0
文件: create.c 项目: rod-lin/Ivory
ClassOrMemberModifierList
Ivyc_chain_class_or_member_modifier(ClassOrMemberModifierList list,
                                   ClassOrMemberModifierList add)
{
    if (add.is_abstract != NOT_SPECIFIED_MODIFIER) {
        DBG_assert(add.is_abstract == ABSTRACT_MODIFIER,
                   ("add.is_abstract..%d", add.is_abstract));
        if (list.is_abstract != NOT_SPECIFIED_MODIFIER) {
            Ivyc_compile_error(Ivyc_get_current_compiler()->current_line_number,
                              ABSTRACT_MULTIPLE_SPECIFIED_ERR,
                              MESSAGE_ARGUMENT_END);
        }
        list.is_abstract = ABSTRACT_MODIFIER;

    } else if (add.access_modifier != NOT_SPECIFIED_MODIFIER) {
        DBG_assert(add.access_modifier == PUBLIC_MODIFIER
                   || add.access_modifier == PUBLIC_MODIFIER,
                   ("add.access_modifier..%d", add.access_modifier));
        if (list.access_modifier != NOT_SPECIFIED_MODIFIER) {
            Ivyc_compile_error(Ivyc_get_current_compiler()->current_line_number,
                              ACCESS_MODIFIER_MULTIPLE_SPECIFIED_ERR,
                              MESSAGE_ARGUMENT_END);
        }
        list.access_modifier = add.access_modifier;

    } else if (add.is_override != NOT_SPECIFIED_MODIFIER) {
        DBG_assert(add.is_override == OVERRIDE_MODIFIER,
                   ("add.is_override..%d", add.is_override));
        if (list.is_override != NOT_SPECIFIED_MODIFIER) {
            Ivyc_compile_error(Ivyc_get_current_compiler()->current_line_number,
                              OVERRIDE_MODIFIER_MULTIPLE_SPECIFIED_ERR,
                              MESSAGE_ARGUMENT_END);
        }
        list.is_override = add.is_override;
    } else if (add.is_virtual != NOT_SPECIFIED_MODIFIER) {
        DBG_assert(add.is_virtual == VIRTUAL_MODIFIER,
                   ("add.is_virtual..%d", add.is_virtual));
        if (list.is_virtual != NOT_SPECIFIED_MODIFIER) {
            Ivyc_compile_error(Ivyc_get_current_compiler()->current_line_number,
                              VIRTUAL_MODIFIER_MULTIPLE_SPECIFIED_ERR,
                              MESSAGE_ARGUMENT_END);
        }
        list.is_virtual = add.is_virtual;
    }
    return list;
}
示例#19
0
文件: generate.c 项目: BluePanM/code
static void
generate_return_statement(DVM_Executable *exe, Block *block,
                          Statement *statement, OpcodeBuf *ob)
{
    DBG_assert(statement->u.return_s.return_value != NULL,
               ("return value is null."));

    generate_expression(exe, block, statement->u.return_s.return_value, ob);
    generate_code(ob, statement->line_number, DVM_RETURN);
}
示例#20
0
文件: create.c 项目: rod-lin/Ivory
ISandBox_AccessModifier
conv_access_modifier(ClassOrMemberModifierKind src)
{
    if (src == PUBLIC_MODIFIER) {
        return ISandBox_PUBLIC_ACCESS;
    } else if (src == PRIVATE_MODIFIER) {
        return ISandBox_PRIVATE_ACCESS;
    } else {
        DBG_assert(src == NOT_SPECIFIED_MODIFIER, ("src..%d\n", src));
        return ISandBox_FILE_ACCESS;
    }
}
示例#21
0
文件: create.c 项目: rod-lin/Ivory
Block *
Ivyc_close_block(Block *block, StatementList *statement_list)
{
    Ivyc_Compiler *compiler = Ivyc_get_current_compiler();

    DBG_assert(block == compiler->current_block,
               ("block mismatch.\n"));
    block->statement_list = statement_list;
    compiler->current_block = block->outer_block;

    return block;
}
示例#22
0
文件: generate.c 项目: BluePanM/code
static void
generate_assign_expression(DVM_Executable *exe, Block *block,
                           Expression *expr, OpcodeBuf *ob,
                           DVM_Boolean is_toplevel)
{
    if (expr->u.assign_expression.operator != NORMAL_ASSIGN) {
        generate_identifier_expression(exe, block, 
                                       expr->u.assign_expression.left,
                                       ob);
    }
    generate_expression(exe, block, expr->u.assign_expression.operand, ob);

    switch (expr->u.assign_expression.operator) {
    case NORMAL_ASSIGN :
        break;
    case ADD_ASSIGN:
        generate_code(ob, expr->line_number,
                      DVM_ADD_INT
                      + get_opcode_type_offset(expr->type->basic_type));
        break;
    case SUB_ASSIGN:
        generate_code(ob, expr->line_number,
                      DVM_SUB_INT
                      + get_opcode_type_offset(expr->type->basic_type));
        break;
    case MUL_ASSIGN:
        generate_code(ob, expr->line_number,
                      DVM_MUL_INT
                      + get_opcode_type_offset(expr->type->basic_type));
        break;
    case DIV_ASSIGN:
        generate_code(ob, expr->line_number,
                      DVM_DIV_INT
                      + get_opcode_type_offset(expr->type->basic_type));
        break;
    case MOD_ASSIGN:
        generate_code(ob, expr->line_number,
                      DVM_MOD_INT
                      + get_opcode_type_offset(expr->type->basic_type));
        break;
    default:
        DBG_assert(0, ("operator..%d\n", expr->u.assign_expression.operator));
    }

    if (!is_toplevel) {
        generate_code(ob, expr->line_number, DVM_DUPLICATE);
    }
    generate_pop_to_identifier(expr->u.assign_expression.left
                               ->u.identifier.u.declaration,
                               expr->line_number,
                               ob);
}
示例#23
0
文件: util.c 项目: zhumj1231/Crowbar
CRB_Value *
CRB_search_local_variable(CRB_LocalEnvironment *env, char *identifier)
{
    CRB_Value *value;
    CRB_Object  *sc; /* scope chain */

    if (env == NULL)
        return NULL;

    DBG_assert(env->variable->type == SCOPE_CHAIN_OBJECT,
               ("type..%d\n", env->variable->type));

    for (sc = env->variable; sc; sc = sc->u.scope_chain.next) {
        DBG_assert(sc->type == SCOPE_CHAIN_OBJECT,
                   ("sc->type..%d\n", sc->type));
        value = CRB_search_assoc_member(sc->u.scope_chain.frame, identifier);
        if (value)
            break;
    }

    return value;
}
示例#24
0
文件: native.c 项目: 3man/devlang
static DVM_Value
nv_print_proc(DVM_VirtualMachine *dvm,
              int arg_count, DVM_Value *args)
{
    DVM_Value ret;

    ret.int_value = 0;

    DBG_assert(arg_count == 1, ("arg_count..%d", arg_count));
    dvm_print_wcs(stdout, args[0].object->u.string.string);
    fflush(stdout);

    return ret;
}
示例#25
0
文件: util.c 项目: zhumj1231/Crowbar
CRB_Value *
CRB_add_local_variable(CRB_Interpreter *inter, CRB_LocalEnvironment *env,
                       char *identifier, CRB_Value *value,
                       CRB_Boolean is_final)
{
    CRB_Value *ret;

    DBG_assert(env->variable->type == SCOPE_CHAIN_OBJECT,
               ("type..%d\n", env->variable->type));

    ret = CRB_add_assoc_member(inter, env->variable->u.scope_chain.frame,
                               identifier, value, is_final);

    return ret;
}
示例#26
0
文件: generate.c 项目: BluePanM/code
static void
generate_statement_list(DVM_Executable *exe, Block *current_block,
                        StatementList *statement_list,
                        OpcodeBuf *ob)
{
    StatementList *pos;

    for (pos = statement_list; pos; pos = pos->next) {
        switch (pos->statement->type) {
        case EXPRESSION_STATEMENT:
            generate_expression_statement(exe, current_block,
                                          pos->statement->u.expression_s, ob);
            break;
        case IF_STATEMENT:
            generate_if_statement(exe, current_block, pos->statement, ob);
            break;
        case WHILE_STATEMENT:
            generate_while_statement(exe, current_block, pos->statement, ob);
            break;
        case FOR_STATEMENT:
            generate_for_statement(exe, current_block, pos->statement, ob);
            break;
        case FOREACH_STATEMENT:
            break;
        case RETURN_STATEMENT:
            generate_return_statement(exe, current_block, pos->statement, ob);
            break;
        case BREAK_STATEMENT:
            generate_break_statement(exe, current_block, pos->statement, ob);
            break;
        case CONTINUE_STATEMENT:
            generate_continue_statement(exe, current_block,
                                        pos->statement, ob);
            break;
        case TRY_STATEMENT:
            break;
        case THROW_STATEMENT:
            break;
        case DECLARATION_STATEMENT:
            generate_initializer(exe, current_block,
                                 pos->statement, ob);
            break;
        case STATEMENT_TYPE_COUNT_PLUS_1: /* FALLTHRU */
        default:
            DBG_assert(0, ("pos->statement->type..", pos->statement->type));
        }
    }
}
示例#27
0
文件: eval.c 项目: lyyyuna/sim_car
static void
push_value(SIMCAR_Interpreter *inter, SIMCAR_Value *value)
{
    DBG_assert(inter->stack.stack_pointer <= inter->stack.stack_alloc_size,
               ("stack_pointer..%d, stack_alloc_size..%d\n",
                inter->stack.stack_pointer, inter->stack.stack_alloc_size));

    if (inter->stack.stack_pointer == inter->stack.stack_alloc_size) {
        inter->stack.stack_alloc_size += STACK_ALLOC_SIZE;
        inter->stack.stack
            = MEM_realloc(inter->stack.stack,
                          sizeof(SIMCAR_Value) * inter->stack.stack_alloc_size);
    }
    inter->stack.stack[inter->stack.stack_pointer] = *value;
    inter->stack.stack_pointer++;
}
示例#28
0
文件: interface.c 项目: BluePanM/code
void
CRB_dispose_interpreter(CRB_Interpreter *interpreter)
{
    release_global_strings(interpreter);

    if (interpreter->execute_storage) {
        MEM_dispose_storage(interpreter->execute_storage);
    }
    interpreter->variable = NULL;
    crb_garbage_collect(interpreter);
    DBG_assert(interpreter->heap.current_heap_size == 0,
               ("%d bytes leaked.\n", interpreter->heap.current_heap_size));
    MEM_free(interpreter->stack.stack);
    crb_dispose_regexp_literals(interpreter);
    MEM_dispose_storage(interpreter->interpreter_storage);
}
示例#29
0
文件: generate.c 项目: BluePanM/code
static void
generate_code(OpcodeBuf *ob, int line_number, DVM_Opcode code, ...)
{
    va_list     ap;
    int         i;
    char        *param;
    int         param_count;
    int         start_pc;

    va_start(ap, code);

    param = dvm_opcode_info[(int)code].parameter;
    param_count = strlen(param);
    if (ob->alloc_size < ob->size + 1 + (param_count * 2)) {
        ob->code = MEM_realloc(ob->code, ob->alloc_size + OPCODE_ALLOC_SIZE);
        ob->alloc_size += OPCODE_ALLOC_SIZE;
    }

    start_pc = ob->size;
    ob->code[ob->size] = code;
    ob->size++;
    for (i = 0; param[i] != '\0'; i++) {
        unsigned int value = va_arg(ap, int);
        switch (param[i]) {
        case 'b': /* byte */
            ob->code[ob->size] = (DVM_Byte)value;
            ob->size++;
            break;
        case 's': /* short(2byte int) */
            ob->code[ob->size] = (DVM_Byte)(value >> 8);
            ob->code[ob->size+1] = (DVM_Byte)(value & 0xff);
            ob->size += 2;
            break;
        case 'p': /* constant pool index */
            ob->code[ob->size] = (DVM_Byte)(value >> 8);
            ob->code[ob->size+1] = (DVM_Byte)(value & 0xff);
            ob->size += 2;
            break;
        default:
            DBG_assert(0, ("param..%s, i..%d", param, i));
        }
    }
    add_line_number(ob, line_number, start_pc);

    va_end(ap);
}
示例#30
0
文件: generate.c 项目: BluePanM/code
static void
generate_binary_expression(DVM_Executable *exe, Block *block,
                           Expression *expr, DVM_Opcode code,
                           OpcodeBuf *ob)
{
    DBG_assert(expr->u.binary_expression.left->type->basic_type
               == expr->u.binary_expression.right->type->basic_type,
               ("left..%d, right..%d",
                expr->u.binary_expression.left->type->basic_type,
                expr->u.binary_expression.right->type->basic_type));

    generate_expression(exe, block, expr->u.binary_expression.left, ob);
    generate_expression(exe, block, expr->u.binary_expression.right, ob);
    generate_code(ob, expr->line_number,
                  code
                  + get_opcode_type_offset(expr->u.binary_expression.left
                                           ->type->basic_type));
}