def fhook(self, ops, vm):
val_one, val_two = get_stack_operands(vm)
if val_two == 0:
raise DivisionZero()
result = opfunc.floordiv(abs(val_one), abs(val_two))
check_overflow(result, vm)
vm.stack[hex(vm.get_sp()).split('x')[-1].upper()] = result
vm.inc_sp()
def div(val1, val2):
"""There is a faster way to do division. Its called
division by reciprocal approximation. It takes about the same
time as a fl. pt. multiply. """
if val2 == 0.0:
raise DivisionZero()
else:
return mul(val1, 1 / val2)
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 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.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 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 ''