AbstractCPU (emuLib 9.0.1 API)

java.lang.Object
- emulib.plugins.cpu.AbstractCPU

All Implemented Interfaces:

CPU, Plugin, Callable<CPU.RunState>
```
@ThreadSafe
public abstract class AbstractCPU
extends Object
implements CPU, Callable<CPU.RunState>
```
This class implements some fundamental functionality that can be used by your own plug-ins. Such as: - support of breakpoints - thread safe controlling of run states - managing CPU state listeners

Nested Class Summary
- Nested classes/interfaces inherited from interface emulib.plugins.cpu.CPU
  CPU.CPUListener, CPU.RunState

Constructor Summary

Constructors
Constructor and Description

AbstractCPU(Long pluginID)
Creates new instance of CPU.

Constructors
Constructor and Description
`AbstractCPU(Long pluginID)` Creates new instance of CPU.

Method Summary

All Methods Instance Methods Abstract Methods Concrete Methods
Modifier and Type	Method and Description
`boolean`	`addCPUListener(CPU.CPUListener listener)` Add new CPU listener to the list of stateObservers.
`void`	`destroy()` Destroys all plug-in resources.
`protected abstract void`	`destroyInternal()` Called by original destroy() method.
`void`	`execute()` Runs CPU emulation.
`protected long`	`getPluginID()` Get plug-in ID assigned by emuStudio.
`String`	`getTitle()` Get run-time title of this plug-in.
`boolean`	`isBreakpointSet(int memLocation)` Determine if a breakpoint is set at a memory location.
`boolean`	`isBreakpointSupported()` This class support breakpoints.
`boolean`	`isShowSettingsSupported()` This class does not support showing settings
`void`	`pause()` Pauses the CPU emulation.
`boolean`	`removeCPUListener(CPU.CPUListener listener)` Remove CPU listener object from the list of stateObservers.
`void`	`reset()` Perform a reset of this plugin.
`void`	`reset(int addr)` Perform reset of the CPU with specific starting address.
`protected abstract void`	`resetInternal(int startPos)` Performs specific CPU reset.
`void`	`setBreakpoint(int memLocation)` Set a breakpoint at a memory location.
`void`	`showSettings()` Does nothing.
`void`	`step()` Perform one step of CPU emulation.
`protected abstract CPU.RunState`	`stepInternal()` Perform one emulation step in synchronized context.
`void`	`stop()` Stops the CPU emulation.
`void`	`unsetBreakpoint(int memLocation)` Unset a breakpoint at a memory location.

Methods inherited from class java.lang.Object
clone, equals, finalize, getClass, hashCode, notify, notifyAll, toString, wait, wait, wait

Methods inherited from interface emulib.plugins.cpu.CPU
getDisassembler, getInstructionPosition, getStatusPanel, setInstructionPosition

Methods inherited from interface emulib.plugins.Plugin
getVersion, initialize

Methods inherited from interface java.util.concurrent.Callable
call

- Constructor Detail
  - AbstractCPU
```
public AbstractCPU(Long pluginID)
```
    Creates new instance of CPU.
    
    Parameters:
    
    pluginID - plug-in identification number
    
    Throws:
    
    NullPointerException - if pluginID is null
- Method Detail
  - getPluginID
```
protected long getPluginID()
```
    Get plug-in ID assigned by emuStudio.
    
    Returns:
    
    plug-in ID
  - getTitle
```
public String getTitle()
```
    Description copied from interface: Plugin
    
    Get run-time title of this plug-in. The title is a matter of change during runtime - for example there might be a device which might be used many times but it is called differently for each instance.
    
    Specified by:
    
    getTitle in interface Plugin
    
    Returns:
    
    run-time title of the plug-in
  - showSettings
```
public void showSettings()
```
    Does nothing.
    
    Specified by:
    
    showSettings in interface Plugin
  - isShowSettingsSupported
```
public boolean isShowSettingsSupported()
```
    This class does not support showing settings
    
    Specified by:
    
    isShowSettingsSupported in interface Plugin
    
    Returns:
    
    false
  - isBreakpointSupported
```
public boolean isBreakpointSupported()
```
    This class support breakpoints.
    
    Specified by:
    
    isBreakpointSupported in interface CPU
    
    Returns:
    
    true
  - setBreakpoint
```
public void setBreakpoint(int memLocation)
```
    Description copied from interface: CPU
    
    Set a breakpoint at a memory location. Does nothing if breakpoints are not supported.
    
    Specified by:
    
    setBreakpoint in interface CPU
    
    Parameters:
    
    memLocation - memory location where the breakpoint will be set
    
    See Also:
    
    CPU.isBreakpointSupported()
  - unsetBreakpoint
```
public void unsetBreakpoint(int memLocation)
```
    Description copied from interface: CPU
    
    Unset a breakpoint at a memory location. Does nothing if breakpoints are not supported.
    
    Specified by:
    
    unsetBreakpoint in interface CPU
    
    Parameters:
    
    memLocation - memory location from where the breakpoint will be unset
    
    See Also:
    
    CPU.isBreakpointSupported()
  - isBreakpointSet
