diff options
Diffstat (limited to 'enums.h')
| -rw-r--r-- | enums.h | 490 |
1 files changed, 282 insertions, 208 deletions
@@ -1,189 +1,287 @@ +enum am { + /* Part of Base ISA. */ + IMM, /* Immediate Data. */ + ZM, /* Zero Matrix. */ + ZMX, /* Zero Matrix, indexed with X. */ + ZMY, /* Zero Matrix, indexed with Y. */ + IND, /* Indirect. */ + INDX, /* Indexed Indirect. */ + INDY, /* Indirect Indexed. */ + ABS, /* Absolute. */ + REL, /* Relative to Program Counter. */ + IMPL, /* Implied. */ + /* Part of Base Extension. */ + ABSX, /* Absolute, Indexed with X. */ + ABSY, /* Absolute, Indexed with Y. */ + SPI, /* Stack Pointer, Immediate Offset. */ + SPX, /* Stack Pointer, Offset with X. */ + SPY, /* Stack Pointer, Offset with Y. */ + INA, /* Absolute Indirect. */ + INAX, /* Absolute Indexed Indirect. */ + INAY, /* Absolute Indirect Indexed. */ + EIND, /* Effective Address Register, Indirect. */ +}; + +enum mne { + AAB = 0, + ABA = 1, + ADC = 2, + AND = 3, + ARB = 4, + ASR = 5, + BCC = 6, + BCS = 7, + BEQ = 8, + BNE = 9, + BNG = 10, + BPO = 11, + BRA = 12, + BRK = 13, + BVC = 14, + BVS = 15, + CAB = 16, + CLC = 17, + CLI = 18, + CLV = 19, + CMP = 20, + CPB = 21, + CPS = 22, + CPX = 23, + CPY = 24, + DAB = 25, + DEB = 26, + DEC = 27, + DEX = 28, + DEY = 29, + DIV = 30, + INB = 31, + INC = 32, + INX = 33, + INY = 34, + JMP = 35, + JSR = 36, + LDA = 37, + LDB = 38, + LDX = 39, + LDY = 40, + LLB = 41, + LRB = 42, + LSL = 43, + LSR = 44, + MAB = 45, + MUL = 46, + NOP = 47, + OAB = 48, + ORA = 49, + PHA = 50, + PHB = 51, + PHP = 52, + PHX = 53, + PHY = 54, + PLA = 55, + PLB = 56, + PLP = 57, + PLX = 58, + PLY = 59, + RLB = 60, + ROL = 61, + ROR = 62, + RRB = 63, + RTI = 64, + RTS = 65, + SAB = 66, + SBC = 67, + SEC = 68, + SEI = 69, + STA = 70, + STB = 71, + STX = 72, + STY = 73, + TAB = 74, + TAX = 75, + TAY = 76, + TBA = 77, + TSX = 78, + TXA = 79, + TXS = 80, + TXY = 81, + TYA = 82, + TYX = 83, + WAI = 84, + XAB = 85, + XOR = 86 +}; enum base_isa { - CPS = 0x00, /* Clear Processor Status. */ - ADC = 0x01, /* ADd with Carry. */ - AAB = 0x02, /* Add Accumulator with carry by B register. */ - ADC_AB = 0x04, /* ADC Absolute. */ - LDA_IN = 0x05, /* LDA Indirect. */ - ADC_Z = 0x06, /* ADC Zero Matrix. */ - PHP = 0x08, /* PusH Processor status to stack. */ - CPB = 0x09, /* ComPare B register. */ - PHB = 0x0A, /* PusH B register to stack. */ - DEC_AB = 0x0C, /* DEC Absolute. */ - DEC_Z = 0x0D, /* DEC Zero Matrix. */ - JMP_Z = 0x0E, /* JuMP to memory location. */ - JMP = 0x10, /* JMP Absolute. */ - SBC = 0x11, /* SuBtract with Carry. */ - SAB = 0x12, /* Subtract Accumulator with carry by B register. */ - SBC_AB = 0x14, /* SBC Absolute. */ - STA_IN = 0x15, /* STA Indirect. */ - SBC_Z = 0x16, /* SBC Zero Matrix. */ - ENT = 0x18, /* ENd Threads. */ - CPY = 0x19, /* ComPare Y register. */ - PLB = 0x1A, /* PuLl B register to stack. */ - INC_AB = 0x1C, /* INC Absolute. */ - INC_Z = 0x1D, /* INC Zero Matrix. */ - JSR_Z = 0x1E, /* Jump to SubRoutine. */ - JSR = 0x20, /* JSR Absolute. */ - AND = 0x21, /* bitwise AND with accumulator. */ - ABA = 0x22, /* bitwise And with Accumulator, and B register. */ - AND_AB = 0x24, /* AND Absolute. */ - CMP_IN = 0x25, /* CMP Indirect. */ - AND_Z = 0x26, /* AND Zero Matrix. */ - PLP = 0x28, /* PuLl Processor status from stack. */ - CPX = 0x29, /* ComPare X register. */ - PHY = 0x2A, /* PusH Y register to stack. */ - CPB_AB = 0x2C, /* CPB Absolute. */ - CPB_Z = 0x2D, /* CPB Zero Matrix. */ - BPO_Z = 0x2E, /* Branch if POsitive. */ - BPO = 0x30, /* BPO Absolute. */ - ORA = 0x31, /* bitwise OR with Accumulator. */ - OAB = 0x32, /* bitwise Or with Accumulator, and B register. */ - ORA_AB = 0x34, /* ORA Absolute. */ - LDB_IN = 0x35, /* LDB Indirect. */ - ORA_Z = 0x36, /* ORA Zero Matrix. */ - STT = 0x38, /* STart Threads. */ - LDA_ZY = 0x39, /* LDA Zero Matrix, indexed with Y. */ - PLY = 0x3A, /* PuLl Y register from stack. */ - CPX_AB = 0x3C, /* CPX Absolute. */ - CPY_Z = 0x3D, /* CPY Zero Matrix. */ - BNG_Z = 0x3E, /* Branch if NeGative. */ - BNG = 0x40, /* BNG Absolute. */ - XOR = 0x41, /* bitwise XOR with accumulator. */ - XAB = 0x42, /* bitwise Xor with Accumulator, and B register. */ - XOR_AB = 0x44, /* XOR Absolute. */ - STB_IN = 0x45, /* STB Indirect. */ - XOR_Z = 0x46, /* XOR Zero Matrix. */ - PHA = 0x48, /* PusH Accumulator to stack. */ - STA_ZY = 0x49, /* STA Zero Matrix, indexed with Y. */ - PHX = 0x4A, /* PusH X register to stack. */ - CPY_AB = 0x4C, /* CPY Absolute. */ - CPX_Z = 0x4D, /* CPX Zero Matrix. */ - BCS_Z = 0x4E, /* Branch if Carry Set. */ - BCS = 0x50, /* BCS Absolute. */ - LSL = 0x51, /* Logical Shift Left. */ - LLB = 0x52, /* Logical shift Left accumulator by B. */ - LSL_AB = 0x54, /* LSL Absolute. */ - CPB_IN = 0x55, /* CPB Indirect. */ - LSL_Z = 0x56, /* LSL Zero Matrix. */ - CLC = 0x58, /* CLear Carry flag. */ - LDB_ZY = 0x59, /* LDB Zero Matrix, indexed with Y. */ - PLX = 0x5A, /* PuLl X register from stack. */ - LDA_IY = 0x5C, /* LDA Indirect Indexed. */ - LDA_IX = 0x5D, /* LDA Indexed Indirect. */ - BCC_Z = 0x5E, /* Branch if Carry Clear. */ - BCC = 0x60, /* BCC Absolute. */ - LSR = 0x61, /* Logical Shift Right. */ - LRB = 0x62, /* Logical shift Right accumulator by B. */ - LSR_AB = 0x64, /* LSR Absolute. */ - LDY_IN = 0x65, /* LDY Indirect. */ - LSR_Z = 0x66, /* LSR Zero Matrix. */ - PLA = 0x68, /* PuLl Accumulator from stack. */ - STB_ZY = 0x69, /* STB Zero Matrix, indexed with Y. */ - TAB = 0x6A, /* Transfer Accumulator to B. */ - STA_IY = 0x6C, /* STA Indirect Indexed. */ - STA_IX = 0x6D, /* STA Indexed Indirect. */ - BEQ_Z = 0x6E, /* Branch if EQual. */ - BEQ = 0x70, /* BEQ Absolute. */ - ROL = 0x71, /* ROtate Left. */ - RLB = 0x72, /* Rotate Left accumulator by B. */ - ROL_AB = 0x74, /* ROL Absolute. */ - STY_IN = 0x75, /* STY Indirect. */ - ROL_Z = 0x76, /* ROL Zero Matrix. */ - SEC = 0x78, /* SEt Carry flag. */ - LDA_ZX = 0x79, /* LDA Zero Matrix, indexed with X. */ - TBA = 0x7A, /* Transfer B to Accumulator. */ - CMP_IY = 0x7C, /* CMP Indirect Indexed. */ - CMP_IX = 0x7D, /* CMP Indexed Indirect. */ - BNE_Z = 0x7E, /* Branch if Not Equal. */ - BNE = 0x80, /* BNE Absolute. */ - ROR = 0x81, /* ROtate Right. */ - RRB = 0x82, /* Rotate Right accumulator by B. */ - ROR_AB = 0x84, /* ROR Absolute. */ - CPY_IN = 0x85, /* CPY Indirect. */ - ROR_Z = 0x86, /* ROR Zero Matrix. */ - DEY = 0x88, /* DEcrement Y register. */ - STA_ZX = 0x89, /* STA Zero Matrix, indexed with X. */ - TAY = 0x8A, /* Transfer Accumulator to Y. */ - LDB_IY = 0x8C, /* LDB Indirect Indexed. */ - LDB_IX = 0x8D, /* LDB Indexed Indirect. */ - BVS_Z = 0x8E, /* Branch if oVerflow Set. */ - BVS = 0x90, /* BVS Absolute. */ - MUL = 0x91, /* MULtiply accumulator. */ - MAB = 0x92, /* Multiply Accumulator by B. */ - MUL_AB = 0x94, /* MUL Absolute. */ - LDX_IN = 0x95, /* LDX Indirect. */ - MUL_Z = 0x96, /* MUL Zero Matrix. */ - CLI = 0x98, /* CLear Interupt flag. */ - LDB_ZX = 0x99, /* LDB Zero Matrix, indexed with X. */ - TYA = 0x9A, /* Transfer Y to Accumulator. */ - STB_IY = 0x9C, /* STB Indirect Indexed. */ - STB_IX = 0x9D, /* STB Indexed Indirect. */ - BVC_Z = 0x9E, /* Branch if oVerflow Clear. */ - BVC = 0xA0, /* BVC Absolute. */ - DIV = 0xA1, /* DIVide with accumulator. */ - DAB = 0xA2, /* Divide Accumulator by B. */ - DIV_AB = 0xA4, /* DIV Absolute. */ - STX_IN = 0xA5, /* STX Indirect. */ - DIV_Z = 0xA6, /* DIV Zero Matrix. */ - INY = 0xA8, /* INcrement Y register. */ - STB_ZX = 0xA9, /* STB Zero Matrix, indexed with X. */ - TAX = 0xAA, /* Transfer Accumulator to X. */ - CPB_IY = 0xAC, /* CPB Indirect Indexed. */ - CPB_IX = 0xAD, /* CPB Indexed Indirect. */ - RTS = 0xAE, /* ReTurn from Subroutine. */ - CMP = 0xB1, /* CoMPare accumulator. */ - CAB = 0xB2, /* Compare Accumulator, and B. */ - CMP_AB = 0xB4, /* CMP Absolute. */ - CPX_IN = 0xB5, /* CPX Indirect. */ - CMP_Z = 0xB6, /* CMP Zero Matrix. */ - SEI = 0xB8, /* SEt Interupt flag. */ - LDX = 0xB9, /* LoaD X register. */ - TXA = 0xBA, /* Transfer X to Accumulator. */ - LDX_AB = 0xBC, /* LDX Absolute. */ - LDX_Z = 0xBD, /* LDX Zero Matrix. */ - JSR_IN = 0xBE, /* JSR Indirect. */ - RTI = 0xC0, /* ReTurn from Interrupt. */ - LDA = 0xC1, /* LoaD Accumulator. */ - LDA_AB = 0xC4, /* LDA Absolute. */ - DEX = 0xC5, /* DEcrement X register. */ - LDA_Z = 0xC6, /* LDA Zero Matrix. */ - CLV = 0xC8, /* CLear oVerflow flag. */ - LDX_ZY = 0xC9, /* LDX Zero Matrix, indexed with Y. */ - TYX = 0xCA, /* Transfer Y to X. */ - STA = 0xCC, /* STA Absolute. */ - STA_Z = 0xCD, /* STore Accumulator. */ - JMP_IN = 0xCE, /* JMP Indirect. */ - TSX = 0xD0, /* Transfer Stack pointer to X. */ - LDB = 0xD1, /* LoaD B register. */ - LDB_AB = 0xD4, /* LDB Absolute. */ - INX = 0xD5, /* INcrement X register. */ - LDB_Z = 0xD6, /* LDB Zero Matrix. */ - WAI = 0xD8, /* WAit for Interrupt. */ - STX_ZY = 0xD9, /* STX Zero Matrix, indexed with Y. */ - TXY = 0xDA, /* Transfer X to Y. */ - STB = 0xDC, /* STB Absolute. */ - STB_Z = 0xDD, /* STore B register. */ - TXS = 0xE0, /* Transfer X to Stack pointer. */ - LDY = 0xE1, /* LoaD Y register. */ - LDY_AB = 0xE4, /* LDY Absolute. */ - DEC = 0xE5, /* DECrement accumulator. */ - LDY_Z = 0xE6, /* LDY Zero Matrix. */ - BRK = 0xE8, /* BReaK. */ - LDY_ZX = 0xE9, /* LDY Zero Matrix, indexed with X. */ - NOP = 0xEA, /* No OPeration. */ - STY = 0xEC, /* STY Absolute. */ - STY_Z = 0xED, /* STore Y register. */ - DEB = 0xEE, /* Decrement B register. */ - ASR = 0xF1, /* Arithmetic Shift Right. */ - ARB = 0xF2, /* Arithmetic shift Right accumulator by B. */ - ASR_AB = 0xF4, /* ASR Absolute. */ - INC = 0xF5, /* INCrement accumulator. */ - ASR_Z = 0xF6, /* ASR Zero Matrix. */ - STY_ZX = 0xF9, /* STY Zero Matrix, indexed with X. */ - STX = 0xFC, /* STX Absolute. */ - STX_Z = 0xFD, /* STore X register. */ - INB = 0xFE /* Increment B register. */ + CPS_IMP = 0x00, /* Clear Processor Status. */ + ADC_IMM = 0x01, /* ADd with Carry. */ + AAB_IMP = 0x02, /* Add Accumulator with carry by B register. */ + ADC_AB = 0x04, /* ADC Absolute. */ + LDA_IN = 0x05, /* LDA Indirect */ + ADC_Z = 0x06, /* ADC Zero Matrix. */ + CLC_IMP = 0x08, /* CLear Carry flag. */ + DEX_IMP = 0x09, /* DEcrement X register. */ + DEC_IMP = 0x0A, /* DECrement accumulator. */ + DEC_AB = 0x0C, /* DEC Absolute. */ + DEC_Z = 0x0D, /* DEC Zero Matrix. */ + JMP_AB = 0x10, /* JMP Absolute. */ + SBC_IMM = 0x11, /* SuBtract with Carry. */ + SAB_IMP = 0x12, /* Subtract Accumulator with carry by B register. */ + SBC_AB = 0x14, /* SBC Absolute. */ + STA_IN = 0x15, /* STA Indirect */ + SBC_Z = 0x16, /* SBC Zero Matrix. */ + SEC_IMP = 0x18, /* SEt Carry flag. */ + INX_IMP = 0x19, /* INcrement X register. */ + INC_IMP = 0x1A, /* INCrement accumulator. */ + INC_AB = 0x1C, /* INC Absolute. */ + INC_Z = 0x1D, /* INC Zero Matrix. */ + JSR_AB = 0x20, /* JSR Absolute. */ + AND_IMM = 0x21, /* bitwise AND with accumulator. */ + ABA_IMP = 0x22, /* bitwise And with Accumulator, and B register. */ + AND_AB = 0x24, /* AND Absolute. */ + CMP_IN = 0x25, /* CMP Indirect */ + AND_Z = 0x26, /* AND Zero Matrix. */ + CLI_IMP = 0x28, /* CLear Interupt flag. */ + DEY_IMP = 0x29, /* DEcrement Y register. */ + CPB_IMM = 0x2A, /* ComPare B register. */ + CPB_AB = 0x2C, /* CPB Absolute. */ + CPB_Z = 0x2D, /* CPB Zero Matrix. */ + JMP_Z = 0x30, /* JuMP to memory location. */ + ORA_IMM = 0x31, /* bitwise OR with Accumulator. */ + OAB_IMP = 0x32, /* bitwise Or with Accumulator, and B register. */ + ORA_AB = 0x34, /* ORA Absolute. */ + LDB_IN = 0x35, /* LDB Indirect */ + ORA_Z = 0x36, /* ORA Zero Matrix. */ + SEI_IMP = 0x38, /* SEt Interupt flag. */ + INY_IMP = 0x39, /* INcrement Y register. */ + CPX_IMM = 0x3A, /* ComPare X register. */ + CPX_AB = 0x3C, /* CPX Absolute. */ + CPY_Z = 0x3D, /* CPY Zero Matrix. */ + JSR_Z = 0x40, /* Jump to SubRoutine. */ + XOR_IMM = 0x41, /* bitwise XOR with accumulator. */ + XAB_IMP = 0x42, /* bitwise Xor with Accumulator, and B register. */ + XOR_AB = 0x44, /* XOR Absolute. */ + STB_IN = 0x45, /* STB Indirect */ + XOR_Z = 0x46, /* XOR Zero Matrix. */ + CLV_IMP = 0x48, /* CLear oVerflow flag. */ + CPY_IMM = 0x4A, /* ComPare Y register. */ + CPY_AB = 0x4C, /* CPY Absolute. */ + CPX_Z = 0x4D, /* CPX Zero Matrix. */ + BPO_REL = 0x50, /* Branch if POsitive. */ + LSL_IMM = 0x51, /* Logical Shift Left. */ + LLB_IMP = 0x52, /* Logical shift Left accumulator by B. */ + LSL_AB = 0x54, /* LSL Absolute. */ + CPB_IN = 0x55, /* CPB Indirect */ + LSL_Z = 0x56, /* LSL Zero Matrix. */ + WAI_IMP = 0x58, /* WAit for Interrupt. */ + PHP_IMP = 0x59, /* PusH Processor status to stack. */ + TAB_IMP = 0x5A, /* Transfer Accumulator to B. */ + LDA_IY = 0x5C, /* LDA Indirect Indexed. */ + LDA_IX = 0x5D, /* LDA Indexed Indirect. */ + BNG_REL = 0x60, /* Branch if NeGative. */ + LSR_IMM = 0x61, /* Logical Shift Right. */ + LRB_IMP = 0x62, /* Logical shift Right accumulator by B. */ + LSR_AB = 0x64, /* LSR Absolute. */ + LDY_IN = 0x65, /* LDY Indirect */ + LSR_Z = 0x66, /* LSR Zero Matrix. */ + BRK_IMP = 0x68, /* BReaK. */ + PLP_IMP = 0x69, /* PuLl Processor status from stack. */ + TBA_IMP = 0x6A, /* Transfer B to Accumulator. */ + STA_IY = 0x6C, /* STA Indirect Indexed. */ + STA_IX = 0x6D, /* STA Indexed Indirect. */ + BCS_REL = 0x70, /* Branch if Carry Set. */ + ROL_IMM = 0x71, /* ROtate Left. */ + RLB_IMP = 0x72, /* Rotate Left accumulator by B. */ + ROL_AB = 0x74, /* ROL Absolute. */ + STY_IN = 0x75, /* STY Indirect */ + ROL_Z = 0x76, /* ROL Zero Matrix. */ + LDA_ZY = 0x78, /* LDA Zero Marrix, Indexed with Y. */ + PHA_IMP = 0x79, /* PusH Accumulator to stack. */ + TAY_IMP = 0x7A, /* Transfer Accumulator to Y. */ + CMP_IY = 0x7C, /* CMP Indirect Indexed. */ + CMP_IX = 0x7D, /* CMP Indexed Indirect. */ + BCC_REL = 0x80, /* Branch if Carry Clear. */ + ROR_IMM = 0x81, /* ROtate Right. */ + RRB_IMP = 0x82, /* Rotate Right accumulator by B. */ + ROR_AB = 0x84, /* ROR Absolute. */ + LDX_IN = 0x85, /* LDX Indirect */ + ROR_Z = 0x86, /* ROR Zero Matrix. */ + STA_ZY = 0x88, /* STA Zero Marrix, Indexed with Y. */ + PLA_IMP = 0x89, /* PuLl Accumulator from stack. */ + TYA_IMP = 0x8A, /* Transfer Y to Accumulator. */ + LDB_IY = 0x8C, /* LDB Indirect Indexed. */ + LDB_IX = 0x8D, /* LDB Indexed Indirect. */ + BEQ_REL = 0x90, /* Branch if EQual. */ + MUL_IMM = 0x91, /* MULtiply accumulator. */ + MAB_IMP = 0x92, /* Multiply Accumulator by B. */ + MUL_AB = 0x94, /* MUL Absolute. */ + STX_IN = 0x95, /* STX Indirect */ + MUL_Z = 0x96, /* MUL Zero Matrix. */ + LDB_ZY = 0x98, /* LDB Zero Marrix, Indexed with Y. */ + PHB_IMP = 0x99, /* PusH B register to stack. */ + TAX_IMP = 0x9A, /* Transfer Accumulator to X. */ + STB_IY = 0x9C, /* STB Indirect Indexed. */ + STB_IX = 0x9D, /* STB Indexed Indirect. */ + BNE_REL = 0xA0, /* Branch if Not Equal. */ + DIV_IMM = 0xA1, /* DIVide with accumulator. */ + DAB_IMP = 0xA2, /* Divide Accumulator by B. */ + DIV_AB = 0xA4, /* DIV Absolute. */ + JSR_IN = 0xA5, /* JSR Indirect */ + DIV_Z = 0xA6, /* DIV Zero Matrix. */ + STB_ZY = 0xA8, /* STB Zero Marrix, Indexed with Y. */ + PLB_IMP = 0xA9, /* PuLl B register to stack. */ + TXA_IMP = 0xAA, /* Transfer X to Accumulator. */ + CPB_IY = 0xAC, /* CPB Indirect Indexed. */ + CPB_IX = 0xAD, /* CPB Indexed Indirect. */ + BVS_REL = 0xB0, /* Branch if oVerflow Set. */ + CMP_IMM = 0xB1, /* CoMPare accumulator. */ + CAB_IMP = 0xB2, /* Compare Accumulator, and B. */ + CMP_AB = 0xB4, /* CMP Absolute. */ + JMP_IN = 0xB5, /* JMP Indirect */ + CMP_Z = 0xB6, /* CMP Zero Matrix. */ + LDA_ZX = 0xB8, /* LDA Zero Marrix, Indexed with X. */ + LDX_IMM = 0xB9, /* LoaD X register. */ + TYX_IMP = 0xBA, /* Transfer Y to X. */ + LDX_AB = 0xBC, /* LDX Absolute. */ + LDX_Z = 0xBD, /* LDX Zero Matrix. */ + BVC_REL = 0xC0, /* Branch if oVerflow Clear. */ + LDA_IMM = 0xC1, /* LoaD Accumulator. */ + DEB_IMP = 0xC2, /* Decrement B register. */ + LDA_AB = 0xC4, /* LDA Absolute. */ + LDA_Z = 0xC6, /* LDA Zero Matrix. */ + STA_ZX = 0xC8, /* STA Zero Marrix, Indexed with X. */ + PHY_IMP = 0xC9, /* PusH Y register to stack. */ + TXY_IMP = 0xCA, /* Transfer X to Y. */ + STA_AB = 0xCC, /* STA Absolute. */ + STA_Z = 0xCD, /* STore Accumulator. */ + BRA_REL = 0xD0, /* BRanch Always. */ + LDB_IMM = 0xD1, /* LoaD B register. */ + INB_IMP = 0xD2, /* Increment B register. */ + LDB_AB = 0xD4, /* LDB Absolute. */ + LDB_Z = 0xD6, /* LDB Zero Matrix. */ + LDB_ZX = 0xD8, /* LDB Zero Marrix, Indexed with X. */ + PLY_IMP = 0xD9, /* PuLl Y register from stack. */ + TSX_IMP = 0xDA, /* Transfer Stack pointer to X. */ + STB_AB = 0xDC, /* STB Absolute. */ + STB_Z = 0xDD, /* STore B register. */ + RTS_IMP = 0xE0, /* ReTurn from Subroutine. */ + LDY_IMM = 0xE1, /* LoaD Y register. */ + LDY_AB = 0xE4, /* LDY Absolute. */ + LDY_Z = 0xE6, /* LDY Zero Matrix. */ + STB_ZX = 0xE8, /* STB Zero Marrix, Indexed with X. */ + PHX_IMP = 0xE9, /* PusH X register to stack. */ + NOP_IMP = 0xEA, /* No OPeration. */ + STY_AB = 0xEC, /* STY Absolute. */ + STY_Z = 0xED, /* STore Y register. */ + RTI_IMP = 0xF0, /* ReTurn from Interrupt. */ + ASR_IMM = 0xF1, /* Arithmetic Shift Right. */ + ARB_IMP = 0xF2, /* Arithmetic shift Right accumulator by B. */ + ASR_AB = 0xF4, /* ASR Absolute. */ + ASR_Z = 0xF6, /* ASR Zero Matrix. */ + PLX_IMP = 0xF9, /* PuLl X register from stack. */ + TXS_IMM = 0xFA, /* Transfer X to Stack pointer. */ + STX_AB = 0xFC, /* STX Absolute. */ + STX_Z = 0xFD /* STore X register. */ }; enum base_ext { @@ -306,27 +404,3 @@ enum base_ext { NOT_E = 0xF4, /* NOT E Indirect. */ STX_E = 0xFC, /* STX E Indirect. */ }; - -enum am { - /* Part of Base ISA. */ - IMM, /* Immediate Data. */ - ZM, /* Zero Matrix. */ - ZMX, /* Zero Matrix, indexed with X. */ - ZMY, /* Zero Matrix, indexed with Y. */ - IND, /* Indirect. */ - INDX, /* Indexed Indirect. */ - INDY, /* Indirect Indexed. */ - ABS, /* Absolute. */ - IMPL, /* Implied. */ - /* Part of Base Extension. */ - ABSX, /* Absolute, Indexed with X. */ - ABSY, /* Absolute, Indexed with Y. */ - SPI, /* Stack Pointer, Immediate Offset. */ - SPX, /* Stack Pointer, Offset with X. */ - SPY, /* Stack Pointer, Offset with Y. */ - REL, /* Relative to Program Counter. */ - INA, /* Absolute Indirect. */ - INAX, /* Absolute Indexed Indirect. */ - INAY, /* Absolute Indirect Indexed. */ - EIND, /* Effective Address Register, Indirect. */ -}; |