MOS6510 (javamod 2.2 API)

java.lang.Object
- de.quippy.sidplay.libsidplay.common.mos6510.C64Environment
- - de.quippy.sidplay.libsidplay.common.mos6510.MOS6510

Direct Known Subclasses:: SID6510

public class MOS6510
extends C64Environment

Nested Class Summary

Nested Classes
Modifier and Type	Class and Description
`protected static interface`	`MOS6510.IFunc` Resolve use of function pointer
`protected static class`	`MOS6510.Interrupts`
`protected static class`	`MOS6510.ProcessorCycle`
`protected static class`	`MOS6510.ProcessorOperations` Declare processor operations

Field Summary

Fields
Modifier and Type	Field and Description
`protected boolean`	`aec` Address Controller, blocks reads
`protected short`	`Cycle_Data`
`protected int`	`Cycle_EffectiveAddress`
`protected int`	`Cycle_Pointer`
`protected byte`	`cycleCount`
`protected short`	`Debug_Data`
`protected int`	`Debug_EffectiveAddress`
`protected short`	`Debug_Opcode`
`protected int`	`Debug_Operand`
`protected int`	`Debug_ProgramCounter`
`protected boolean`	`dodump`
`protected Event`	`event` Resolve multiple inheritance
`protected IEventContext`	`eventContext`
`protected MOS6510.ProcessorCycle`	`fetchCycle`
`static int`	`iIRQ`
`static int`	`iIRQSMAX`
`static int`	`iNMI`
`static int`	`iNONE`
`protected int`	`Instr_Operand`
`protected MOS6510.ProcessorOperations`	`instrCurrent`
`protected short`	`instrOpcode`
`protected int`	`instrStartPC`
`protected MOS6510.ProcessorOperations[]`	`instrTable`
`protected MOS6510.Interrupts`	`interrupts`
`protected MOS6510.ProcessorOperations[]`	`interruptTable`
`static int`	`iRST`
`protected byte`	`lastAddrCycle`
`protected boolean`	`m_blocked`
`protected long`	`m_dbgClk`
`protected Event.event_phase_t`	`m_extPhase` Clock phase when external events appear
`protected Event.event_phase_t`	`m_phase` Clock phase in use by the processor
`protected long`	`m_stealingClk`
`protected static Logger`	`MOS6510`
`static String`	`MOS6510_AUTHOR`
`static String`	`MOS6510_DATE`
`static String`	`MOS6510_EMAIL`
`static int`	`MOS6510_INTERRUPT_DELAY`
`static String`	`MOS6510_VERSION`
`static int`	`oIRQ`
`static int`	`oNMI`
`static int`	`oNONE`
`static int`	`oRST`
`static boolean`	`PC64_TESTSUITE`
`protected MOS6510.ProcessorCycle[]`	`procCycle`
`protected short`	`Register_Accumulator`
`protected short`	`Register_c_Flag`
`protected short`	`Register_n_Flag`
`protected long`	`Register_ProgramCounter`
`protected int`	`Register_StackPointer`
`protected short`	`Register_Status`
`protected short`	`Register_v_Flag`
`protected short`	`Register_X`
`protected short`	`Register_Y`
`protected short`	`Register_z_Flag`
`static short`	`SP_PAGE`
`static int`	`SR_BREAK`
`static int`	`SR_CARRY`
`static int`	`SR_DECIMAL`
`static int`	`SR_INTERRUPT`
`static int`	`SR_NEGATIVE`
`static int`	`SR_NOTUSED`
`static int`	`SR_OVERFLOW`
`static int`	`SR_ZERO`

Constructor Summary

Constructors
Constructor and Description

MOS6510(IEventContext context)
Initialize and create CPU Chip

Constructors
Constructor and Description
`MOS6510(IEventContext context)` Initialize and create CPU Chip

Method Summary

