opcodes.h File Reference

This graph shows which files directly or indirectly include this file:

Go to the source code of this file.

Enumerations
enum	CPU_INSTRUCTION {   ADC_I = 0x69 , ADC_Z = 0x65 , ADC_ZX = 0x75 , ADC_A = 0x6d ,   ADC_AX = 0x7d , ADC_AY = 0x79 , ADC_IdX = 0x61 , ADC_IdY = 0x71 ,   AND_I = 0x29 , AND_Z = 0x25 , AND_ZX = 0x35 , AND_A = 0x2d ,   AND_AX = 0x3d , AND_AY = 0x39 , AND_IdX = 0x21 , AND_IdY = 0x31 ,   ASL_Ac = 0x0a , ASL_Z = 0x06 , ASL_ZX = 0x16 , ASL_A = 0x0e ,   ASL_AX = 0x1e , BCC = 0x90 , BCS = 0xb0 , BEQ = 0xf0 ,   BIT_Z = 0x24 , BIT_A = 0x2c , BMI = 0x30 , BNE = 0xd0 ,   BPL = 0x10 , BRK = 0x00 , BVC = 0x50 , BVS = 0x70 ,   CLC = 0x18 , CLD = 0xd8 , CLI = 0x58 , CLV = 0xb8 ,   CMP_I = 0xc9 , CMP_Z = 0xc5 , CMP_ZX = 0xd5 , CMP_A = 0xcd ,   CMP_AX = 0xdd , CMP_AY = 0xd9 , CMP_IdX = 0xc1 , CMP_IdY = 0xd1 ,   CPX_I = 0xe0 , CPX_Z = 0xe4 , CPX_A = 0xec , CPY_I = 0xc0 ,   CPY_Z = 0xc4 , CPY_A = 0xcc , DEC_Z = 0xc6 , DEC_ZX = 0xd6 ,   DEC_A = 0xce , DEC_AX = 0xde , DEX = 0xca , DEY = 0x88 ,   EOR_I = 0x49 , EOR_Z = 0x45 , EOR_ZX = 0x55 , EOR_A = 0x4d ,   EOR_AX = 0x5d , EOR_AY = 0x59 , EOR_IdX = 0x41 , EOR_IdY = 0x51 ,   INC_Z = 0xe6 , INC_ZX = 0xf6 , INC_A = 0xee , INC_AX = 0xfe ,   INX = 0xe8 , INY = 0xc8 , JMP_A = 0x4c , JMP_Id = 0x6c ,   JSR = 0x20 , LDA_I = 0xa9 , LDA_Z = 0Xa5 , LDA_ZX = 0xb5 ,   LDA_A = 0xad , LDA_AX = 0xbd , LDA_AY = 0xb9 , LDA_IdX = 0xa1 ,   LDA_IdY = 0xb1 , LDX_I = 0xa2 , LDX_Z = 0xa6 , LDX_ZY = 0xb6 ,   LDX_A = 0xae , LDX_AY = 0xbe , LDY_I = 0xa0 , LDY_Z = 0xa4 ,   LDY_ZX = 0xb4 , LDY_A = 0xac , LDY_AX = 0xbc , LSR_Ac = 0x4a ,   LSR_Z = 0x46 , LSR_ZX = 0x56 , LSR_A = 0x4e , LSR_AX = 0x5e ,   NOP = 0xea , ORA_I = 0x09 , ORA_Z = 0x05 , ORA_ZX = 0x15 ,   ORA_A = 0x0d , ORA_AX = 0x1d , ORA_AY = 0x19 , ORA_IdX = 0x01 ,   ORA_IdY = 0x11 , PHA = 0x48 , PHP = 0x08 , PLA = 0x68 ,   PLP = 0x28 , ROL_Ac = 0x2a , ROL_Z = 0x26 , ROL_ZX = 0x36 ,   ROL_A = 0x2e , ROL_AX = 0x3e , ROR_Ac = 0x6a , ROR_Z = 0x66 ,   ROR_ZX = 0x76 , ROR_A = 0x6e , ROR_AX = 0x7e , RTI = 0x40 ,   RTS = 0x60 , SBC_I = 0xe9 , SBC_Z = 0xe5 , SBC_ZX = 0xf5 ,   SBC_A = 0xed , SBC_AX = 0xfd , SBC_AY = 0xf9 , SBC_IdX = 0xe1 ,   SBC_IdY = 0xf1 , SEC = 0x38 , SED = 0xf8 , SEI = 0x78 ,   STA_Z = 0x85 , STA_ZX = 0x95 , STA_A = 0x8d , STA_AX = 0x9d ,   STA_AY = 0x99 , STA_IdX = 0x81 , STA_IdY = 0x91 , STX_Z = 0x86 ,   STX_ZY = 0x96 , STX_A = 0x8e , STY_Z = 0x84 , STY_ZX = 0x94 ,   STY_A = 0x8c , TAX = 0xaa , TSX = 0xba , TXA = 0x8a ,   TYA = 0x98 , TXS = 0x9a , TAY = 0xa8 }

