Struct moa_z80::execute::ExecuteNext

pub(crate) struct ExecuteNext<'a, Bus, Instant>
where
    Bus: BusAccess<Z80AddressSpace, Instant = Instant>,
{
    state: &'a mut Z80State,
    signals: &'a mut Z80Signals,
    debugger: &'a mut Z80Debugger,
    cycle: Z80Cycle<Instant>,
    bus: Bus,
}

Fields

state: &'a mut Z80State

signals: &'a mut Z80Signals

debugger: &'a mut Z80Debugger

cycle: Z80Cycle<Instant>

bus: Bus

Implementations

impl<'a, Bus, Instant> ExecuteNext<'a, Bus, Instant>

where Bus: BusAccess<Z80AddressSpace, Instant = Instant>, Instant: EmuInstant,

pub(crate) fn end(self) -> Z80Cycle<Instant>

pub(crate) fn step_one(&mut self) -> Result<u16, Z80Error>

fn step_internal(&mut self) -> Result<u16, Z80Error>

fn init(&mut self) -> Result<u16, Z80Error>

fn reset(&mut self) -> Result<u16, Z80Error>

fn cycle_one(&mut self) -> Result<u16, Z80Error>

fn decode_next(&mut self) -> Result<(), Z80Error>

fn execute_current(&mut self) -> Result<(), Z80Error>

fn execute_adca(&mut self, target: Target) -> Result<(), Z80Error>

fn execute_adc16( &mut self, dest_pair: RegisterPair, src_pair: RegisterPair ) -> Result<(), Z80Error>

fn execute_adda(&mut self, target: Target) -> Result<(), Z80Error>

fn execute_add16( &mut self, dest_pair: RegisterPair, src_pair: RegisterPair ) -> Result<(), Z80Error>

fn execute_and(&mut self, target: Target) -> Result<(), Z80Error>

fn execute_bit(&mut self, bit: u8, target: Target) -> Result<(), Z80Error>

fn execute_call(&mut self, addr: u16) -> Result<(), Z80Error>

fn execute_callcc(&mut self, cond: Condition, addr: u16) -> Result<(), Z80Error>

fn execute_ccf(&mut self) -> Result<(), Z80Error>

fn execute_cp(&mut self, target: Target) -> Result<(), Z80Error>

fn execute_cpl(&mut self) -> Result<(), Z80Error>

fn execute_daa(&mut self) -> Result<(), Z80Error>

fn execute_dec16(&mut self, regpair: RegisterPair) -> Result<(), Z80Error>

fn execute_dec8(&mut self, target: Target) -> Result<(), Z80Error>

fn execute_di(&mut self) -> Result<(), Z80Error>

fn execute_djnz(&mut self, offset: i8) -> Result<(), Z80Error>

fn execute_ei(&mut self) -> Result<(), Z80Error>

fn execute_exx(&mut self) -> Result<(), Z80Error>

fn execute_ex_af_af(&mut self) -> Result<(), Z80Error>

fn execute_ex_hl_de(&mut self) -> Result<(), Z80Error>

fn execute_ex_sp(&mut self, regpair: RegisterPair) -> Result<(), Z80Error>

fn execute_halt(&mut self) -> Result<(), Z80Error>

fn execute_im(&mut self, mode: InterruptMode) -> Result<(), Z80Error>

fn execute_inc16(&mut self, regpair: RegisterPair) -> Result<(), Z80Error>

fn execute_inc8(&mut self, target: Target) -> Result<(), Z80Error>

fn execute_ini(&mut self) -> Result<(), Z80Error>

fn execute_inic(&mut self, reg: Register) -> Result<(), Z80Error>

fn execute_inx(&mut self, n: u8) -> Result<(), Z80Error>

fn execute_jp(&mut self, addr: u16) -> Result<(), Z80Error>

fn execute_jp_indirect(&mut self, regpair: RegisterPair) -> Result<(), Z80Error>

fn execute_jpcc(&mut self, cond: Condition, addr: u16) -> Result<(), Z80Error>

fn execute_jr(&mut self, offset: i8) -> Result<(), Z80Error>

fn execute_jrcc(&mut self, cond: Condition, offset: i8) -> Result<(), Z80Error>

fn execute_ld( &mut self, dest: LoadTarget, src: LoadTarget ) -> Result<(), Z80Error>

fn execute_ldsr( &mut self, special_reg: SpecialRegister, dir: Direction ) -> Result<(), Z80Error>

fn execute_ldx(&mut self) -> Result<(), Z80Error>

fn execute_neg(&mut self) -> Result<(), Z80Error>

fn execute_or(&mut self, target: Target) -> Result<(), Z80Error>

fn execute_outic(&mut self, reg: Register) -> Result<(), Z80Error>

fn execute_outx(&mut self, n: u8) -> Result<(), Z80Error>

fn execute_pop(&mut self, regpair: RegisterPair) -> Result<(), Z80Error>

fn execute_push(&mut self, regpair: RegisterPair) -> Result<(), Z80Error>

fn execute_res( &mut self, bit: u8, target: Target, opt_copy: UndocumentedCopy ) -> Result<(), Z80Error>

fn execute_ret(&mut self) -> Result<(), Z80Error>

