def fhook(self, ops, vm):
check_num_args(self.get_nm(), ops, 2)
ops[0].set_val(ops[1].get_val())
if isinstance(ops[0], Register):
vm.changes.add(ops[0].get_nm())
elif isinstance(ops[0], Address):
vm.changes.add(f'MEM{ops[0].get_mem_addr()}')
def get_three_ops_imm(instr, ops):
'''
Same concept as the function above.
'''
check_num_args(instr, ops, 3)
check_immediate_three(instr, ops)
return (ops[0], ops[1], ops[2])
def get_two_op_imm(instr, ops):
"""
Again, same as above, except for reg, imm format
"""
check_num_args(instr, ops, 2)
check_immediate_two(instr, ops)
return (ops[0], ops[1])
def fhook(self, ops, vm):
check_num_args("CALL", ops, 1)
vm.dec_sp()
vm.stack[hex(vm.get_sp() + 1).split('x')[-1].upper()] = vm.get_ip()
target = get_one_op(self.get_nm(), ops)
vm.c_stack.append(vm.get_ip())
raise Jump(target.name)
def fhook(self, ops, vm):
check_num_args(self.name, ops, 3)
check_reg_only(self.name, ops)
ops[0].set_val(
check_overflow(
opfunc.mod(abs(ops[1].get_val()), abs(ops[2].get_val())), vm))
vm.changes.add(ops[0].get_nm())
def fhook(self, ops, vm):
check_num_args(self.name, ops, 3)
check_reg_only(self.name, ops)
fixed_op2 = ops[2].get_val() % 32
ops[0].set_val(
check_overflow(opfunc.lshift(ops[1].get_val(), fixed_op2), vm))
vm.changes.add(ops[0].get_nm())
def fhook(self, ops, vm):
check_num_args(self.name, ops, 1)
if not isinstance(ops[0], Register):
raise InvalidArgument(ops[0].get_nm())
ops[0].set_val(vm.registers['LO'])
vm.changes.add(ops[0].get_nm())
return ''
def fhook(self, ops, vm):
check_num_args(self.get_nm(), ops, 1)
if isinstance(ops[0], NewSymbol):
vm.locals[ops[0].get_nm()] = ops[0].get_val()
vm.changes.add(f'LOCALVAR{ops[0].get_nm()}')
else:
raise InvalidArgument(ops[0].get_nm())
def fhook(self, ops, vm):
check_num_args(self.get_nm(), ops, 1)
if vm.is_FP_stack_full():
raise StackFull()
# if isinstance(ops[0], FloatTok):
# vm.push_to_Float_Stack(ops[0].get_val())
vm.push_to_Float_Stack(ops[0].get_val())
def fhook(self, ops, vm):
check_num_args(self.get_nm(), ops, 2, type_ins=1)
if isinstance(ops[0], Register):
checkEven(ops[0])
if isinstance(ops[1], RegAddress):
reg_number = int(ops[0].get_nm()[1:])
curr_reg = "F" + str(reg_number + 0)
next_reg = "F" + str(reg_number + 1)
first_half = vm.registers[curr_reg]
second_half = vm.registers[next_reg]
full_b = first_half + second_half
v = b_to_f64(full_b)
ops[1].set_val(v)
# deprecated code below
# print(ops[0])
# first_half = ops[0].get_val()
# reg_name = "F" + str(int(ops[0].get_nm()[1:]))
# second_half = vm.registers[reg_name]
# full_b = first_half + second_half
# print("full_b", full_b)
# v = b_to_f64(full_b)
# ops[1].set_val(v)
else:
InvalidArgument(ops[1].get_nm())
else:
raise InvalidArgument(ops[0].get_nm())
def two_op_arith(ops, vm, instr, operator):
"""
operator: this is the functional version of Python's
+, -, *, etc.
"""
check_num_args(instr, ops, 2)
ops[0].set_val(checkflag(operator(ops[0].get_val(), ops[1].get_val()), vm))
vm.changes.add(ops[0].get_nm())
def fhook(self, ops, vm):
check_num_args(self.get_nm(), ops, 2)
if isinstance(ops[0], Register):
if isinstance(ops[1], RegAddress):
ops[1].set_val(ops[0].get_val())
else:
InvalidArgument(ops[1].get_nm())
else:
raise InvalidArgument(ops[0].get_nm())
def fhook(self, ops, vm):
check_num_args("RET", ops, 0)
vm.inc_sp()
vm.set_ip(int(vm.stack[hex(vm.get_sp()).split('x')[-1].upper()]))
vm.stack[hex(vm.get_sp()).split('x')[-1].upper()] = vm.empty_cell()
while not isinstance(vm.c_stack[-1], int):
vm.c_stack.pop()
if isinstance(vm.c_stack[-1], int):
vm.c_stack.pop()
def get_three_ops(instr, ops):
'''
Function to grab the values in registers.
Put in a separate so that we don't have to write out the checks
all the time.
'''
check_num_args(instr, ops, 3)
check_reg_only(instr, ops)
return (ops[0], ops[1], ops[2])
def one_op_arith(ops, vm, instr, operator):
"""
operator: this is the functional version of Python's
+, -, *, etc.
"""
check_num_args(instr, ops, 1)
if operator.__name__ == 'div' and ops[0].get_val() == 0.0:
raise DivisionZero()
else:
vm.registers["ST0"] = operator(vm.registers["ST0"], ops[0].get_val())
def three_op_arith_immediate(ops, vm, instr, operator):
"""
operator: this is the functional version of Python's
+, -, *, etc.
"""
check_num_args(instr, ops, 3)
check_immediate_three(instr, ops)
ops[0].set_val(
check_overflow(operator(ops[1].get_val(), ops[2].get_val()), vm))
vm.changes.add(ops[0].get_nm())
def fhook(self, ops, vm):
check_num_args(self.get_nm(), ops, 1)
if type(ops[0]) != IntegerTok:
raise InvalidOperand(str(ops[0]))
try:
interrupt_class = int_vectors[ops[0].get_val()]
interrupt_handler = interrupt_class[int(vm.registers[EAX])]
except KeyError:
raise UnknownInt(str(ops[0].get_val()) + ": " + vm.registers[EAX])
c = interrupt_handler(vm, self.get_nm())
return str(c)
def fhook(self, ops, vm):
check_num_args(self.get_nm(), ops, 1)
if isinstance(ops[0], IntegerTok):
try:
stack_loc = hex(vm.get_sp()).split('x')[-1].upper()
vm.stack[stack_loc] = ops[0].get_val()
vm.inc_sp()
except Exception:
raise InvalidArgument(ops[0].get_nm())
else:
raise InvalidArgument(ops[0].get_nm())
def fhook(self, ops, vm):
check_num_args(self.get_nm(), ops, 1)
if isinstance(ops[0], NewSymbol):
if ops[0].get_nm() in vm.locals:
stack_loc = hex(vm.get_sp()).split('x')[-1].upper()
vm.stack[stack_loc] = vm.locals[ops[0].get_nm()]
vm.inc_sp()
else:
raise InvalidArgument(ops[0].get_nm())
else:
raise InvalidArgument(ops[0].get_nm())
def fhook(self, ops, vm):
check_num_args(self.get_nm(), ops, 2)
if isinstance(ops[0], Register):
checkEven(ops[0])
if isinstance(ops[1], RegAddress):
# if (float(ops[0].get_val()) > float(2 ** 22)):
# raise TooBigForSingle(str(float(ops[0].get_val())))
ops[1].set_val(float(ops[0].get_val()))
else:
InvalidArgument(ops[1].get_nm())
else:
raise InvalidArgument(ops[0].get_nm())
def fhook(self, ops, vm):
check_num_args(self.name, ops, 2)
check_reg_only(self.name, ops)
result = ops[0].get_val() * ops[1].get_val()
if result > 2**32 - 1:
vm.registers['LO'] = opfunc.lshift(result, 32)
vm.registers['HI'] = opfunc.rshift(result, 32)
else:
vm.registers['LO'] = result
vm.registers['HI'] = 0
vm.changes.add('LO')
vm.changes.add('HI')
return ''
def fhook(self, ops, vm):
check_num_args(self.name, ops, 2)
check_reg_only(self.name, ops)
if ops[1].get_val() == 0:
raise DivisionZero()
quotient = ops[0].get_val() // ops[1].get_val()
remainder = ops[0].get_val() % ops[1].get_val()
vm.registers['LO'] = quotient
vm.registers['HI'] = remainder
vm.changes.add('LO')
vm.changes.add('HI')
return ''
def fhook(self, ops, vm):
check_num_args(self.get_nm(), ops, 1)
if isinstance(ops[0], NewSymbol):
if ops[0].get_nm() in vm.globals:
vm.dec_sp()
stack_loc = hex(vm.get_sp()).split('x')[-1].upper()
vm.globals[ops[0].get_nm()] = vm.stack[stack_loc]
vm.inc_sp()
vm.changes.add(f'GLOBALVAR{ops[0].get_nm()}')
else:
raise InvalidArgument(ops[0].get_nm())
else:
raise InvalidArgument(ops[0].get_nm())
def fhook(self, ops, vm):
check_num_args(self.name, ops, 1)
hireg = int(vm.registers['EDX']) << 32
lowreg = int(vm.registers['EAX'])
dividend = hireg + lowreg
if ops[0].get_val() == 0:
raise DivisionZero()
vm.registers['EAX'] = dividend // ops[0].get_val()
vm.registers['EDX'] = dividend % ops[0].get_val()
vm.changes.add('EAX')
vm.changes.add('EDX')
return ''
def pop_arith(ops, vm, instr, operator):
check_num_args(instr, ops, 2)
reg_one, reg_two = [int(x.get_nm()[-1]) for x in ops]
# first_reg = vm.get_float_stack_register_at_offset(offset1)
# second_reg = vm.get_float_stack_register_at_offset(offset2)
# r1 = vm.fp_stack_registers[first_reg]
# r2 = vm.fp_stack_registers[second_reg]
# vm.fp_stack_registers[first_reg] = checkflag(operator(r1, r2), vm)
if reg_two != 0:
raise InvalidOperand(f'ST{reg_two}')
r1 = vm.registers[f'ST{reg_one}']
r2 = vm.registers[f'ST{reg_two}']
vm.registers[f'ST{reg_one}'] = checkflag(float(operator(r1, r2)), vm)
def fhook(self, ops, vm):
check_num_args(self.name, ops, 3, type_ins=1)
check_reg_only(self.name, ops)
if ops[2].get_val() == 0:
raise DivisionZero()
result = ops[1].get_val() / ops[2].get_val()
# this is the single version of div for floats
# so we don't want to be bigger than max single
if (result > 2**22):
raise TooBigForSingle(str(result))
ops[0].set_val(result)
vm.changes.add(ops[0].get_nm())
return ''
def fhook(self, ops, vmachine):
check_num_args(self.name, ops, 2)
num = ops[1].get_val()
if num == 0:
vmachine.flags["ZF"] = 1
else:
vmachine.flags["ZF"] = 0
if ops[1].get_val().bit_length() <= 16:
bit_size = 16
else:
bit_size = 32
binStr = str(bin(num))[2:].zfill(bit_size)
for index in range(len(binStr)):
if binStr[index] == '1':
break
index = bit_size - index
ops[0].set_val(index)
def three_op_arith_reg(ops, vm, instr, operator):
"""
operator: this is the functional version of Python's
+, -, *, etc.
"""
check_num_args(instr, ops, 3, type_ins=1)
check_reg_only(instr, ops)
# go through the register ops and make sure that they're even numbered
for op in ops:
checkEven(op)
ops[0].set_val(operator(ops[1].get_val(), ops[2].get_val()))
# check_overflow(operator(ops[1].get_val(),
# ops[2].get_val()),
# vm))
vm.changes.add(ops[0].get_nm())
def two_op_arith(ops, vm, instr, operator):
"""
operator: this is the functional version of Python's
+, -, *, etc.
"""
check_num_args(instr, ops, 2)
reg_one, reg_two = [int(x.get_nm()[-1]) for x in ops]
# first_reg = vm.get_float_stack_register_at_offset(offset1)
# second_reg = vm.get_float_stack_register_at_offset(offset2)
# r1 = vm.fp_stack_registers[first_reg]
# r2 = vm.fp_stack_registers[second_reg]
# vm.fp_stack_registers[first_reg] = checkflag(operator(r1, r2), vm)
if reg_one != 0 and reg_two != 0:
raise InvalidOperand('Neither registers are ST0')
r1 = vm.registers[f'ST{reg_one}']
r2 = vm.registers[f'ST{reg_two}']
vm.registers[f'ST{reg_one}'] = checkflag(operator(r1, r2), vm)
def fhook(self, ops, vm):
check_num_args("BNE", ops, 3)
disp = 0
if isinstance(ops[2], IntegerTok):
disp = ops[2].get_val()
else:
raise InvalidArgument(ops[0].get_nm())
val_one, val_two = (0, 0)
if isinstance(ops[0], Register):
val_one = ops[0].get_val()
if isinstance(ops[1], Register):
val_two = ops[1].get_val()
else:
InvalidArgument(ops[1].get_nm())
else:
InvalidArgument(ops[0].get_nm())
if val_one != val_two:
current_ip = vm.get_ip()
if current_ip + disp * 4 >= 0:
vm.set_ip(current_ip + disp * 4)
else:
raise OutofBounds()
