def check_ld_16reg_immediate(self, op_codes, register_pair):
# given
little_endian_address = [random_byte(), random_byte()]
self.given_next_instruction_is(op_codes, little_endian_address)
# when
self.processor.execute()
# then
if register_pair == 'ix':
assert_equals(self.processor.index_registers['ix'], big_endian_value(little_endian_address))
elif register_pair == 'iy':
assert_equals(self.processor.index_registers['iy'], big_endian_value(little_endian_address))
elif register_pair == 'sp':
assert_equals(self.processor.special_registers['sp'], big_endian_value(little_endian_address))
else:
assert_equals(self.processor.main_registers[register_pair[0]], little_endian_address[1])
assert_equals(self.processor.main_registers[register_pair[1]], little_endian_address[0])
def execute(self, processor, memory, pc):
old_index = self.processor.index_registers[self.indexed_reg]
self.processor.index_registers[self.indexed_reg] = big_endian_value([
self.memory[self.processor.special_registers['sp']],
self.memory[0xffff & (self.processor.special_registers['sp'] + 1)]
])
high_byte, low_byte = high_low_pair(old_index)
self.memory[0xffff & self.processor.special_registers['sp']] = low_byte
self.memory[0xffff
& (self.processor.special_registers['sp'] + 1)] = high_byte
return 23, False, pc
def check_ld_16reg_immediate(self, op_codes, register_pair):
# given
little_endian_address = [random_byte(), random_byte()]
self.given_next_instruction_is(op_codes, little_endian_address)
# when
self.processor.execute()
# then
if register_pair == 'ix':
assert_equals(self.processor.index_registers['ix'],
big_endian_value(little_endian_address))
elif register_pair == 'iy':
assert_equals(self.processor.index_registers['iy'],
big_endian_value(little_endian_address))
elif register_pair == 'sp':
assert_equals(self.processor.special_registers['sp'],
big_endian_value(little_endian_address))
else:
assert_equals(self.processor.main_registers[register_pair[0]],
little_endian_address[1])
assert_equals(self.processor.main_registers[register_pair[1]],
little_endian_address[0])
def test_ld_ext_addr_from_a(self):
# given
register_value = random_byte()
self.given_register_contains_value('a', register_value)
little_endian_address = [random_byte(), random_byte()]
self.given_next_instruction_is(0x32, little_endian_address[0], little_endian_address[1])
# when
self.processor.execute()
# then
self.assert_pc_address().equals(0x0003)
assert_equals(self.memory[big_endian_value(little_endian_address)], register_value)
def test_ld_a_ext_addr(self):
# given
little_endian_address = [random_byte(), random_byte()]
self.given_next_instruction_is(0x3a, little_endian_address[0], little_endian_address[1])
memory_value = random_byte()
self.memory[big_endian_value(little_endian_address)] = memory_value
# when
self.processor.execute()
# then
self.assert_pc_address().equals(0x0003)
assert_equals(self.processor.main_registers['a'], memory_value)
def test_ld_a_ext_addr(self):
# given
little_endian_address = [random_byte(), random_byte()]
self.given_next_instruction_is(0x3a, little_endian_address[0],
little_endian_address[1])
memory_value = random_byte()
self.memory[big_endian_value(little_endian_address)] = memory_value
# when
self.processor.execute()
# then
self.assert_pc_address().equals(0x0003)
assert_equals(self.processor.main_registers['a'], memory_value)
def test_ld_ext_addr_from_a(self):
# given
register_value = random_byte()
self.given_register_contains_value('a', register_value)
little_endian_address = [random_byte(), random_byte()]
self.given_next_instruction_is(0x32, little_endian_address[0],
little_endian_address[1])
# when
self.processor.execute()
# then
self.assert_pc_address().equals(0x0003)
assert_equals(self.memory[big_endian_value(little_endian_address)],
register_value)
def check_push_without_wraparound(self, op_codes, register_pair):
lsb = random_byte()
msb = random_byte()
# given
if register_pair == 'ix' or register_pair == 'iy':
self.given_register_contains_value(register_pair, big_endian_value([lsb, msb]))
else:
self.given_register_contains_value(register_pair[0], msb)
self.given_register_contains_value(register_pair[1], lsb)
self.given_stack_pointer_is(0xffff)
self.given_next_instruction_is(op_codes)
# when
self.processor.execute()
# then
assert_equals(self.processor.special_registers['sp'], 0xfffd)
assert_equals(self.memory[0xfffe], msb)
assert_equals(self.memory[0xfffd], lsb)
def check_pop_without_workaround(self, op_codes, register_pair):
# given
msb = random_byte()
lsb = random_byte()
self.memory[0xfff0] = lsb
self.memory[0xfff1] = msb
self.given_stack_pointer_is(0xfff0)
self.given_next_instruction_is(op_codes)
# when
self.processor.execute()
# then
assert_equals(self.processor.special_registers['sp'], 0xfff2)
if register_pair == 'ix' or register_pair == 'iy':
assert_equals(self.processor.index_registers[register_pair], big_endian_value([lsb, msb]))
else:
assert_equals(self.processor.main_registers[register_pair[0]], msb)
assert_equals(self.processor.main_registers[register_pair[1]], lsb)
def check_push_without_wraparound(self, op_codes, register_pair):
lsb = random_byte()
msb = random_byte()
# given
if register_pair == 'ix' or register_pair == 'iy':
self.given_register_contains_value(register_pair,
big_endian_value([lsb, msb]))
else:
self.given_register_contains_value(register_pair[0], msb)
self.given_register_contains_value(register_pair[1], lsb)
self.given_stack_pointer_is(0xffff)
self.given_next_instruction_is(op_codes)
# when
self.processor.execute()
# then
assert_equals(self.processor.special_registers['sp'], 0xfffd)
assert_equals(self.memory[0xfffe], msb)
assert_equals(self.memory[0xfffd], lsb)
def check_pop_without_workaround(self, op_codes, register_pair):
# given
msb = random_byte()
lsb = random_byte()
self.memory[0xfff0] = lsb
self.memory[0xfff1] = msb
self.given_stack_pointer_is(0xfff0)
self.given_next_instruction_is(op_codes)
# when
self.processor.execute()
# then
assert_equals(self.processor.special_registers['sp'], 0xfff2)
if register_pair == 'ix' or register_pair == 'iy':
assert_equals(self.processor.index_registers[register_pair],
big_endian_value([lsb, msb]))
else:
assert_equals(self.processor.main_registers[register_pair[0]], msb)
assert_equals(self.processor.main_registers[register_pair[1]], lsb)
def execute(self, processor, memory, pc):
src_address, pc = fetch_word(memory, pc)
low_byte = self.memory[0xffff & src_address]
high_byte = self.memory[0xffff & (src_address + 1)]
self.processor.index_registers[self.indexed_reg] = big_endian_value([low_byte, high_byte])
return 20, False, pc
def fetch_word(memory, pc):
return big_endian_value([memory[pc],
memory[(pc + 1) & 0xffff]]), (pc + 2) & 0xffff
def execute(self, processor, memory, pc):
lsb = self.processor.pop_byte()
msb = self.processor.pop_byte()
self.processor.index_registers[self.indexed_reg] = big_endian_value([lsb, msb])
return 14, False, pc
def fetch_word(memory, pc):
return big_endian_value([memory[pc], memory[(pc + 1) & 0xffff]]), (pc + 2) & 0xffff
def execute(self, processor, memory, pc):
self.processor.special_registers['sp'] = big_endian_value([self.processor.main_registers['l'],
self.processor.main_registers['h']])
return 6, False, pc
def execute(self, processor, memory, pc):
lsb = self.processor.pop_byte()
msb = self.processor.pop_byte()
self.processor.index_registers[self.indexed_reg] = big_endian_value(
[lsb, msb])
return 14, False, pc
