|
| 1 | +// This file is part of zinc64. |
| 2 | +// Copyright (c) 2016-2019 Sebastian Jastrzebski. All rights reserved. |
| 3 | +// Licensed under the GPLv3. See LICENSE file in the project root for full license text. |
| 4 | +#![allow(dead_code)] |
| 5 | + |
| 6 | +use core::fmt; |
| 7 | + |
| 8 | +pub enum Operand { |
| 9 | + Accumulator, |
| 10 | + Immediate(u8), |
| 11 | + ZeroPage(u8), |
| 12 | + ZeroPageX(u8), |
| 13 | + ZeroPageY(u8), |
| 14 | + Absolute(u16), |
| 15 | + AbsoluteX(u16), |
| 16 | + AbsoluteY(u16), |
| 17 | + IndirectX(u8), |
| 18 | + IndirectY(u8), |
| 19 | + Indirect(u16), |
| 20 | + Relative(i8), |
| 21 | +} |
| 22 | + |
| 23 | +pub enum Instruction { |
| 24 | + // Data Movement (16) |
| 25 | + LDA(Operand), |
| 26 | + LDX(Operand), |
| 27 | + LDY(Operand), |
| 28 | + PHA, |
| 29 | + PHP, |
| 30 | + PLA, |
| 31 | + PLP, |
| 32 | + STA(Operand), |
| 33 | + STX(Operand), |
| 34 | + STY(Operand), |
| 35 | + TAX, |
| 36 | + TAY, |
| 37 | + TSX, |
| 38 | + TXA, |
| 39 | + TXS, |
| 40 | + TYA, |
| 41 | + // Arithmetic (11) |
| 42 | + ADC(Operand), |
| 43 | + SBC(Operand), |
| 44 | + CMP(Operand), |
| 45 | + CPX(Operand), |
| 46 | + CPY(Operand), |
| 47 | + DEC(Operand), |
| 48 | + DEX, |
| 49 | + DEY, |
| 50 | + INC(Operand), |
| 51 | + INX, |
| 52 | + INY, |
| 53 | + // Logical (3) |
| 54 | + AND(Operand), |
| 55 | + EOR(Operand), |
| 56 | + ORA(Operand), |
| 57 | + // Shift and Rotate (4) |
| 58 | + ASL(Operand), |
| 59 | + LSR(Operand), |
| 60 | + ROL(Operand), |
| 61 | + ROR(Operand), |
| 62 | + // Control Flow (11) |
| 63 | + BCC(Operand), |
| 64 | + BCS(Operand), |
| 65 | + BEQ(Operand), |
| 66 | + BMI(Operand), |
| 67 | + BNE(Operand), |
| 68 | + BPL(Operand), |
| 69 | + BVC(Operand), |
| 70 | + BVS(Operand), |
| 71 | + JMP(Operand), |
| 72 | + JSR(Operand), |
| 73 | + RTS, |
| 74 | + // Misc (11) |
| 75 | + BIT(Operand), |
| 76 | + BRK, |
| 77 | + CLC, |
| 78 | + CLD, |
| 79 | + CLI, |
| 80 | + CLV, |
| 81 | + NOP, |
| 82 | + SEC, |
| 83 | + SED, |
| 84 | + SEI, |
| 85 | + RTI, |
| 86 | + // Undocumented |
| 87 | + ANE(Operand), |
| 88 | + ANX(Operand), |
| 89 | + ALR(Operand), |
| 90 | + AXS(Operand), |
| 91 | + LAX(Operand), |
| 92 | + LSE(Operand), |
| 93 | +} |
| 94 | + |
| 95 | +impl fmt::Display for Operand { |
| 96 | + fn fmt(&self, f: &mut fmt::Formatter<'_>) -> fmt::Result { |
| 97 | + match *self { |
| 98 | + Operand::Accumulator => write!(f, "acc"), |
| 99 | + Operand::Immediate(value) => write!(f, "#{:02x}", value), |
| 100 | + Operand::ZeroPage(address) => write!(f, "${:02x}", address), |
| 101 | + Operand::ZeroPageX(address) => write!(f, "${:02x},x", address), |
| 102 | + Operand::ZeroPageY(address) => write!(f, "${:02x},y", address), |
| 103 | + Operand::Absolute(address) => write!(f, "${:04x}", address), |
| 104 | + Operand::AbsoluteX(address) => write!(f, "${:04x},x", address), |
| 105 | + Operand::AbsoluteY(address) => write!(f, "${:04x},y", address), |
| 106 | + Operand::IndirectX(address) => write!(f, "$({:02x},x)", address), |
| 107 | + Operand::IndirectY(address) => write!(f, "$({:02x},y)", address), |
| 108 | + Operand::Indirect(address) => write!(f, "$({:04x})", address), |
| 109 | + Operand::Relative(offset) => write!(f, "${:02x}", offset), |
| 110 | + } |
| 111 | + } |
| 112 | +} |
| 113 | + |
| 114 | +impl fmt::Display for Instruction { |
| 115 | + fn fmt(&self, f: &mut fmt::Formatter<'_>) -> fmt::Result { |
| 116 | + match *self { |
| 117 | + // Data Movement |
| 118 | + Instruction::LDA(ref operand) => write!(f, "lda {}", operand), |
| 119 | + Instruction::LDX(ref operand) => write!(f, "ldx {}", operand), |
| 120 | + Instruction::LDY(ref operand) => write!(f, "ldy {}", operand), |
| 121 | + Instruction::PHA => write!(f, "pha"), |
| 122 | + Instruction::PHP => write!(f, "php"), |
| 123 | + Instruction::PLA => write!(f, "pla"), |
| 124 | + Instruction::PLP => write!(f, "plp"), |
| 125 | + Instruction::STA(ref operand) => write!(f, "sta {}", operand), |
| 126 | + Instruction::STX(ref operand) => write!(f, "stx {}", operand), |
| 127 | + Instruction::STY(ref operand) => write!(f, "sty {}", operand), |
| 128 | + Instruction::TAX => write!(f, "tax"), |
| 129 | + Instruction::TAY => write!(f, "tay"), |
| 130 | + Instruction::TSX => write!(f, "tsx"), |
| 131 | + Instruction::TXA => write!(f, "txa"), |
| 132 | + Instruction::TXS => write!(f, "txs"), |
| 133 | + Instruction::TYA => write!(f, "tya"), |
| 134 | + // Arithmetic |
| 135 | + Instruction::ADC(ref operand) => write!(f, "adc {}", operand), |
| 136 | + Instruction::SBC(ref operand) => write!(f, "sbc {}", operand), |
| 137 | + Instruction::CMP(ref operand) => write!(f, "cmp {}", operand), |
| 138 | + Instruction::CPX(ref operand) => write!(f, "cpx {}", operand), |
| 139 | + Instruction::CPY(ref operand) => write!(f, "cpy {}", operand), |
| 140 | + Instruction::DEC(ref operand) => write!(f, "dec {}", operand), |
| 141 | + Instruction::DEX => write!(f, "dex"), |
| 142 | + Instruction::DEY => write!(f, "dey"), |
| 143 | + Instruction::INC(ref operand) => write!(f, "inc {}", operand), |
| 144 | + Instruction::INX => write!(f, "inx"), |
| 145 | + Instruction::INY => write!(f, "iny"), |
| 146 | + // Logical |
| 147 | + Instruction::AND(ref operand) => write!(f, "and {}", operand), |
| 148 | + Instruction::EOR(ref operand) => write!(f, "eor {}", operand), |
| 149 | + Instruction::ORA(ref operand) => write!(f, "ora {}", operand), |
| 150 | + // Shift and Rotate |
| 151 | + Instruction::ASL(ref operand) => write!(f, "asl {}", operand), |
| 152 | + Instruction::LSR(ref operand) => write!(f, "lsr {}", operand), |
| 153 | + Instruction::ROL(ref operand) => write!(f, "rol {}", operand), |
| 154 | + Instruction::ROR(ref operand) => write!(f, "ror {}", operand), |
| 155 | + // Control Flow |
| 156 | + Instruction::BCC(ref operand) => write!(f, "bcc {}", operand), |
| 157 | + Instruction::BCS(ref operand) => write!(f, "bcs {}", operand), |
| 158 | + Instruction::BEQ(ref operand) => write!(f, "beq {}", operand), |
| 159 | + Instruction::BMI(ref operand) => write!(f, "bmi {}", operand), |
| 160 | + Instruction::BNE(ref operand) => write!(f, "bne {}", operand), |
| 161 | + Instruction::BPL(ref operand) => write!(f, "bpl {}", operand), |
| 162 | + Instruction::BVC(ref operand) => write!(f, "bvc {}", operand), |
| 163 | + Instruction::BVS(ref operand) => write!(f, "bvs {}", operand), |
| 164 | + Instruction::JMP(ref operand) => write!(f, "jmp {}", operand), |
| 165 | + Instruction::JSR(ref operand) => write!(f, "jsr {}", operand), |
| 166 | + Instruction::RTS => write!(f, "rts"), |
| 167 | + // Misc |
| 168 | + Instruction::BIT(ref operand) => write!(f, "bit {}", operand), |
| 169 | + Instruction::BRK => write!(f, "brk"), |
| 170 | + Instruction::CLC => write!(f, "clc"), |
| 171 | + Instruction::CLD => write!(f, "cld"), |
| 172 | + Instruction::CLI => write!(f, "cli"), |
| 173 | + Instruction::CLV => write!(f, "clv"), |
| 174 | + Instruction::NOP => write!(f, "nop"), |
| 175 | + Instruction::SEC => write!(f, "sec"), |
| 176 | + Instruction::SED => write!(f, "sed"), |
| 177 | + Instruction::SEI => write!(f, "sei"), |
| 178 | + Instruction::RTI => write!(f, "rti"), |
| 179 | + // Undocumented |
| 180 | + Instruction::ANE(ref operand) => write!(f, "ane {}", operand), |
| 181 | + Instruction::ANX(ref operand) => write!(f, "anx {}", operand), |
| 182 | + Instruction::ALR(ref operand) => write!(f, "alr {}", operand), |
| 183 | + Instruction::AXS(ref operand) => write!(f, "axs {}", operand), |
| 184 | + Instruction::LAX(ref operand) => write!(f, "lax {}", operand), |
| 185 | + Instruction::LSE(ref operand) => write!(f, "lse {}", operand), |
| 186 | + } |
| 187 | + } |
| 188 | +} |
0 commit comments