Struct moa_z80::state::Z80

pub struct Z80<Instant> {
    pub cputype: Z80Type,
    pub frequency: Frequency,
    pub state: Z80State,
    pub debugger: Z80Debugger,
    pub previous_cycle: Z80Cycle<Instant>,
    pub signals: Z80Signals,
}

Fields

cputype: Z80Type

frequency: Frequency

state: Z80State

debugger: Z80Debugger

previous_cycle: Z80Cycle<Instant>

signals: Z80Signals

Implementations

impl<Instant> Z80<Instant>

where Instant: EmuInstant,

pub(crate) fn begin<'a, Bus>( &'a mut self, clock: Instant, bus: &'a mut Bus ) -> Result<ExecuteNext<'a, &'a mut Bus, Instant>, Z80Error>

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

impl<Instant> Z80<Instant>

where Instant: EmuInstant,

pub fn new(cputype: Z80Type, frequency: Frequency) -> Self

pub fn from_type(cputype: Z80Type, frequency: Frequency) -> Self

pub fn clear_state(&mut self)

pub fn dump_state<W, Bus>( &mut self, writer: &mut W, _clock: Instant, bus: &mut Bus ) -> Result<(), Error>

where W: Write, Bus: BusAccess<Z80AddressSpace, Instant = Instant>,

Trait Implementations

impl<Instant: Clone> Clone for Z80<Instant>

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

Returns a copy of the value.

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

Performs copy-assignment from source.

impl<Bus, BusError, Instant, Writer> Debug<Z80AddressSpace, Bus, Writer> for Z80<Instant>

where Bus: BusAccess<Z80AddressSpace, Instant = Instant, Error = BusError>, BusError: ErrorType, Instant: EmuInstant, Writer: Write,

Control the execution of a CPU device for debugging purposes

type DebugError = Z80Error

Represents an error that can occur while debugging

fn get_execution_address(&mut self) -> Result<Z80AddressSpace, Self::DebugError>

Returns the Address where execution will take place the next time step() is called

fn set_execution_address( &mut self, address: Z80AddressSpace ) -> Result<(), Self::DebugError>

Sets the Address where execution will take place the next time step() is called

fn add_breakpoint(&mut self, address: Z80AddressSpace)

Add a breakpoint

fn remove_breakpoint(&mut self, address: Z80AddressSpace)

Remove a breakpoint

fn clear_breakpoints(&mut self)

Clear all breakpoints

impl<Bus, BusError, Instant, Writer> Inspect<Z80AddressSpace, Bus, Writer> for Z80<Instant>

where Bus: BusAccess<Z80AddressSpace, Instant = Instant, Error = BusError>, BusError: ErrorType, Instant: EmuInstant, Writer: Write,

type InfoType = Z80Info

A type that describes the types of information or state that this device can emit

type Error = Z80Error

A type that is returned if the data cannot be written as expected

fn inspect( &mut self, info: Self::InfoType, bus: &mut Bus, writer: &mut Writer ) -> Result<(), Self::Error>

Write the given information type to the given writer, or return an error

fn brief_summary( &mut self, bus: &mut Bus, writer: &mut Writer ) -> Result<(), Self::Error>

Write a brief summary of the device’s current state to the given writer, or return an error

fn detailed_summary( &mut self, bus: &mut Bus, writer: &mut Writer ) -> Result<(), Self::Error>

Write a detailed summary of the device’s current state to the given writer, or return an error

impl<Instant, Bus> Step<Z80AddressSpace, Bus> for Z80<Instant>

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

type Error = Z80Error

A type that is return if the step cannot be performed

fn is_running(&mut self) -> bool

Returns true if this device is still running. This can be used to detect a stop or halt condition

fn reset( &mut self, _now: Bus::Instant, _bus: &mut Bus ) -> Result<(), Self::Error>

Reset the device to its initial state, as if the device’s reset signal was asserted

fn step( &mut self, now: Bus::Instant, bus: &mut Bus ) -> Result<Bus::Instant, Self::Error>

Step the process by one unit of time, and return the time at which this function should be called again