Enumeration Type Documentation

CPU_INSTRUCTION

enum CPU_INSTRUCTION

Enumerator
ADC_I	ADC Immediate.
ADC_Z	ADC Zero Page.
ADC_ZX	ADC Zero Page, X.
ADC_A	ADC Absolute.
ADC_AX	ADC Absolute, X.
ADC_AY	ADC Absolute, Y.
ADC_IdX	ADC (Indirect, X)
ADC_IdY	ADC (Indirect), Y.
AND_I	AND Immediate.
AND_Z	AND Zero Page.
AND_ZX	AND Zero Page, X.
AND_A	AND Absolute.
AND_AX	AND Absolute, X.
AND_AY	AND Absolute, Y.
AND_IdX	AND (Indirect, X)
AND_IdY	AND (Indirect), Y.
ASL_Ac	ASL Accumulator.
ASL_Z	ASL Zero Page.
ASL_ZX	ASL Zero Page, X.
ASL_A	ASL Absolute.
ASL_AX	ASL Absolute, X.
BCC	If C = 0.
BCS	If C = 1.
BEQ	If Z = 1.
BIT_Z	BIT Zero Page.
BIT_A	BIT Absolute.
BMI	iF N = 1
BNE	If Z = 0.
BPL	If N = 0.
BRK	Break instruction.
BVC	If V = 0.
BVS	If V = 1.
CLC	C = 0.
CLD	D = 0.
CLI	I = 0.
CLV	V = 0.
CMP_I	CMP Immediate.
CMP_Z	CMP Zero Page.
CMP_ZX	CMP Zero Page, X.
CMP_A	CMP Absolute.
CMP_AX	CMP Absolute, X.
CMP_AY	CMP Absolute, Y.
CMP_IdX	CMP (Indirect, X)
CMP_IdY	CMP (Indirect), Y.
CPX_I	CPX Immediate.
CPX_Z	CPX Zero Page.
CPX_A	CPX Absolute.
CPY_I	CPY Immediate.
CPY_Z	CPY Zero Page.
CPY_A	CPY Absolute.
DEC_Z	DEC Zero Page.
DEC_ZX	DEC Zero Page, X.
DEC_A	DEC Absolute.
DEC_AX	DEC Absolute, X.
DEX	X = X - 1.
DEY	Y = Y - 1.
EOR_I	EOR Immediate.
EOR_Z	EOR Zero Page.
EOR_ZX	EOR Zero Page, X.
EOR_A	EOR Abolute.
EOR_AX	EOR Absolute, X.
EOR_AY	EOR Absolute, Y.
EOR_IdX	EOR (Indirect, X)
EOR_IdY	EOR (Indirect), Y.
INC_Z	INC Zero Page.
INC_ZX	INC Zero Page, X.
INC_A	INC Absolute.
INC_AX	INC Absolute, X.
INX	X = X + 1.
INY	Y = Y + 1.
JMP_A	JMP Absolute.
JMP_Id	JMP Indirect.
JSR	Jump to the subroutine.
LDA_I	LDA Immediate.
LDA_Z	LDA Zero Page.
LDA_ZX	LDA Zero Page, X.
LDA_A	LDA Absolute.
LDA_AX	LDA Absolute, X.
LDA_AY	LDA Absolute, Y.
LDA_IdX	LDA (Indirect, X)
LDA_IdY	LDA (Indirect), Y.
LDX_I	LDX Immediate.
LDX_Z	LDX Zero Page.
LDX_ZY	LDX Zero Page, Y.
LDX_A	LDX Absolute.
LDX_AY	LDX Absolute, Y.
LDY_I	LDY Immediate.
LDY_Z	LDY Zero Page.
LDY_ZX	LDY Zero Page, X.
LDY_A	LDY Absolute.
LDY_AX	LDY Absolute, X.
LSR_Ac	LSR Accumulator.
LSR_Z	LSR Zero Page.
LSR_ZX	LSR Zero Page, X.
LSR_A	LSR Absolute.
LSR_AX	LSR Absolute, X.
NOP	No Operation.
ORA_I	ORA Immediate.
ORA_Z	ORA Zero Page.
ORA_ZX	ORA Zero Page, X.
ORA_A	ORA Absolute.
ORA_AX	ORA Absolute, X.
ORA_AY	ORA Absolute, Y.
ORA_IdX	ORA (Indirect, X)
ORA_IdY	ORA (Indirect), Y.
PHA	push(ACC); sp = sp - 1;
PHP	push(flags); sp = sp - 1;
PLA	ACC = pull(); sp = sp + 1;.
PLP	flags = pull(); sp = sp + 1;
ROL_Ac	ROL Accumulator.
ROL_Z	ROL Zero Page.
ROL_ZX	ROL Zero Page, X.
ROL_A	ROL Absolute.
ROL_AX	ROL Absolute, X.
ROR_Ac	ROR Accumulator.
ROR_Z	ROR Zero Page.
ROR_ZX	ROR Zero Page, X.
ROR_A	ROR Absolute.
ROR_AX	ROR Absolute, X.
RTI	Return from the current interrupt.
RTS	Return from the current subroutine.
SBC_I	SBC Immediate.
SBC_Z	SBC Zero Page.
SBC_ZX	SBC Zero Page, X.
SBC_A	SBC Absolute.
SBC_AX	SBC Absolute, X.
SBC_AY	SBC Absolute, Y.
SBC_IdX	SBC (Indirect, X)
SBC_IdY	SBC (Indirect), Y.
SEC	C = 1.
SED	D = 1.
SEI	I = 1.
STA_Z	STA Zero Page.
STA_ZX	STA Zero Page, X.
STA_A	STA Absolute.
STA_AX	STA Absolute, X.
STA_AY	STA Absolute, Y.
STA_IdX	STA (Indirect, X)
STA_IdY	STA (Indirect), Y.
STX_Z	STX Zero Page.
STX_ZY	STX Zero Page, Y.
STX_A	STX Absolute.
STY_Z	STY Zero Page.
STY_ZX	STY Zero Page, X.
STY_A	STY Absolute.
TAX	X = ACC.
TSX	X = sp.
TXA	ACC = X.
TYA	ACC = Y.
TXS
TAY