```
public boolean isBreakpointSet(int memLocation)
```
    Description copied from interface: CPU
    
    Determine if a breakpoint is set at a memory location.
    
    Specified by:
    
    isBreakpointSet in interface CPU
    
    Parameters:
    
    memLocation - memory location, from where the breakpoint will be determined
    
    Returns:
    
    true if breakpoint is set in the location, false otherwise or if breakpoints are not supported.
    
    See Also:
    
    CPU.isBreakpointSupported()
  - addCPUListener
```
public boolean addCPUListener(CPU.CPUListener listener)
```
    Add new CPU listener to the list of stateObservers. CPU listener is an implementation object of CPUListener interface. The methods are called when some events are occured on CPU.
    
    Specified by:
    
    addCPUListener in interface CPU
    
    Parameters:
    
    listener - CPUListener object
    
    Returns:
    
    true if the listener was added, false otherwise
  - removeCPUListener
```
public boolean removeCPUListener(CPU.CPUListener listener)
```
    Remove CPU listener object from the list of stateObservers. If the listener is not included in the list, nothing will be done.
    
    Specified by:
    
    removeCPUListener in interface CPU
    
    Parameters:
    
    listener - CPUListener object
    
    Returns:
    
    true if the listener was return, false otherwise
  - destroy
```
public void destroy()
```
    Description copied from interface: Plugin
    
    Destroys all plug-in resources. This method is called immediately after user closes the emulator. Inside the method, the plug-in should: - unregister all registered contexts for this plug-in - execute clean-up/destroy code for used resources (GUIs, timers, threads, sockets, memory, etc).
    
    Specified by:
    
    destroy in interface Plugin
  - destroyInternal
```
protected abstract void destroyInternal()
```
    Called by original destroy() method. Do not override the original destroy() method. Subsequent calls of destroy() will call this only once.
  - reset
```
public void reset()
```
    Description copied from interface: Plugin
    
    Perform a reset of this plugin. Reset process depends on the type of the plugin and it should bring it to some default initial state.
    
    Specified by:
    
    reset in interface Plugin
  - reset
```
public void reset(int addr)
```
    Description copied from interface: CPU
    
    Perform reset of the CPU with specific starting address. This is used when program starting address is known. Otherwise it is used standard Plugin.reset() method
    
    Specified by:
    
    reset in interface CPU
    
    Parameters:
    
    addr - Starting address/memory position of the program counter
  - execute
```
public void execute()
```
    Description copied from interface: CPU
    
    Runs CPU emulation. Change state of CPU to "running" and start instruction fetch/decode/execute loop. The emuStudio creates separate thread for this purpose. While CPU is running, the emuStudio will not allow to call method step(). A good CPU should performs right timing for instructions here. Debug window should not be updated after each instruction execution, in order to the execution loop would be faster.
    
    Specified by:
    
    execute in interface CPU
  - pause
```
public void pause()
```
    Description copied from interface: CPU
    
    Pauses the CPU emulation. If a thread was used for CPU execution and is running, then it should be stopped (destroyed) but the CPU state has to be saved for future run. CPU changes it state to "breakpoint".
    
    Specified by:
    
    pause in interface CPU
  - stop
```
public void stop()
```
    Description copied from interface: CPU
    
    Stops the CPU emulation. If a thread was used for CPU execution and is running, then it should be stopped (destroyed) but the CPU state can be saved. CPU changes its state to "stopped" and main module should now forbid execution any of methods step(), pause(), execute() until user resets the CPU. Debug window in main module should be updated with saved CPU state.
    
    Specified by:
    
    stop in interface CPU
  - step
```
public void step()
```
    Description copied from interface: CPU
    
    Perform one step of CPU emulation. It means that one instruction should be executed. CPU state changes to state "running", then it executes one instruction, and then it should return to state "breakpoint" or "stopped". Correct timing of executed instruction isn't so important.
    
    Specified by:
    
    step in interface CPU
  - stepInternal
```
protected abstract CPU.RunState stepInternal()
                                      throws Exception
```
    Perform one emulation step in synchronized context.
    
    Returns:
    
    new CPU state. If nothing bad happened, it should return RunState.STATE_STOPPED_BREAK.
    
    Throws:
    
    Exception - The emulator is allowed to throw any exception
  - resetInternal
```
protected abstract void resetInternal(int startPos)
```
    Performs specific CPU reset. CONTRACT: If this method throws an exception, the behavior is undefined.
    
    Parameters:
    
    startPos - starting position (similar to calling reset(pos))

Class AbstractCPU

Nested Class Summary

Nested classes/interfaces inherited from interface emulib.plugins.cpu.CPU

Constructor Summary

Method Summary

Methods inherited from class java.lang.Object

Methods inherited from interface emulib.plugins.cpu.CPU

Methods inherited from interface emulib.plugins.Plugin

Methods inherited from interface java.util.concurrent.Callable

Constructor Detail

AbstractCPU

Method Detail

getPluginID

getTitle

showSettings

isShowSettingsSupported

isBreakpointSupported

setBreakpoint

unsetBreakpoint

isBreakpointSet

addCPUListener

removeCPUListener

destroy

destroyInternal

reset

reset

execute

pause

stop

step

stepInternal

resetInternal