Methods
Modifier and Type	Method and Description
`protected void`	`adc_instr()`
`void`	`aecSignal(boolean state)` Handle bus access signals
`protected void`	`alr_instr()` Undocumented - This opcode ANDs the contents of the A register with an immediate value and then LSRs the result.
`protected void`	`anc_instr()` Undocumented - ANC ANDs the contents of the A register with an immediate value and then moves bit 7 of A into the Carry flag.
`protected void`	`and_instr()`
`protected void`	`ane_instr()`
`protected void`	`arr_instr()` Undocumented - This opcode ANDs the contents of the A register with an immediate value and then RORs the result (Implementation based on that of Frodo C64 Emulator)
`protected void`	`asl_instr()`
`protected void`	`asla_instr()`
`protected void`	`aso_instr()` Undocumented - This opcode ASLs the contents of a memory location and then ORs the result with the accumulator.
`protected void`	`axa_instr()` Undocumented - This opcode stores the result of A AND X AND the high byte of the target address of the operand +1 in memory.
`protected void`	`axs_instr()` Undocumented - AXS ANDs the contents of the A and X registers (without changing the contents of either register) and stores the result in memory.
`protected void`	`bcc_instr()`
`protected void`	`bcs_instr()`
`protected void`	`beq_instr()`
`protected void`	`bit_instr()`
`protected void`	`bmi_instr()`
`protected void`	`bne_instr()`
`protected void`	`bpl_instr()`
`protected void`	`branch_instr(boolean condition)`
`protected void`	`branch2_instr()`
`protected void`	`brk_instr()`
`protected void`	`bvc_instr()`
`protected void`	`bvs_instr()`
`protected void`	`clc_instr()`
`protected void`	`cld_instr()`
`void`	`clearIRQ()`
`protected void`	`cli_instr()`
`protected void`	`clock()` Emulate One Complete Cycle
`protected void`	`clv_instr()`
`protected void`	`cmp_instr()`
`protected void`	`cpx_instr()`
`protected void`	`cpy_instr()`
`void`	`credits(StringBuffer sbuffer)` Module Credits
`protected void`	`dcm_instr()` Undocumented - This opcode DECs the contents of a memory location and then CMPs the result with the A register.
`void`	`debug(boolean enable)`
`protected void`	`DebugCycle()`
`protected void`	`dec_instr()`
`protected void`	`dex_instr()`
`protected void`	`dey_instr()`
`void`	`DumpState()`
`protected void`	`eor_instr()`
`protected void`	`FetchDataByte()` Fetch value, increment PC Addressing Modes: Immediate Relative
`protected void`	`FetchEffAddrDataByte()`
`protected void`	`FetchHighAddr()` Fetch high address byte, increment PC (Absolute Addressing) Low byte must have been obtained first!
`protected void`	`FetchHighAddrX()` Fetch high byte of address, add index register X to low address byte, increment PC Addressing Modes: Absolute Indexed
`protected void`	`FetchHighAddrX2()` Same as above except dosen't worry about page crossing
`protected void`	`FetchHighAddrY()` Fetch high byte of address, add index register Y to low address byte, increment PC Addressing Modes: Absolute Indexed
`protected void`	`FetchHighAddrY2()` Same as above except dosen't worry about page crossing
`protected void`	`FetchHighEffAddr()` Fetch effective address high Addressing Modes: Indirect Indexed Indirect (pre X)
`protected void`	`FetchHighEffAddrY()` Fetch effective address high, add Y to low byte of effective address Addressing Modes: Indirect indexed (post Y)
`protected void`	`FetchHighEffAddrY2()` Same as above except dosen't worry about page crossing
`protected void`	`FetchHighPointer()` Fetch pointer address high, increment PC Addressing Modes: Absolute Indirect
`protected void`	`FetchLowAddr()` Fetch low address byte, increment PC Addressing Modes: Stack Manipulation Absolute Zero Page Zero Page Indexed Absolute Indexed Absolute Indirect
`protected void`	`FetchLowAddrX()` Read from address, add index register X to it Addressing Modes: Zero Page Indexed
`protected void`	`FetchLowAddrY()` Read from address, add index register Y to it Addressing Modes: Zero Page Indexed
`protected void`	`FetchLowEffAddr()` Fetch effective address low Addressing Modes: Indirect Indexed Indirect (pre X) Indirect indexed (post Y)
`protected void`	`FetchLowPointer()` Fetch pointer address low, increment PC Addressing Modes: Absolute Indirect Indirect indexed (post Y)
`protected void`	`FetchLowPointerX()` Read pointer from the address and add X to it Addressing Modes: Indexed Indirect (pre X)
`protected void`	`FetchOpcode()` Fetch opcode, increment PC Addressing Modes: All
`protected void`	`illegal_instr()`
`protected void`	`inc_instr()`
`protected void`	`Initialise()` Initialize CPU Emulation (Registers)
`protected void`	`ins_instr()` Undocumented - This opcode INCs the contents of a memory location and then SBCs the result from the A register.
`protected boolean`	`interruptPending()`
`protected void`	`inx_instr()`
`protected void`	`iny_instr()`
`protected void`	`IRQ1Request()`
`protected void`	`IRQ2Request()`
`protected void`	`IRQRequest_sidplay_irq()` Overridden in the Sub-class SID6510 for Sidplay compatibility
`protected void`	`IRQRequest()`
`protected void`	`jmp_instr()`
`protected void`	`jsr_instr()`
`protected void`	`las_instr()` Undocumented - This opcode ANDs the contents of a memory location with the contents of the stack pointer register and stores the result in the accumulator, the X register, and the stack pointer.
`protected void`	`lax_instr()` Undocumented - This opcode loads both the accumulator and the X register with the contents of a memory location.
`protected void`	`lda_instr()`
`protected void`	`ldx_instr()`
`protected void`	`ldy_instr()`
`protected void`	`lse_instr()` Undocumented - LSE LSRs the contents of a memory location and then EORs the result with the accumulator.
`protected void`	`lsr_instr()`
`protected void`	`lsra_instr()`
`protected void`	`NextInstr()`
`protected void`	`NMI1Request()`
`protected void`	`NMIRequest()`
`protected void`	`oal_instr()` Undocumented - This opcode ORs the A register with #xx, ANDs the result with an immediate value, and then stores the result in both A and X. xx may be EE,EF,FE, OR FF, but most emulators seem to use EE
`protected void`	`ora_instr()`
`protected void`	`Perform_ADC()`
`protected void`	`Perform_SBC()`
`protected void`	`pha_instr()`
`protected void`	`pla_instr()`
`protected void`	`PopHighPC()` Increment stack and pull program counter high byte from stack,
`protected void`	`PopLowPC()` Increment stack and pull program counter low byte from stack,
`protected void`	`PopSR_sidplay_rti()` Overridden in the Sub-class SID6510 for Sidplay compatibility
`protected void`	`PopSR()` increment S, Pop P off stack
`protected void`	`PushHighPC_sidplay_brk()` Overridden in the Sub-class SID6510 for Sidplay compatibility
`protected void`	`PushHighPC()` Push Program Counter High Byte on stack, decrement S
`protected void`	`PushLowPC()` Push Program Counter Low Byte on stack, decrement S
`protected void`	`PushSR()`
`protected void`	`PushSR(boolean b_flag)` Push P on stack, decrement S
`protected void`	`PutEffAddrDataByte()`
`void`	`reset()` Reset CPU Emulation
`protected void`	`rla_instr()` Undocumented - RLA ROLs the contents of a memory location and then ANDs the result with the accumulator.
`protected void`	`rol_instr()`
`protected void`	`rola_instr()`
`protected void`	`ror_instr()`
`protected void`	`rora_instr()`
`protected void`	`rra_instr()` Undocumented - RRA RORs the contents of a memory location and then ADCs the result with the accumulator.
`protected void`	`RSTRequest()`
`protected void`	`rti_instr()` RTI does not delay the IRQ I flag change as it is set 3 cycles before the end of the opcode, and thus the 6510 has enough time to call the interrupt routine as soon as the opcode ends, if necessary.
`protected void`	`rts_instr()`
`protected void`	`say_instr()` Undocumented - This opcode ANDs the contents of the Y register with <ab+1> and stores the result in memory.
`protected void`	`sbc_instr()`
`protected void`	`sbx_instr()`
`protected void`	`sec_instr()`
`protected void`	`sed_instr()`
`protected void`	`sei_instr()`
`protected void`	`shs_instr()` Generic Instruction Undocumented Opcodes See documented 6502-nmo.opc by Adam Vardy for more details
`protected void`	`sta_instr()`
`protected void`	`stx_instr()`
`protected void`	`sty_instr()`
`protected void`	`tas_instr()` Undocumented - This opcode ANDs the contents of the A and X registers (without changing the contents of either register) and transfers the result to the stack pointer.
`protected void`	`tax_instr()`
`protected void`	`tay_instr()`
`void`	`triggerIRQ()` Level triggered interrupt
`void`	`triggerNMI()`
`void`	`triggerRST()`
`protected void`	`tsx_instr()`
`protected void`	`txa_instr()`
`protected void`	`txs_instr()`
`protected void`	`tya_instr()`
`protected void`	`WasteCycle()`
`protected void`	`xas_instr()` Undocumented - This opcode ANDs the contents of the X register with <ab+1> and stores the result in memory.