fn execute_reti(&mut self) -> Result<(), Z80Error>

fn execute_retn(&mut self) -> Result<(), Z80Error>

fn execute_retcc(&mut self, cond: Condition) -> Result<(), Z80Error>

fn execute_rl( &mut self, target: Target, opt_copy: UndocumentedCopy ) -> Result<(), Z80Error>

fn execute_rla(&mut self) -> Result<(), Z80Error>

fn execute_rlc( &mut self, target: Target, opt_copy: UndocumentedCopy ) -> Result<(), Z80Error>

fn execute_rlca(&mut self) -> Result<(), Z80Error>

fn execute_rld(&mut self) -> Result<(), Z80Error>

fn execute_rr( &mut self, target: Target, opt_copy: UndocumentedCopy ) -> Result<(), Z80Error>

fn execute_rra(&mut self) -> Result<(), Z80Error>

fn execute_rrc( &mut self, target: Target, opt_copy: UndocumentedCopy ) -> Result<(), Z80Error>

fn execute_rrca(&mut self) -> Result<(), Z80Error>

fn execute_rrd(&mut self) -> Result<(), Z80Error>

fn execute_rst(&mut self, addr: u8) -> Result<(), Z80Error>

fn execute_sbca(&mut self, target: Target) -> Result<(), Z80Error>

fn execute_sbc16( &mut self, dest_pair: RegisterPair, src_pair: RegisterPair ) -> Result<(), Z80Error>

fn execute_scf(&mut self) -> Result<(), Z80Error>

fn execute_set( &mut self, bit: u8, target: Target, opt_copy: UndocumentedCopy ) -> Result<(), Z80Error>

fn execute_sla( &mut self, target: Target, opt_copy: UndocumentedCopy ) -> Result<(), Z80Error>

fn execute_sll( &mut self, target: Target, opt_copy: UndocumentedCopy ) -> Result<(), Z80Error>

fn execute_sra( &mut self, target: Target, opt_copy: UndocumentedCopy ) -> Result<(), Z80Error>

fn execute_srl( &mut self, target: Target, opt_copy: UndocumentedCopy ) -> Result<(), Z80Error>

fn execute_sub(&mut self, target: Target) -> Result<(), Z80Error>

fn execute_xor(&mut self, target: Target) -> Result<(), Z80Error>

fn rotate_left(&mut self, value: u8, rtype: RotateType) -> (u8, bool)

fn rotate_right(&mut self, value: u8, rtype: RotateType) -> (u8, bool)

fn add_to_regpair(&mut self, regpair: RegisterPair, value: i16) -> u16

fn push_word(&mut self, value: u16) -> Result<(), Z80Error>

fn pop_word(&mut self) -> Result<u16, Z80Error>

fn get_load_target_value(&mut self, target: LoadTarget) -> Result<u16, Z80Error>

fn set_load_target_value( &mut self, target: LoadTarget, value: u16 ) -> Result<(), Z80Error>

fn get_target_value(&mut self, target: Target) -> Result<u8, Z80Error>

fn set_target_value( &mut self, target: Target, value: u8 ) -> Result<(), Z80Error>

fn increment_refresh(&mut self, count: u8)

fn read_port_u8(&mut self, addr: u16) -> Result<u8, Z80Error>

fn write_port_u8(&mut self, addr: u16, value: u8) -> Result<(), Z80Error>

fn read_port_u16(&mut self, addr: u16) -> Result<u16, Z80Error>

Read a u16 value through this CPU’s memory port

Since the memory port is only able to read 8 bits at a time, this does two reads in little endian byte order

fn write_port_u16(&mut self, addr: u16, value: u16) -> Result<(), Z80Error>

Write a u16 value through this CPU’s memory port

Since the memory port is only able to read 8 bits at a time, this does two writes in little endian byte order

fn read_ioport_value(&mut self, upper: u8, lower: u8) -> Result<u8, Z80Error>

fn write_ioport_value( &mut self, upper: u8, lower: u8, value: u8 ) -> Result<(), Z80Error>

fn get_register_value(&mut self, reg: Register) -> u8

fn set_register_value(&mut self, reg: Register, value: u8)

fn get_index_register_half_value(&mut self, reg: IndexRegisterHalf) -> u8

fn set_index_register_half_value(&mut self, reg: IndexRegisterHalf, value: u8)

fn get_register_pair_value(&mut self, regpair: RegisterPair) -> u16

fn set_register_pair_value(&mut self, regpair: RegisterPair, value: u16)

fn get_index_register_value(&mut self, reg: IndexRegister) -> u16

fn get_current_condition(&mut self, cond: Condition) -> bool

fn set_numeric_flags(&mut self, value: u16, size: Size)

fn set_parity_flags(&mut self, value: u8)

fn set_arithmetic_op_flags( &mut self, value: u16, size: Size, addsub: bool, carry: bool, overflow: bool, half_carry: bool )

fn set_logic_op_flags(&mut self, value: u8, carry: bool, half_carry: bool)

fn get_flag(&self, flag: Flags) -> bool

fn set_flag(&mut self, flag: Flags, value: bool)

fn get_flags(&self) -> u8

fn set_flags(&mut self, mask: u8, values: u8)