Enum moa_z80::state::Z80AddressSpace

pub enum Z80AddressSpace {
    Memory(Z80Address),
    IO(Z80IOAddress),
}

Variants

Memory(Z80Address)

IO(Z80IOAddress)

Trait Implementations

impl<MemBus, IOBus, Instant> BusAccess<Z80AddressSpace> for Z80Port<MemBus, IOBus, Instant>

where Instant: EmuInstant, MemBus: BusAccess<Z80Address, Instant = Instant>, IOBus: BusAccess<Z80IOAddress, Instant = Instant>,

type Instant = Instant

The type of an instant in simulated time that the bus access is meant to occur at

type Error = Z80BusError<<MemBus as BusAccess<u16>>::Error, <IOBus as BusAccess<u16>>::Error>

The type of an error returned by this bus

fn read( &mut self, now: Self::Instant, addr: Z80AddressSpace, data: &mut [u8] ) -> Result<usize, Self::Error>

Read an arbitrary length of bytes from this device, at time now

fn write( &mut self, now: Self::Instant, addr: Z80AddressSpace, data: &[u8] ) -> Result<usize, Self::Error>

Write an arbitrary length of bytes into this device, at time now

fn read_u8( &mut self, now: Self::Instant, addr: Address ) -> Result<u8, Self::Error>

Read a single u8 value at the given address

fn read_beu16( &mut self, now: Self::Instant, addr: Address ) -> Result<u16, Self::Error>

Read a single u16 value in big endian byte order at the given address

fn read_leu16( &mut self, now: Self::Instant, addr: Address ) -> Result<u16, Self::Error>

Read a single u16 value in little endian byte order at the given address

fn read_u16( &mut self, order: ByteOrder, now: Self::Instant, addr: Address ) -> Result<u16, Self::Error>

Read a single u16 value in the given byte order at the given address

fn read_beu32( &mut self, now: Self::Instant, addr: Address ) -> Result<u32, Self::Error>

Read a single u32 value in big endian byte order at the given address

fn read_leu32( &mut self, now: Self::Instant, addr: Address ) -> Result<u32, Self::Error>

Read a single u32 value in little endian byte order at the given address

fn read_u32( &mut self, order: ByteOrder, now: Self::Instant, addr: Address ) -> Result<u32, Self::Error>

Read a single u32 value in the given byte order at the given address

fn read_beu64( &mut self, now: Self::Instant, addr: Address ) -> Result<u64, Self::Error>

Read a single u64 value in big endian byte order at the given address

fn read_leu64( &mut self, now: Self::Instant, addr: Address ) -> Result<u64, Self::Error>

Read a single u64 value in little endian byte order at the given address

fn read_u64( &mut self, order: ByteOrder, now: Self::Instant, addr: Address ) -> Result<u64, Self::Error>

Read a single u64 value in the given byte order at the given address

fn write_u8( &mut self, now: Self::Instant, addr: Address, value: u8 ) -> Result<(), Self::Error>

Write a single u8 value to the given address

fn write_beu16( &mut self, now: Self::Instant, addr: Address, value: u16 ) -> Result<(), Self::Error>

Write the given u16 value in big endian byte order to the given address

fn write_leu16( &mut self, now: Self::Instant, addr: Address, value: u16 ) -> Result<(), Self::Error>

Write the given u16 value in little endian byte order to the given address

fn write_u16( &mut self, order: ByteOrder, now: Self::Instant, addr: Address, value: u16 ) -> Result<(), Self::Error>

Write the given u16 value in the given byte order to the given address

fn write_beu32( &mut self, now: Self::Instant, addr: Address, value: u32 ) -> Result<(), Self::Error>

Write the given u32 value in big endian byte order to the given address

fn write_leu32( &mut self, now: Self::Instant, addr: Address, value: u32 ) -> Result<(), Self::Error>

Write the given u32 value in little endian byte order to the given address

fn write_u32( &mut self, order: ByteOrder, now: Self::Instant, addr: Address, value: u32 ) -> Result<(), Self::Error>

Write the given u32 value in the given byte order to the given address

fn write_beu64( &mut self, now: Self::Instant, addr: Address, value: u64 ) -> Result<(), Self::Error>

Write the given u64 value in big endian byte order to the given address

fn write_leu64( &mut self, now: Self::Instant, addr: Address, value: u64 ) -> Result<(), Self::Error>

Write the given u64 value in little endian byte order to the given address

fn write_u64( &mut self, order: ByteOrder, now: Self::Instant, addr: Address, value: u64 ) -> Result<(), Self::Error>

Write the given u64 value in the given byte order to the given address

impl Clone for Z80AddressSpace

fn clone(&self) -> Z80AddressSpace

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 Debug for Z80AddressSpace

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

Formats the value using the given formatter.

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

impl Copy for Z80AddressSpace