Definition at line 4 of file opcodes.h.

                     {
    // ADC : Add with carry
    ADC_I = 0x69,   
    ADC_Z = 0x65,   
    ADC_ZX = 0x75,  
    ADC_A = 0x6d,   
    ADC_AX = 0x7d,  
    ADC_AY = 0x79,  
    ADC_IdX = 0x61, 
    ADC_IdY = 0x71, 
 
    // AND: Logic AND
 
    AND_I = 0x29,   
    AND_Z = 0x25,   
    AND_ZX = 0x35,  
    AND_A = 0x2d,   
    AND_AX = 0x3d,  
    AND_AY = 0x39,  
    AND_IdX = 0x21, 
    AND_IdY = 0x31, 
 
    // ASL: Arithmetic Shift Left
 
    ASL_Ac = 0x0a, 
    ASL_Z = 0x06,  
    ASL_ZX = 0x16, 
    ASL_A = 0x0e,  
    ASL_AX = 0x1e, 
 
    // BCC: Branch if Carry Clear
    BCC = 0x90, 
 
    // BCS: Branch if Carry Set
    BCS = 0xb0, 
 
    // BEQ: Branch if Equal
    BEQ = 0xf0, 
 
    // BIT: Bit Test
 
    BIT_Z = 0x24, 
    BIT_A = 0x2c, 
 
    // BMI: Branch if Minus
    BMI = 0x30, 
 
    // BNE: Branch if Not Equal
    BNE = 0xd0, 
 
    // BPL: Branch if Positive
    BPL = 0x10, 
 
    // BRK: Break
    BRK = 0x00, 
 
    // BVC: Branch if Overflow Clear
    BVC = 0x50, 
 
    // BVS: Branch if Overflow Set
    BVS = 0x70, 
 
    // CLC: Clear Carry flag
    CLC = 0x18, 
 
    // CLD: Clear Decimal flag
    CLD = 0xd8, 
 
    // CLI: Clear Interrupt Disable flag
    CLI = 0x58, 
 
    // CLV: Clear Overflow flag
    CLV = 0xb8, 
 
    // CMP: Compare Accumulator
    CMP_I = 0xc9,   
    CMP_Z = 0xc5,   
    CMP_ZX = 0xd5,  
    CMP_A = 0xcd,   
    CMP_AX = 0xdd,  
    CMP_AY = 0xd9,  
    CMP_IdX = 0xc1, 
    CMP_IdY = 0xd1, 
 
    // CPX: Compare X Register
    CPX_I = 0xe0, 
    CPX_Z = 0xe4, 
    CPX_A = 0xec, 
 
    // CPY: Compare Y Register
    CPY_I = 0xc0, 
    CPY_Z = 0xc4, 
    CPY_A = 0xcc, 
 
    // DEC: Decrement Memory
    DEC_Z = 0xc6,  
    DEC_ZX = 0xd6, 
    DEC_A = 0xce,  
    DEC_AX = 0xde, 
 
    // DEX: Decrement X Register
    DEX = 0xca, 
 
    // DEY: Decrement Y Register
    DEY = 0x88, 
 
    // EOR: Exclusive OR
    EOR_I = 0x49,   
    EOR_Z = 0x45,   
    EOR_ZX = 0x55,  
    EOR_A = 0x4d,   
    EOR_AX = 0x5d,  
    EOR_AY = 0x59,  
    EOR_IdX = 0x41, 
    EOR_IdY = 0x51, 
 
    // INC: Increment Memory
    INC_Z = 0xe6,  
    INC_ZX = 0xf6, 
    INC_A = 0xee,  
    INC_AX = 0xfe, 
 
    // INX: Increment X Register
    INX = 0xe8, 
 
    // INY: Increment Y Register
    INY = 0xc8, 
 
    // JMP: Jump instruction
    JMP_A = 0x4c,  
    JMP_Id = 0x6c, 
 
    // JSR: Jump Subroutine
    JSR = 0x20, 
 
    // LDA: Load Accumulator
    LDA_I = 0xa9,   
    LDA_Z = 0Xa5,   
    LDA_ZX = 0xb5,  
    LDA_A = 0xad,   
    LDA_AX = 0xbd,  
    LDA_AY = 0xb9,  
    LDA_IdX = 0xa1, 
    LDA_IdY = 0xb1, 
 
    // LDX: Load X Register
    LDX_I = 0xa2,  
    LDX_Z = 0xa6,  
    LDX_ZY = 0xb6, 
    LDX_A = 0xae,  
    LDX_AY = 0xbe, 
 
    // LDY: Load Y Register
    LDY_I = 0xa0,  
    LDY_Z = 0xa4,  
    LDY_ZX = 0xb4, 
    LDY_A = 0xac,  
    LDY_AX = 0xbc, 
 
    // LSR: Logical Shift Right
    LSR_Ac = 0x4a, 
    LSR_Z = 0x46,  
    LSR_ZX = 0x56, 
    LSR_A = 0x4e,  
    LSR_AX = 0x5e, 
 
    // NOP: No Operation
    NOP = 0xea, 
 
    // ORA: Logical OR
    ORA_I = 0x09,   
    ORA_Z = 0x05,   
    ORA_ZX = 0x15,  
    ORA_A = 0x0d,   
    ORA_AX = 0x1d,  
    ORA_AY = 0x19,  
    ORA_IdX = 0x01, 
    ORA_IdY = 0x11, 
 
    // PHA: Push Accumulator
    PHA = 0x48, 
 
    // PHP: Push Processor Status
    PHP = 0x08, 
 
    // PLA: Pull Accumulator
    PLA = 0x68, 
 
    // PLP: Pull Processor Status
    PLP = 0x28, 
 
    // ROL: Rotate Left
    ROL_Ac = 0x2a, 
    ROL_Z = 0x26,  
    ROL_ZX = 0x36, 
    ROL_A = 0x2e,  
    ROL_AX = 0x3e, 
 
    // ROR: Rotate Right
    ROR_Ac = 0x6a, 
    ROR_Z = 0x66,  
    ROR_ZX = 0x76, 
    ROR_A = 0x6e,  
    ROR_AX = 0x7e, 
 
    // RTI: Return from Interrupt
    RTI = 0x40, 
 
    // RTS: Return from subroutine
    RTS = 0x60, 
 
    // SBC: Substract with Carry
    SBC_I = 0xe9,   
    SBC_Z = 0xe5,   
    SBC_ZX = 0xf5,  
    SBC_A = 0xed,   
    SBC_AX = 0xfd,  
    SBC_AY = 0xf9,  
    SBC_IdX = 0xe1, 
    SBC_IdY = 0xf1, 
 
    // SEC: Set carry flag
    SEC = 0x38, 
 
    // SED: Set Decimal flag
    SED = 0xf8, 
 
    // SEI: Set Interrupt disable
    SEI = 0x78, 
 
    // STA: Store Accumulator
    STA_Z = 0x85,   
    STA_ZX = 0x95,  
    STA_A = 0x8d,   
    STA_AX = 0x9d,  
    STA_AY = 0x99,  
    STA_IdX = 0x81, 
    STA_IdY = 0x91, 
 
    // STX: Store X Register
    STX_Z = 0x86,  
    STX_ZY = 0x96, 
    STX_A = 0x8e,  
 
    // STY: Store Y Register
    STY_Z = 0x84,  
    STY_ZX = 0x94, 
    STY_A = 0x8c,  
 
    // TAX: Transfer Accumulator to X
    TAX = 0xaa, 
 
    // TSX: Transfer stack pointer to X
    TSX = 0xba, 
 
    // TXA: Transfer X to the Accumulator
    TXA = 0x8a, 
 
    // TYA: Transfer Y to the Accumulator
    TYA = 0x98, 
 
    // TXS: Transfer X to stack pointer
    TXS = 0x9a,
 
    // TAY: Transfer Accumulator to Y
    TAY = 0xa8,
};