Methods inherited from class de.quippy.sidplay.libsidplay.common.mos6510.C64Environment
envCheckBankJump, envClearIRQ, envLoadFile, envReadMemByte, envReadMemDataByte, envReset, envSleep, envTriggerIRQ, envTriggerNMI, envTriggerRST, envWriteMemByte, setEnvironment

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

- Field Detail
  - MOS6510_VERSION
```
public static final String MOS6510_VERSION
```
    See Also:
    Constant Field Values
  - MOS6510_DATE
```
public static final String MOS6510_DATE
```
    See Also:
    Constant Field Values
  - MOS6510_AUTHOR
```
public static final String MOS6510_AUTHOR
```
    See Also:
    Constant Field Values
  - MOS6510_EMAIL
```
public static final String MOS6510_EMAIL
```
    See Also:
    Constant Field Values
  - MOS6510_INTERRUPT_DELAY
```
public static final int MOS6510_INTERRUPT_DELAY
```
    See Also:
    Constant Field Values
  - SR_NEGATIVE
```
public static final int SR_NEGATIVE
```
    See Also:
    Constant Field Values
  - SR_OVERFLOW
```
public static final int SR_OVERFLOW
```
    See Also:
    Constant Field Values
  - SR_NOTUSED
```
public static final int SR_NOTUSED
```
    See Also:
    Constant Field Values
  - SR_BREAK
