Python Memory.get_int方法代码示例

# 需要导入模块: import Memory [as 别名]
# 或者: from Memory import get_int [as 别名]
def exec_jalr(inst):
    Memory.write_plain(Registers.read_fp(), read_pc())  # set return address
    func_obj = Memory.get_obj(Registers.get_reg(inst['rd']))
    if func_obj['type'] == 7:  # panel.readInt()
        num = int(raw_input('Please enter an integer.\n'))
        num_addr = Memory.new_int(num)
        Memory.write_plain(Registers.read_fp() - 12, num_addr)
        inc_pc(4)
    elif func_obj['type'] == 8:  # panel.readStr()
        string = raw_input('Please enter an string.\n')
        str_addr = Memory.new_str(string)
        Memory.write_plain(Registers.read_fp() - 12, str_addr)
        inc_pc(4)
    elif func_obj['type'] == 9:  # panel.show()
        arg = Memory.read_plain(Registers.read_fp() - 16)
        Memory.print_obj(arg)
        inc_pc(4)
    else:
        assert func_obj['type'] == 4
        func_addr = Registers.get_reg(inst['rd'])
        address_field = Memory.get_field(func_addr, Constants.get_str('address'))
        address_addr = Memory.get_prop(address_field)['value']
        address = Memory.get_int(address_addr)
        Memory.write_plain(Registers.read_fp(), read_pc() + 4)
        write_pc(address)

# 需要导入模块: import Memory [as 别名]
# 或者: from Memory import get_int [as 别名]
def exec_getvar(inst):
    func_addr = Memory.read_plain(Registers.read_fp() - 4)
    rs_val = Registers.get_reg(inst['rs'])
    while True:
        arg_field = Memory.get_field(func_addr, Constants.get_str('arguments'))
        arg_obj = Memory.get_prop(arg_field)['value']
        var_field = Memory.get_field(arg_obj, rs_val)
        if var_field:  # The field is found in arguments.
            offset_addr = Memory.get_prop(var_field)['value']
            offset = Memory.get_int(offset_addr)
            Registers.set_reg(inst['rd'], Memory.read_plain(Registers.read_fp() + offset))
            break
        scope_field = Memory.get_field(func_addr, Constants.get_str('scope'))
        scope_obj = Memory.get_prop(scope_field)['value']
        var_field = Memory.get_field(scope_obj, rs_val)
        if var_field:  # The field is found in scope.
            var_obj = Memory.get_prop(var_field)['value']
            Registers.set_reg(inst['rd'], var_obj)
            break
        outer_field = Memory.get_field(func_addr, Constants.get_str('outer'))
        outer_obj = Memory.get_prop(outer_field)['value']
        if not outer_obj:  # The field 'outer' is empty.
            func_addr = Memory.read_plain(Registers.read_fp() - 4)
            scope_field = Memory.get_field(func_addr, Constants.get_str('scope'))
            scope_obj = Memory.get_prop(scope_field)['value']
            prop_addr = Memory.new_field(scope_obj, rs_val)
            obj_addr = Memory.new_obj()
            Memory.set_prop(prop_addr, value=obj_addr)
            Registers.set_reg(inst['rd'], obj_addr)
            break
        else:
            func_addr = outer_obj
    inc_pc(4)

# 需要导入模块: import Memory [as 别名]
# 或者: from Memory import get_int [as 别名]
def set_reg(num, content):
    if num in [SP, FP]:
        Memory.get_int(content)  # check whether it points to an integer
    regs[num] = content

# 需要导入模块: import Memory [as 别名]
# 或者: from Memory import get_int [as 别名]
def read_fp():
    return Memory.get_int(regs[FP])

# 需要导入模块: import Memory [as 别名]
# 或者: from Memory import get_int [as 别名]
def read_sp():
    return Memory.get_int(regs[SP])

# 需要导入模块: import Memory [as 别名]
# 或者: from Memory import get_int [as 别名]
def exec_ld(inst):
    src_addr = Memory.get_int(Registers.get_reg(inst['rs'])) + inst['offset']
    Registers.set_reg(inst['rd'], Memory.read_plain(src_addr))
    inc_pc(4)

