Struct z80emu::z80::Z80

pub struct Z80<Q: Flavour> {
    pub flavour: Q,
    /* private fields */
}

Emulates a Zilog’s Z80 CPU in various “flavours” via the Cpu trait.

Fields

flavour: Q

Exposes an instance of the Flavour implementation.

Implementations

impl<Q: Flavour> Z80<Q>

pub fn new() -> Self

Creates a new instance of Z80 with the state just after RESET.

pub fn get_memptr(&self) -> u16

Retrieves the internal state of the MEMPTR register.

pub fn set_memptr(&mut self, memptr: u16)

Changes the internal state of the MEMPTR register.

pub fn normalize_r(&mut self)

The content of the R register is lazy evaluated when its value is being set or retrieved. This method normalizes the internal state of the R register, so e.g. two instances of Z80 can be compared if they represent the same CPU state.

pub fn into_flavour<F>(self) -> Z80<F>where
    F: From<Q> + Flavour,

Converts between instances of Z80 with different flavours.

NOTE: Some Flavour related information may be lost during conversion.

pub fn from_flavour<F: Flavour>(cpu: Z80<F>) -> Selfwhere
    Q: From<F>,

Converts between instances of Z80 with different flavours.

NOTE: Some Flavour related information may be lost during conversion.

Trait Implementations

impl<Q: Clone + Flavour> Clone for Z80<Q>

fn clone(&self) -> Z80<Q>

Returns a copy of the value.

fn clone_from(&mut self, source: &Self)

Performs copy-assignment from source.

impl<Q: Flavour> Cpu for Z80<Q>

fn reset(&mut self)

Instantly resets the Cpu to its initial state.

fn get_pc(&self) -> u16

Returns the current value of the program counter.

fn set_pc(&mut self, pc: u16)

Sets the current value of the program counter.

fn get_sp(&self) -> u16

Returns the current value of the stack pointer.

fn set_sp(&mut self, sp: u16)

Sets the current value of the stack pointer.

fn get_acc(&self) -> u8

Returns the Accumulator value as an unsigned 8-bit integer.

fn set_acc(&mut self, val: u8)

Sets the Accumulator value from an unsigned 8-bit integer.

fn get_flags(&self) -> CpuFlags

Returns the current state of the Flags register.

fn set_flags(&mut self, flags: CpuFlags)

Sets the current state of the Flags register.

fn inc_r(&mut self)

Increases the memory refresh counter.

fn add_r(&mut self, delta: i32)

Adds the arbitrary value to the memory refresh counter. This can be used to emulate the Cpu in the HALT state without executing the busy loop.

fn get_r(&self) -> u8

Returns the current value of the memory refresh register R.

fn set_r(&mut self, r: u8)

Sets the memory refresh register R value.

fn get_i(&self) -> u8

Returns the current value of the interrupt page I register.

fn set_i(&mut self, i: u8)

Sets the current value of the interrupt page I register.

fn get_ir(&self) -> u16

Returns the current memory refresh address.

fn get_iffs(&self) -> (bool, bool)

Returns values of interrupt flip-flops (iff1, iff2).

fn set_iffs(&mut self, iff1: bool, iff2: bool)

Sets the values of interrupt flip-flops.

fn halt(&mut self)

Forces Cpu to enter the HALT state. This doesn’t involve Clock and happens instantly. This also can be done by executing HALT instruction with Cpu::execute_instruction.

fn is_halt(&self) -> bool

Returns true if the Cpu is in the HALT state.

fn get_im(&self) -> InterruptMode

Returns the current interrupt mode.

fn set_im(&mut self, im: InterruptMode)

Sets the interrupt mode.

fn ex_af_af(&mut self)

Swaps the AF register with its alternative counterpart AF'.

fn exx(&mut self)

Swaps the BC, DE and HL registers with their alternative counterparts BC', DE' and HL'.

fn get_reg(&self, reg: Reg8, prefix: Option<Prefix>) -> u8

Returns the content of the selected 8-bit register.

fn set_reg(&mut self, dst: Reg8, prefix: Option<Prefix>, val: u8)

Sets the content of the selected 8-bit register.

fn get_reg2(&self, src: StkReg16) -> (u8, u8)

Returns the content of the selected pair of registers as a tuple of 8-bit unsigned integers.

fn get_alt_reg2(&self, src: StkReg16) -> (u8, u8)

Returns the content of the selected pair of alternative registers as a tuple of 8-bit unsigned integers.

fn get_reg16(&self, src: StkReg16) -> u16

Returns the content of the selected pair of registers as an unsigned 16-bit integer.

fn get_alt_reg16(&self, src: StkReg16) -> u16

Returns the content of the selected pair of alternative registers as an unsigned 16-bit integer.

fn set_reg2(&mut self, src: StkReg16, hi: u8, lo: u8)

Sets the content of the selected pair of registers.

fn set_reg16(&mut self, src: StkReg16, val: u16)

Sets the content of the selected pair of registers as an unsigned 16-bit integer.

fn get_index2(&self, prefix: Prefix) -> (u8, u8)

Returns the content of one of the index registers as a tuple of 8-bit unsigned integers.