```
public static final int SR_BREAK
```
    See Also:
    Constant Field Values
  - SR_DECIMAL
```
public static final int SR_DECIMAL
```
    See Also:
    Constant Field Values
  - SR_INTERRUPT
```
public static final int SR_INTERRUPT
```
    See Also:
    Constant Field Values
  - SR_ZERO
```
public static final int SR_ZERO
```
    See Also:
    Constant Field Values
  - SR_CARRY
```
public static final int SR_CARRY
```
    See Also:
    Constant Field Values
  - SP_PAGE
```
public static final short SP_PAGE
```
    See Also:
    Constant Field Values
  - PC64_TESTSUITE
```
public static final boolean PC64_TESTSUITE
```
    See Also:
    Constant Field Values
  - aec
```
protected boolean aec
```
    Address Controller, blocks reads
  - m_blocked
```
protected boolean m_blocked
```
  - m_stealingClk
```
protected long m_stealingClk
```
  - m_dbgClk
```
protected long m_dbgClk
```
  - MOS6510
```
protected static final Logger MOS6510
```
  - dodump
```
protected boolean dodump
```
  - eventContext
```
protected IEventContext eventContext
```
  - m_phase
```
protected Event.event_phase_t m_phase
```
    Clock phase in use by the processor
  - m_extPhase
```
protected Event.event_phase_t m_extPhase
```
    Clock phase when external events appear
  - fetchCycle
```
protected MOS6510.ProcessorCycle fetchCycle
```
  - procCycle
```
protected MOS6510.ProcessorCycle[] procCycle
```
  - instrTable
```
protected MOS6510.ProcessorOperations[] instrTable
```
  - interruptTable
```
protected MOS6510.ProcessorOperations[] interruptTable
```
  - instrCurrent
```
protected MOS6510.ProcessorOperations instrCurrent
```
  - instrStartPC
```
protected int instrStartPC
```
  - instrOpcode
```
protected short instrOpcode
```
  - lastAddrCycle
```
protected byte lastAddrCycle
```
  - cycleCount
```
protected byte cycleCount
```
  - Cycle_EffectiveAddress
```
protected int Cycle_EffectiveAddress
```
  - Cycle_Data
```
protected short Cycle_Data
```
  - Cycle_Pointer