# 需要导入模块: import Memory [as 别名]
# 或者: from Memory import get_int [as 别名]
def init():
    for name in ['constructor', 'prototype', 'this', 'address', 'scope', 'outer', 'null', 'undefined',
                 'panel', 'readStr', 'readInt', 'integer', 'object', 'function', 'arguments']:
        Constants.get_str(name)

    for value in [1, 4]:
        Constants.get_int(value)

    addr = Memory.alloc(8)
    Memory.write(addr, {'type': 1, 'content': 5, 'object': {'type': 5}})  # null
    Constants.set_special('null', addr)

    addr = Memory.alloc(8)
    Memory.write(addr, {'type': 1, 'content': 6, 'object': {'type': 6}})  # undefined
    Constants.set_special('undefined', addr)

    Registers.set_sp(Memory.new_int(0x2FFFFFFC))  # sp
    Registers.set_fp(Memory.new_int(0x2FFFFFFC))  # fp

    # initialize runtime stack
    init_func = Memory.new_func()  # function 'init
    state['init_func'] = init_func
    fp_addr = Memory.get_int(Registers.get_fp())
    Memory.write_plain(fp_addr, 0)  # return address
    Memory.write_plain(fp_addr - 4, init_func)  # current function
    Memory.write_plain(fp_addr - 8, Memory.new_obj())  # this pointer
    Memory.write_plain(fp_addr - 12, 0)  # return value
    Memory.set_int(Registers.get_sp(), fp_addr - 16)

    # add function 'Object' into 'init'
    scope_field = Memory.get_field(init_func, Constants.get_str('scope'))
    scope_addr = Memory.get_prop(scope_field)['value']
    object_field = Memory.new_field(scope_addr, Constants.get_str('Object'))
    object_addr = Memory.new_obj()
    Memory.set_prop(object_field, value=object_addr)
    state['obj_func'] = object_addr

    # add object 'panel' into 'init'
    panel_field = Memory.new_field(scope_addr, Constants.get_str('panel'))
    panel_addr = Memory.new_obj()
    Memory.set_prop(panel_field, value=panel_addr)

    # add property 'readInt' into 'panel'
    read_int_prop = Memory.new_field(panel_addr, Constants.get_str('readInt'))
    read_int_func = Memory.new_func()
    Memory.set_prop(read_int_prop, value=read_int_func)
    read_int_obj = Memory.get_obj(read_int_func)
    read_int_obj['type'] = 7  # special type value
    Memory.set_obj(read_int_func, read_int_obj)

    # add property 'readStr' into 'panel'
    read_str_prop = Memory.new_field(panel_addr, Constants.get_str('readStr'))
    read_str_func = Memory.new_func()
    Memory.set_prop(read_str_prop, value=read_str_func)
    read_str_obj = Memory.get_obj(read_str_func)
    read_str_obj['type'] = 8
    Memory.set_obj(read_str_func, read_str_obj)

    # add property 'show' into 'panel'
    show_prop = Memory.new_field(panel_addr, Constants.get_str('show'))
    show_func = Memory.new_func()
    Memory.set_prop(show_prop, value=show_func)
    show_obj = Memory.get_obj(show_func)
    show_obj['type'] = 9
    Memory.set_obj(show_func, show_obj)

# 需要导入模块: import Memory [as 别名]
# 或者: from Memory import get_int [as 别名]
def exec_sub(inst):
    rs_val = Memory.get_int(Registers.get_reg(inst['rs']))
    rt_val = Memory.get_int(Registers.get_reg(inst['rt']))
    Memory.set_int(Registers.get_reg(inst['rd']), rs_val - rt_val)
    inc_pc(4)

# 需要导入模块: import Memory [as 别名]
# 或者: from Memory import get_int [as 别名]
def exec_st(inst):
    dest_addr = Memory.get_int(Registers.get_reg(inst['rs'])) + inst['offset']
    Memory.write_plain(dest_addr, Registers.get_reg(inst['rd']))
    inc_pc(4)