Enum z80emu::z80::any::Z80Any

pub enum Z80Any {
    NMOS(Z80<NMOS>),
    CMOS(Z80<CMOS>),
    BM1(Z80<BM1>),
}

Z80 with any Flavour.

This enum can be used in place of Z80 when changing of Flavour is required in run time.

Variants

NMOS(Z80<NMOS>)

CMOS(Z80<CMOS>)

BM1(Z80<BM1>)

Implementations

impl Z80Any

pub fn tag(&self) -> &'static str

Returns the tag of the current Z80 variant as string.

pub fn with_tag(tag: &str) -> Option<Self>

Creates a new instance of Z80Any with the given tag on success with the state just after RESET.

Returns None if the provided tag is unknown.

pub fn new_nmos() -> Z80Any

Creates a new instance of Z80Any::NMOS variant with the state just after RESET.

pub fn new_cmos() -> Z80Any

Creates a new instance of Z80Any::CMOS variant with the state just after RESET.

pub fn new_bm1() -> Z80Any

Creates a new instance of Z80Any::BM1 variant with the state just after RESET.

pub fn is_nmos(&self) -> bool

Returns true if the variant of self is Z80Any::NMOS.

pub fn is_cmos(&self) -> bool

Returns true if the variant of self is Z80Any::CMOS.

pub fn is_bm1(&self) -> bool

Returns true if the variant of self is Z80Any::BM1.

pub fn into_nmos(self) -> Z80Any

Converts an instance of any variant of Z80Any to a Z80Any::NMOS variant.

pub fn into_cmos(self) -> Z80Any

Converts an instance of any variant of Z80Any to a Z80Any::CMOS variant.

pub fn into_bm1(self) -> Z80Any

Converts an instance of any variant of Z80Any to a Z80Any::BM1 variant.

pub fn unwrap_nmos(self) -> Z80<NMOS>

Returns the contained Z80<NMOS> value, consuming the self value.

Panics

Panics if the self value is not a Z80Any::NMOS variant.

pub fn unwrap_cmos(self) -> Z80<CMOS>

Returns the contained Z80<CMOS> value, consuming the self value.

Panics

Panics if the self value is not a Z80Any::CMOS variant.

pub fn unwrap_bm1(self) -> Z80<BM1>

Returns the contained Z80<BM1> value, consuming the self value.

Panics

Panics if the self value is not a Z80Any::BM1 variant.

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.

Trait Implementations

impl Clone for Z80Any

fn clone(&self) -> Z80Any

Returns a copy of the value.

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

Performs copy-assignment from source.

impl Cpu for Z80Any

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) -> bool where
    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 Debug for Z80Any

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

Formats the value using the given formatter.

impl Default for Z80Any

fn default() -> Z80Any

Returns the "default value" for a type.

impl<'de> Deserialize<'de> for Z80Any

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

Deserialize this value from the given Serde deserializer.

impl Display for Z80Any

Displays the tag of the current Z80 variant.

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

Formats the value using the given formatter.

impl Eq for Z80Any

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

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

Performs the conversion.

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

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

Performs the conversion.

impl PartialEq<Z80Any> for Z80Any

fn eq(&self, other: &Z80Any) -> bool

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

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

This method tests for !=.

impl Serialize for Z80Any

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

Serialize this value into the given Serde serializer.

impl StructuralEq for Z80Any

impl StructuralPartialEq for Z80Any