```
protected int Cycle_Pointer
```
  - Register_Accumulator
```
protected short Register_Accumulator
```
  - Register_X
```
protected short Register_X
```
  - Register_Y
```
protected short Register_Y
```
  - Register_ProgramCounter
```
protected long Register_ProgramCounter
```
  - Register_Status
```
protected short Register_Status
```
  - Register_c_Flag
```
protected short Register_c_Flag
```
  - Register_n_Flag
```
protected short Register_n_Flag
```
  - Register_v_Flag
```
protected short Register_v_Flag
```
  - Register_z_Flag
```
protected short Register_z_Flag
```
  - Register_StackPointer
```
protected int Register_StackPointer
```
  - Instr_Operand
```
protected int Instr_Operand
```
  - interrupts
```
protected MOS6510.Interrupts interrupts
```
  - Debug_Data
```
protected short Debug_Data
```
  - Debug_EffectiveAddress
```
protected int Debug_EffectiveAddress
```
  - Debug_Opcode
```
protected short Debug_Opcode
```
  - Debug_Operand
```
protected int Debug_Operand
```
  - Debug_ProgramCounter
```
protected int Debug_ProgramCounter
```
  - event
```
protected Event event
```
    Resolve multiple inheritance
  - iIRQSMAX
```
public static final int iIRQSMAX
```
    See Also:
    Constant Field Values
  - oNONE
```
public static final int oNONE
```
    See Also:
    Constant Field Values
  - oRST
```
public static final int oRST
```
    See Also:
    Constant Field Values
  - oNMI
```
public static final int oNMI
```
    See Also:
    Constant Field Values
  - oIRQ
```
public static final int oIRQ
```
    See Also:
    Constant Field Values
  - iNONE
```
public static final int iNONE
```
    See Also:
    Constant Field Values
  - iRST
```
public static final int iRST
```
    See Also:
    Constant Field Values
  - iNMI
```
public static final int iNMI
```
    See Also:
    Constant Field Values
  - iIRQ
```
public static final int iIRQ
```
    See Also:
    Constant Field Values
- Constructor Detail
  - MOS6510
```
public MOS6510(IEventContext context)
```
    Initialize and create CPU Chip
    
    Parameters:
    context -
- Method Detail
  - clock
```
protected void clock()
```
    Emulate One Complete Cycle
  - Initialise
```
protected void Initialise()
```
    Initialize CPU Emulation (Registers)
  - RSTRequest
```
protected void RSTRequest()
```
  - NMIRequest
```
protected void NMIRequest()
```
  - NMI1Request
```
protected void NMI1Request()
```
  - IRQRequest
```
protected void IRQRequest()
```
  - IRQ1Request
```
protected void IRQ1Request()
```
  - IRQ2Request
```
protected void IRQ2Request()
```
  - interruptPending
```
protected boolean interruptPending()
```
  - FetchOpcode
```
protected void FetchOpcode()
```
    Fetch opcode, increment PC
    Addressing Modes: All
  - NextInstr
```
protected void NextInstr()
```
  - FetchDataByte
```
protected void FetchDataByte()
```
    Fetch value, increment PC
    Addressing Modes:
    - Immediate
    - Relative
  - FetchLowAddr
```
protected void FetchLowAddr()
```
    Fetch low address byte, increment PC
    Addressing Modes:
    - Stack Manipulation
    - Absolute
    - Zero Page
    - Zero Page Indexed
    - Absolute Indexed
    - Absolute Indirect
  - FetchLowAddrX
```
protected void FetchLowAddrX()
```
    Read from address, add index register X to it
    Addressing Modes:
    - Zero Page Indexed
  - FetchLowAddrY
```
protected void FetchLowAddrY()
```
    Read from address, add index register Y to it
    Addressing Modes:
    - Zero Page Indexed
  - FetchHighAddr
```
protected void FetchHighAddr()
```
    Fetch high address byte, increment PC (Absolute Addressing)
    Low byte must have been obtained first!
    Addressing Modes:
    - Absolute
  - FetchHighAddrX
```
protected void FetchHighAddrX()
```
    Fetch high byte of address, add index register X to low address byte,
    increment PC
    Addressing Modes:
    - Absolute Indexed
  - FetchHighAddrX2
