Struct moa_m68k::state::M68k

pub struct M68k<Instant> {
    pub info: CpuInfo,
    pub state: M68kState,
    pub debugger: M68kDebugger,
    pub stats: M68kStatistics,
    pub cycle: Option<M68kCycle<Instant>>,
}

Fields

info: CpuInfo

state: M68kState

debugger: M68kDebugger

stats: M68kStatistics

cycle: Option<M68kCycle<Instant>>

Implementations

impl<Instant> M68k<Instant>

where Instant: BusInstant,

pub fn new(info: CpuInfo) -> Self

pub fn from_type(cputype: M68kType, freq: Frequency) -> Self

pub fn dump_state<W: Write>(&self, writer: &mut W) -> Result<(), Error>

pub fn last_cycle_duration(&self) -> Instant::Duration

Trait Implementations

impl<Instant: Clone> Clone for M68k<Instant>

fn clone(&self) -> M68k<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<u32, Bus, Writer> for M68k<Instant>

where Bus: BusAccess<M68kAddress, Instant = Instant, Error = BusError>, BusError: ErrorType, Instant: BusInstant, Writer: Write,

Control the execution of a CPU device for debugging purposes

type DebugError = M68kError<BusError>

Represents an error that can occur while debugging

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

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

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

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

fn add_breakpoint(&mut self, address: M68kAddress)

Add a breakpoint

fn remove_breakpoint(&mut self, address: M68kAddress)

Remove a breakpoint

fn clear_breakpoints(&mut self)

Clear all breakpoints

impl Debuggable for M68k<Instant>

fn add_breakpoint(&mut self, addr: Address)

fn remove_breakpoint(&mut self, addr: Address)

fn print_current_step(&mut self, system: &System) -> Result<(), Error>

fn print_disassembly(&mut self, system: &System, addr: Address, count: usize)

fn run_command(&mut self, system: &System, args: &[&str]) -> Result<bool, Error>

impl<Bus, BusError, Instant, Writer> Inspect<u32, Bus, Writer> for M68k<Instant>

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

type InfoType = M68kInfo

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

type Error = M68kError<BusError>

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<Bus, BusError, Instant> Step<u32, Bus> for M68k<Instant>

where Bus: BusAccess<M68kAddress, Instant = Instant, Error = BusError>, BusError: ErrorType, Instant: BusInstant,

type Error = M68kError<BusError>

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: 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: Instant, bus: &mut Bus) -> Result<Instant, Self::Error>

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

impl Steppable for M68k<Instant>

fn step(&mut self, system: &System) -> Result<Duration, Error>

fn on_error(&mut self, _system: &System)

impl Transmutable for M68k<Instant>

fn as_steppable(&mut self) -> Option<&mut dyn Steppable>

fn as_interruptable(&mut self) -> Option<&mut dyn Interruptable>

fn as_debuggable(&mut self) -> Option<&mut dyn Debuggable>

fn as_addressable(&mut self) -> Option<&mut dyn Addressable>

fn as_inspectable(&mut self) -> Option<&mut dyn Inspectable>

fn as_signalable(&mut self) -> Option<&mut dyn Signalable>

impl Interruptable for M68k<Instant>