fn get_index16(&self, prefix: Prefix) -> u16

Returns the content of one of the index registers as a 16-bit unsigned integer.

fn set_index2(&mut self, prefix: Prefix, hi: u8, lo: u8)

Sets the content of one of the index registers.

fn set_index16(&mut self, prefix: Prefix, val: u16)

Sets the content of one of the index registers as a 16-bit unsigned integer.

fn is_irq_allowed(&self) -> bool

Returns true if the Cpu will accept the interrupt request before executing the next opcode.

fn is_nmi_allowed(&self) -> bool

Returns true if the Cpu will accept the non-maskable interrupt before executing the next opcode.

fn restore_iff1(&mut self)

Restores the content of the interrupt flip-flop 1 from the content of the interrupt flip-flop 2. This is what RETN instruction usually does.

fn disable_interrupts(&mut self)

Disables the maskable interrupts by resetting both interrupt flip-flops to Off.

fn enable_interrupts(&mut self)

Enabes the maskable interrupts by setting both interrupt flip-flops to On.

fn is_after_ei(&self) -> bool

Returns true if the last command executed was EI.

fn is_after_prefix(&self) -> bool

Returns true if the last command executed was a 0xDD or a 0xFD prefix.

fn get_prefix(&self) -> Option<Prefix>

Returns the prefix value after executing the last command.

fn irq<M, T, F>(
    &mut self,
    control: &mut M,
    tsc: &mut T,
    debug: Option<F>
) -> Option<Result<M::WrIoBreak, M::RetiBreak>>where
    M: Memory<Timestamp = T::Timestamp> + Io<Timestamp = T::Timestamp>,
    T: Clock,
    F: FnOnce(CpuDebug),

Requests a maskable interrupt.

fn nmi<M, T>(&mut self, control: &mut M, tsc: &mut T) -> boolwhere
    M: Memory<Timestamp = T::Timestamp> + Io<Timestamp = T::Timestamp>,
    T: Clock,

Attempts to trigger a non-maskable interrupt.

fn execute_instruction<M, T, F>(
    &mut self,
    control: &mut M,
    tsc: &mut T,
    debug: Option<F>,
    code: u8
) -> Result<M::WrIoBreak, M::RetiBreak>where
    M: Memory<Timestamp = T::Timestamp> + Io<Timestamp = T::Timestamp>,
    T: Clock,
    F: FnOnce(CpuDebug),

Executes a single instruction given as code. If the instruction is a first byte of the multi-byte instruction the rest of the instruction body will be fetched via calls to Memory::read_opcode.

fn execute_next<M, T, F>(
    &mut self,
    control: &mut M,
    tsc: &mut T,
    debug: Option<F>
) -> Result<M::WrIoBreak, M::RetiBreak>where
    M: Memory<Timestamp = T::Timestamp> + Io<Timestamp = T::Timestamp>,
    T: Clock,
    F: FnOnce(CpuDebug),

Executes the next instruction present in the Memory at the program counter fetched via Memory::read_opcode.

fn execute_with_limit<M, T>(
    &mut self,
    control: &mut M,
    tsc: &mut T,
    vc_limit: T::Limit
) -> Result<M::WrIoBreak, M::RetiBreak>where
    M: Memory<Timestamp = T::Timestamp> + Io<Timestamp = T::Timestamp>,
    T: Clock,

Executes instructions until Clock reaches the given limit or when other conditions are met.

impl<Q: Flavour> Debug for Z80<Q>

fn fmt(&self, f: &mut Formatter<'_>) -> Result

Formats the value using the given formatter.

impl<Q: Default + Flavour> Default for Z80<Q>

fn default() -> Z80<Q>

Returns the “default value” for a type.

impl<'de, Q> Deserialize<'de> for Z80<Q>where
    Q: Flavour + Deserialize<'de>,

fn deserialize<D: Deserializer<'de>>(deserializer: D) -> Result<Self, D::Error>

Deserialize this value from the given Serde deserializer.

impl<Q: Flavour> From<Z80<Q>> for Z80Any

fn from(cpu: Z80<Q>) -> Z80Any

Converts to this type from the input type.

impl<Q> From<Z80Any> for Z80<Q>where
    Q: Flavour + From<NMOS> + From<CMOS> + From<BM1>,

fn from(cpu_any: Z80Any) -> Z80<Q>

Converts to this type from the input type.

impl<Q: PartialEq + Flavour> PartialEq<Z80<Q>> for Z80<Q>

fn eq(&self, other: &Z80<Q>) -> bool

This method tests for self and other values to be equal, and is used by ==.

fn ne(&self, other: &Rhs) -> bool

This method tests for !=. The default implementation is almost always sufficient, and should not be overridden without very good reason.

impl<Q: Flavour + Serialize> Serialize for Z80<Q>

fn serialize<S>(&self, serializer: S) -> Result<S::Ok, S::Error>where
    S: Serializer,

Serialize this value into the given Serde serializer.

impl<Q: Eq + Flavour> Eq for Z80<Q>

impl<Q: Flavour> StructuralEq for Z80<Q>

impl<Q: Flavour> StructuralPartialEq for Z80<Q>