```
protected void FetchHighAddrX2()
```
    Same as above except dosen't worry about page crossing
  - FetchHighAddrY
```
protected void FetchHighAddrY()
```
    Fetch high byte of address, add index register Y to low address byte,
    increment PC
    Addressing Modes:
    - Absolute Indexed
  - FetchHighAddrY2
```
protected void FetchHighAddrY2()
```
    Same as above except dosen't worry about page crossing
  - FetchLowEffAddr
```
protected void FetchLowEffAddr()
```
    Fetch effective address low
    Addressing Modes:
    - Indirect
    - Indexed Indirect (pre X)
    - Indirect indexed (post Y)
  - FetchHighEffAddr
```
protected void FetchHighEffAddr()
```
    Fetch effective address high
    Addressing Modes:
    - Indirect
    - Indexed Indirect (pre X)
  - FetchHighEffAddrY
```
protected void FetchHighEffAddrY()
```
    Fetch effective address high, add Y to low byte of effective address
    Addressing Modes:
    - Indirect indexed (post Y)
  - FetchHighEffAddrY2
```
protected void FetchHighEffAddrY2()
```
    Same as above except dosen't worry about page crossing
  - FetchLowPointer
```
protected void FetchLowPointer()
```
    Fetch pointer address low, increment PC
    Addressing Modes:
    - Absolute Indirect
    - Indirect indexed (post Y)
  - FetchLowPointerX
```
protected void FetchLowPointerX()
```
    Read pointer from the address and add X to it
    Addressing Modes:
    - Indexed Indirect (pre X)
  - FetchHighPointer
```
protected void FetchHighPointer()
```
    Fetch pointer address high, increment PC
    Addressing Modes:
    - Absolute Indirect
  - FetchEffAddrDataByte
```
protected void FetchEffAddrDataByte()
```
  - PutEffAddrDataByte
```
protected void PutEffAddrDataByte()
```
  - PushLowPC
```
protected void PushLowPC()
```
    Push Program Counter Low Byte on stack, decrement S
  - PushHighPC
```
protected void PushHighPC()
```
    Push Program Counter High Byte on stack, decrement S
  - PushSR
```
protected void PushSR(boolean b_flag)
```
    Push P on stack, decrement S
    
    Parameters:
    b_flag -
  - PushSR
```
protected void PushSR()
```
  - PopLowPC
```
protected void PopLowPC()
```
    Increment stack and pull program counter low byte from stack,
  - PopHighPC
```
protected void PopHighPC()
```
    Increment stack and pull program counter high byte from stack,
  - PopSR
```
protected void PopSR()
```
    increment S, Pop P off stack
  - WasteCycle
```
protected void WasteCycle()
```
  - DebugCycle
```
protected void DebugCycle()
```
  - adc_instr
```
protected void adc_instr()
```
  - alr_instr
```
protected void alr_instr()
```
    Undocumented - This opcode ANDs the contents of the A register with an immediate value and then LSRs the result.
  - anc_instr
```
protected void anc_instr()
```
    Undocumented - ANC ANDs the contents of the A register with an immediate value and then moves bit 7 of A into the Carry flag. This opcode works basically identically to AND #immed. except that the Carry flag is set to the same state that the Negative flag is set to.
  - and_instr
```
protected void and_instr()
```
  - ane_instr
```
protected void ane_instr()
```
  - arr_instr
```
protected void arr_instr()
```
    Undocumented - This opcode ANDs the contents of the A register with an immediate value and then RORs the result (Implementation based on that of Frodo C64 Emulator)
  - asl_instr
```
protected void asl_instr()
```
  - asla_instr
```
protected void asla_instr()
```
  - aso_instr
```
protected void aso_instr()
```
    Undocumented - This opcode ASLs the contents of a memory location and then ORs the result with the accumulator.
  - axa_instr
```
protected void axa_instr()
```
    Undocumented - This opcode stores the result of A AND X AND the high byte of the target address of the operand +1 in memory.
  - axs_instr
```
protected void axs_instr()
```
    Undocumented - AXS ANDs the contents of the A and X registers (without changing the contents of either register) and stores the result in memory. AXS does not affect any flags in the processor status register.
  - bcc_instr
```
protected void bcc_instr()
```
  - bcs_instr
```
protected void bcs_instr()
```
  - beq_instr
```
protected void beq_instr()
```
  - bit_instr
```
protected void bit_instr()
```
  - bmi_instr
```
protected void bmi_instr()
```
  - bne_instr
```
protected void bne_instr()
```
  - branch_instr
```
protected void branch_instr(boolean condition)
```
  - branch2_instr
```
protected void branch2_instr()
```
  - bpl_instr
```
protected void bpl_instr()
```
  - brk_instr
```
protected void brk_instr()
```
  - bvc_instr
```
protected void bvc_instr()
```
  - bvs_instr
```
protected void bvs_instr()
```
  - clc_instr
```
protected void clc_instr()
```
  - cld_instr
```
protected void cld_instr()
```
  - cli_instr
```
protected void cli_instr()
```
  - clv_instr
```
protected void clv_instr()
```
  - cmp_instr
```
protected void cmp_instr()
```
  - cpx_instr
```
protected void cpx_instr()
```
  - cpy_instr
```
protected void cpy_instr()
```
  - dcm_instr
```
protected void dcm_instr()
```
    Undocumented - This opcode DECs the contents of a memory location and then CMPs the result with the A register.
  - dec_instr
```
protected void dec_instr()
```
  - dex_instr
```
protected void dex_instr()
```
  - dey_instr
```
protected void dey_instr()
```
  - eor_instr
```
protected void eor_instr()
```
  - inc_instr
```
protected void inc_instr()
```
  - ins_instr
```
protected void ins_instr()
```
    Undocumented - This opcode INCs the contents of a memory location and then SBCs the result from the A register.
  - inx_instr
```
protected void inx_instr()
```
  - iny_instr
```
protected void iny_instr()
```
  - jmp_instr
```
protected void jmp_instr()
```
  - jsr_instr
```
protected void jsr_instr()
```
  - las_instr
```
protected void las_instr()
```
    Undocumented - This opcode ANDs the contents of a memory location with the contents of the stack pointer register and stores the result in the accumulator, the X register, and the stack pointer. Affected flags: N Z.
  - lax_instr
```
protected void lax_instr()
```
    Undocumented - This opcode loads both the accumulator and the X register with the contents of a memory location.
  - lda_instr
```
protected void lda_instr()
```
  - ldx_instr
```
protected void ldx_instr()
```
  - ldy_instr
```
protected void ldy_instr()
```
  - lse_instr
```
protected void lse_instr()
```
    Undocumented - LSE LSRs the contents of a memory location and then EORs the result with the accumulator.
  - lsr_instr
```
protected void lsr_instr()
```
  - lsra_instr
```
protected void lsra_instr()
```
  - oal_instr
```
protected void oal_instr()
```
    Undocumented - This opcode ORs the A register with #xx, ANDs the result with an immediate value, and then stores the result in both A and X. xx may be EE,EF,FE, OR FF, but most emulators seem to use EE
  - ora_instr
```
protected void ora_instr()
```
  - pha_instr
```
protected void pha_instr()
```
  - pla_instr
```
protected void pla_instr()
```
  - rla_instr
```
protected void rla_instr()
```
    Undocumented - RLA ROLs the contents of a memory location and then ANDs the result with the accumulator.
  - rol_instr
```
protected void rol_instr()
```
  - rola_instr
```
protected void rola_instr()
```
  - ror_instr
```
protected void ror_instr()
```
  - rora_instr
```
protected void rora_instr()
```
  - rra_instr
```
protected void rra_instr()
```
    Undocumented - RRA RORs the contents of a memory location and then ADCs the result with the accumulator.
  - rti_instr
```
protected void rti_instr()
```
    RTI does not delay the IRQ I flag change as it is set 3 cycles before the end of the opcode, and thus the 6510 has enough time to call the interrupt routine as soon as the opcode ends, if necessary.
  - rts_instr
```
protected void rts_instr()
```
  - sbx_instr
```
protected void sbx_instr()
```
  - say_instr
```
protected void say_instr()
```
    Undocumented - This opcode ANDs the contents of the Y register with <ab+1> and stores the result in memory.
  - sbc_instr
```
protected void sbc_instr()
```
  - sec_instr
```
protected void sec_instr()
```
  - sed_instr
```
protected void sed_instr()
```
  - sei_instr
```
protected void sei_instr()
```
  - shs_instr
```
protected void shs_instr()
```
    Generic Instruction Undocumented Opcodes See documented 6502-nmo.opc by Adam Vardy for more details
  - sta_instr
```
protected void sta_instr()
```
  - stx_instr
```
protected void stx_instr()
```
  - sty_instr
```
protected void sty_instr()
```
  - tas_instr
```
protected void tas_instr()
```
    Undocumented - This opcode ANDs the contents of the A and X registers (without changing the contents of either register) and transfers the result to the stack pointer. It then ANDs that result with the contents of the high byte of the target address of the operand +1 and stores that final result in memory.
  - tax_instr
```
protected void tax_instr()
```
  - tay_instr
```
protected void tay_instr()
```
  - tsx_instr
```
protected void tsx_instr()
```
  - txa_instr
```
protected void txa_instr()
```
  - txs_instr
```
protected void txs_instr()
```
  - tya_instr
```
protected void tya_instr()
```
  - xas_instr
```
protected void xas_instr()
```
    Undocumented - This opcode ANDs the contents of the X register with <ab+1> and stores the result in memory.
  - illegal_instr
```
protected void illegal_instr()
```
  - Perform_ADC
```
protected void Perform_ADC()
```
  - Perform_SBC
```
protected void Perform_SBC()
```
  - IRQRequest_sidplay_irq
```
protected void IRQRequest_sidplay_irq()
```
    Overridden in the Sub-class SID6510 for Sidplay compatibility
  - PushHighPC_sidplay_brk
```
protected void PushHighPC_sidplay_brk()
```
    Overridden in the Sub-class SID6510 for Sidplay compatibility
  - PopSR_sidplay_rti
```
protected void PopSR_sidplay_rti()
```
    Overridden in the Sub-class SID6510 for Sidplay compatibility
  - reset
```
public void reset()
```
    Reset CPU Emulation
  - credits
```
public void credits(StringBuffer sbuffer)
```
    Module Credits
    
    Parameters:
    sbuffer -
  - DumpState
```
public void DumpState()
```
  - aecSignal
```
public void aecSignal(boolean state)
```
    Handle bus access signals
    
    Parameters:
    state -
  - triggerRST
```
public void triggerRST()
```
  - triggerNMI
```
public void triggerNMI()
```
  - triggerIRQ
```
public void triggerIRQ()
```
    Level triggered interrupt
  - clearIRQ
```
public void clearIRQ()
```
  - debug
```
public void debug(boolean enable)
```

Class MOS6510

Nested Class Summary

Field Summary

Constructor Summary

Method Summary

Methods inherited from class de.quippy.sidplay.libsidplay.common.mos6510.C64Environment

Methods inherited from class java.lang.Object

Field Detail

MOS6510_VERSION

MOS6510_DATE

MOS6510_AUTHOR

MOS6510_EMAIL

MOS6510_INTERRUPT_DELAY

SR_NEGATIVE

SR_OVERFLOW

SR_NOTUSED

SR_BREAK

SR_DECIMAL

SR_INTERRUPT

SR_ZERO

SR_CARRY

SP_PAGE

PC64_TESTSUITE

aec

m_blocked

m_stealingClk

m_dbgClk

MOS6510

dodump

eventContext

m_phase

m_extPhase

fetchCycle

procCycle

instrTable

interruptTable

instrCurrent

instrStartPC

instrOpcode

lastAddrCycle

cycleCount

Cycle_EffectiveAddress

Cycle_Data

Cycle_Pointer

Register_Accumulator

Register_X

Register_Y

Register_ProgramCounter

Register_Status

Register_c_Flag

Register_n_Flag

Register_v_Flag

Register_z_Flag

Register_StackPointer

Instr_Operand

interrupts

Debug_Data

Debug_EffectiveAddress

Debug_Opcode

Debug_Operand

Debug_ProgramCounter

event

iIRQSMAX

oNONE

oRST

oNMI

oIRQ

iNONE

iRST

iNMI

iIRQ

Constructor Detail

MOS6510

Method Detail

clock

Initialise

RSTRequest

NMIRequest

NMI1Request

IRQRequest