···
0x00 => self.brk(pins), // BRK
113
-
0x01 => if (self.zpXInd(pins)) self.ora(pins, v), // ORA (zp,X)
114
-
0x05 => if (self.zp(pins)) self.ora(pins, v), // ORA zp
115
-
0x06 => if (self.zp(pins)) self.asl(pins, .mem), // ASL zp
116
-
0x09 => if (self.imm(pins)) self.ora(pins, v), // ORA #
117
-
0x0a => if (self.imm(pins)) self.asl(pins, .acc), // ASL A
118
-
0x0d => if (self.abs(pins)) self.ora(pins, v), // ORA abs
119
-
0x0e => if (self.abs(pins)) self.asl(pins, .mem), // ASL abs
121
-
0x10 => if (self.imm(pins)) self.branch(pins, !self.status.negative), // BPL
122
-
0x11 => if (self.zpIndY(pins)) self.ora(pins, v), // ORA (zp),Y
123
-
0x15 => if (self.zpOff(pins, self.x)) self.ora(pins, v), // ORA zp,X
124
-
0x16 => if (self.zpOff(pins, self.x)) self.asl(pins, .mem), // ASL zp,X
112
+
0x01 => if (self.zpXInd(pins)) |_| self.ora(pins, v), // ORA (zp,X)
113
+
0x05 => if (self.zp(pins)) |_| self.ora(pins, v), // ORA zp
114
+
0x06 => if (self.zp(pins)) |_| self.asl(pins, .mem), // ASL zp
115
+
0x09 => if (self.imm(pins)) |_| self.ora(pins, v), // ORA #
116
+
0x0a => if (self.imm(pins)) |_| self.asl(pins, .acc), // ASL A
117
+
0x0d => if (self.abs(pins)) |_| self.ora(pins, v), // ORA abs
118
+
0x0e => if (self.abs(pins)) |_| self.asl(pins, .mem), // ASL abs
120
+
0x10 => if (self.imm(pins)) |_| self.branch(pins, !self.status.negative), // BPL
121
+
0x11 => if (self.zpIndY(pins)) |_| self.ora(pins, v), // ORA (zp),Y
122
+
0x15 => if (self.zpOff(pins, self.x)) |_| self.ora(pins, v), // ORA zp,X
123
+
0x16 => if (self.zpOff(pins, self.x)) |_| self.asl(pins, .mem), // ASL zp,X
0x18 => self.set(pins, .carry, false), // CLC
126
-
0x19 => if (self.absOff(pins, self.y)) self.ora(pins, v), // ORA abs,Y
127
-
0x1d => if (self.absOff(pins, self.x)) self.ora(pins, v), // ORA abs,X
128
-
0x1e => if (self.absOff(pins, self.x)) self.asl(pins, .mem), // ASL abs,X
130
-
0x21 => if (self.zpXInd(pins)) self._and(pins, v), // AND (zp,X)
131
-
0x25 => if (self.zp(pins)) self._and(pins, v), // AND zp
132
-
0x26 => if (self.zp(pins)) self.rol(pins, .mem), // ROL zp
133
-
0x29 => if (self.imm(pins)) self._and(pins, v), // AND #
134
-
0x2a => if (self.imm(pins)) self.rol(pins, .acc), // ROL A
135
-
0x2d => if (self.abs(pins)) self._and(pins, v), // AND abs
136
-
0x2e => if (self.abs(pins)) self.rol(pins, .mem), // ROL abs
138
-
0x30 => if (self.imm(pins)) self.branch(pins, self.status.negative), // BMI
139
-
0x31 => if (self.zpIndY(pins)) self._and(pins, v), // AND (zp),Y
140
-
0x35 => if (self.zpOff(pins, self.x)) self._and(pins, v), // AND zp,X
141
-
0x36 => if (self.zpOff(pins, self.x)) self.rol(pins, .mem), // ROL zp,X
125
+
0x19 => if (self.absOff(pins, self.y)) |_| self.ora(pins, v), // ORA abs,Y
126
+
0x1d => if (self.absOff(pins, self.x)) |_| self.ora(pins, v), // ORA abs,X
127
+
0x1e => if (self.absOff(pins, self.x)) |_| self.asl(pins, .mem), // ASL abs,X
129
+
0x20 => self.jsr(pins), // JSR abs
130
+
0x21 => if (self.zpXInd(pins)) |_| self._and(pins, v), // AND (zp,X)
131
+
0x24 => if (self.zp(pins)) |_| self.bit(pins), // BIT zp
132
+
0x25 => if (self.zp(pins)) |_| self._and(pins, v), // AND zp
133
+
0x26 => if (self.zp(pins)) |_| self.rol(pins, .mem), // ROL zp
134
+
0x29 => if (self.imm(pins)) |_| self._and(pins, v), // AND #
135
+
0x2a => if (self.imm(pins)) |_| self.rol(pins, .acc), // ROL A
136
+
0x2c => if (self.abs(pins)) |_| self.bit(pins), // BIT abs
137
+
0x2d => if (self.abs(pins)) |_| self._and(pins, v), // AND abs
138
+
0x2e => if (self.abs(pins)) |_| self.rol(pins, .mem), // ROL abs
140
+
0x30 => if (self.imm(pins)) |_| self.branch(pins, self.status.negative), // BMI
141
+
0x31 => if (self.zpIndY(pins)) |_| self._and(pins, v), // AND (zp),Y
142
+
0x35 => if (self.zpOff(pins, self.x)) |_| self._and(pins, v), // AND zp,X
143
+
0x36 => if (self.zpOff(pins, self.x)) |_| self.rol(pins, .mem), // ROL zp,X
0x38 => self.set(pins, .carry, true), // SEC
143
-
0x39 => if (self.absOff(pins, self.y)) self._and(pins, v), // AND abs,Y
144
-
0x3d => if (self.absOff(pins, self.x)) self._and(pins, v), // AND abs,X
145
-
0x3e => if (self.absOff(pins, self.x)) self.rol(pins, .mem), // ROL abs,X
145
+
0x39 => if (self.absOff(pins, self.y)) |_| self._and(pins, v), // AND abs,Y
146
+
0x3d => if (self.absOff(pins, self.x)) |_| self._and(pins, v), // AND abs,X
147
+
0x3e => if (self.absOff(pins, self.x)) |_| self.rol(pins, .mem), // ROL abs,X
0x40 => self.rti(pins), // RTI
148
-
0x41 => if (self.zpXInd(pins)) self.eor(pins, v), // EOR (zp,X)
149
-
0x45 => if (self.zp(pins)) self.eor(pins, v), // EOR zp
150
-
0x46 => if (self.zp(pins)) self.lsr(pins, .mem), // LSR zp
151
-
0x49 => if (self.imm(pins)) self.eor(pins, v), // EOR #
152
-
0x4a => if (self.imm(pins)) self.lsr(pins, .acc), // LSR A
153
-
0x4d => if (self.abs(pins)) self.eor(pins, v), // EOR abs
154
-
0x4e => if (self.abs(pins)) self.lsr(pins, .mem), // LSR abs
156
-
0x50 => if (self.imm(pins)) self.branch(pins, !self.status.overflow), // BVC
157
-
0x51 => if (self.zpIndY(pins)) self.eor(pins, v), // EOR (zp),Y
158
-
0x55 => if (self.zpOff(pins, self.x)) self.eor(pins, v), // EOR zp,X
159
-
0x56 => if (self.zpOff(pins, self.x)) self.lsr(pins, .mem), // LSR zp,X
150
+
0x41 => if (self.zpXInd(pins)) |_| self.eor(pins, v), // EOR (zp,X)
151
+
0x45 => if (self.zp(pins)) |_| self.eor(pins, v), // EOR zp
152
+
0x46 => if (self.zp(pins)) |_| self.lsr(pins, .mem), // LSR zp
153
+
0x49 => if (self.imm(pins)) |_| self.eor(pins, v), // EOR #
154
+
0x4a => if (self.imm(pins)) |_| self.lsr(pins, .acc), // LSR A
155
+
0x4c => self.jmp(pins), // JMP abs
156
+
0x4d => if (self.abs(pins)) |_| self.eor(pins, v), // EOR abs
157
+
0x4e => if (self.abs(pins)) |_| self.lsr(pins, .mem), // LSR abs
159
+
0x50 => if (self.imm(pins)) |_| self.branch(pins, !self.status.overflow), // BVC
160
+
0x51 => if (self.zpIndY(pins)) |_| self.eor(pins, v), // EOR (zp),Y
161
+
0x55 => if (self.zpOff(pins, self.x)) |_| self.eor(pins, v), // EOR zp,X
162
+
0x56 => if (self.zpOff(pins, self.x)) |_| self.lsr(pins, .mem), // LSR zp,X
0x58 => self.set(pins, .irq_disabled, false), // CLI
161
-
0x59 => if (self.absOff(pins, self.y)) self.eor(pins, v), // EOR abs,Y
162
-
0x5d => if (self.absOff(pins, self.x)) self.eor(pins, v), // EOR abs,X
163
-
0x5e => if (self.absOff(pins, self.x)) self.lsr(pins, .mem), // LSR abs,X
165
-
// 0x61 => if (self.zpXInd(pins)) self.adc(pins, v), // ADC (zp,X)
166
-
// 0x65 => if (self.zp(pins)) self.adc(pins, v), // ADC zp
167
-
0x66 => if (self.zp(pins)) self.ror(pins, .mem), // ROR zp
168
-
// 0x69 => if (self.imm(pins)) self.adc(pins, v), // ADC #
169
-
0x6a => if (self.imm(pins)) self.ror(pins, .acc), // ROR A
170
-
// 0x6d => if (self.abs(pins)) self.adc(pins, v), // ADC abs
171
-
0x6e => if (self.abs(pins)) self.ror(pins, .mem), // ROR abs
173
-
0x70 => if (self.imm(pins)) self.branch(pins, self.status.overflow), // BVS
174
-
// 0x71 => if (self.zpIndY(pins)) self.adc(pins, v), // ADC (zp),Y
175
-
// 0x75 => if (self.zpOff(pins, self.x)) self.adc(pins, v), // ADC zp,X
176
-
0x76 => if (self.zpOff(pins, self.x)) self.ror(pins, .mem), // ROR zp,X
164
+
0x59 => if (self.absOff(pins, self.y)) |_| self.eor(pins, v), // EOR abs,Y
165
+
0x5d => if (self.absOff(pins, self.x)) |_| self.eor(pins, v), // EOR abs,X
166
+
0x5e => if (self.absOff(pins, self.x)) |_| self.lsr(pins, .mem), // LSR abs,X
168
+
0x60 => self.rts(pins), // RTS
169
+
0x61 => if (self.zpXInd(pins)) |_| self.adc(pins, v), // ADC (zp,X)
170
+
0x65 => if (self.zp(pins)) |_| self.adc(pins, v), // ADC zp
171
+
0x66 => if (self.zp(pins)) |_| self.ror(pins, .mem), // ROR zp
172
+
0x69 => if (self.imm(pins)) |_| self.adc(pins, v), // ADC #
173
+
0x6a => if (self.imm(pins)) |_| self.ror(pins, .acc), // ROR A
174
+
0x6c => self.jmpInd(pins), // JMP (ind)
175
+
0x6d => if (self.abs(pins)) |_| self.adc(pins, v), // ADC abs
176
+
0x6e => if (self.abs(pins)) |_| self.ror(pins, .mem), // ROR abs
178
+
0x70 => if (self.imm(pins)) |_| self.branch(pins, self.status.overflow), // BVS
179
+
0x71 => if (self.zpIndY(pins)) |_| self.adc(pins, v), // ADC (zp),Y
180
+
0x75 => if (self.zpOff(pins, self.x)) |_| self.adc(pins, v), // ADC zp,X
181
+
0x76 => if (self.zpOff(pins, self.x)) |_| self.ror(pins, .mem), // ROR zp,X
0x78 => self.set(pins, .irq_disabled, true), // SEI
178
-
// 0x79 => if (self.absOff(pins, self.y)) self.adc(pins, v), // ADC abs,Y
179
-
// 0x7d => if (self.absOff(pins, self.x)) self.adc(pins, v), // ADC abs,X
180
-
0x7e => if (self.absOff(pins, self.x)) self.ror(pins, .mem), // ROR abs,X
182
-
0x81 => if (self.zpXInd(pins)) self.st(pins, self.y), // STA (zp,X)
183
-
0x84 => if (self.zp(pins)) self.st(pins, self.y), // STY zp
184
-
0x85 => if (self.zp(pins)) self.st(pins, self.a), // STA zp
185
-
0x86 => if (self.zp(pins)) self.st(pins, self.x), // STX zp
186
-
0x88 => if (self.imm(pins)) self.dec(pins, &self.y), // DEY
187
-
0x8a => if (self.imm(pins)) self.ld(pins, &self.a, self.x), // TXA
188
-
0x8c => if (self.abs(pins)) self.st(pins, self.y), // STY abs
189
-
0x8d => if (self.abs(pins)) self.st(pins, self.a), // STA abs
190
-
0x8e => if (self.abs(pins)) self.st(pins, self.x), // STX abs
192
-
0x90 => if (self.imm(pins)) self.branch(pins, !self.status.carry), // BCC
193
-
0x91 => if (self.zpIndY(pins)) self.ld(pins, &self.a, v), // STA (zp),Y
194
-
0x94 => if (self.zpOff(pins, self.x)) self.st(pins, self.y), // STY zp,X
195
-
0x95 => if (self.zpOff(pins, self.x)) self.st(pins, self.a), // STA zp,X
196
-
0x96 => if (self.zpOff(pins, self.y)) self.st(pins, self.x), // STX zp,Y
197
-
0x99 => if (self.absOff(pins, self.y)) self.st(pins, self.a), // STA abs,Y
198
-
0x9a => if (self.imm(pins)) self.ld(pins, &self.sp, self.x), // TXS
199
-
0x9c => if (self.absOff(pins, self.x)) self.st(pins, self.y), // STY abs,X
200
-
0x9d => if (self.absOff(pins, self.x)) self.st(pins, self.a), // STA abs,X
201
-
0x9e => if (self.absOff(pins, self.y)) self.st(pins, self.x), // STX abs,Y
203
-
0xa0 => if (self.imm(pins)) self.ld(pins, &self.y, v), // LDY #
204
-
0xa1 => if (self.zpXInd(pins)) self.ld(pins, &self.y, v), // LDA (zp,X)
205
-
0xa2 => if (self.imm(pins)) self.ld(pins, &self.x, v), // LDX #
206
-
0xa4 => if (self.zp(pins)) self.ld(pins, &self.y, v), // LDY zp
207
-
0xa5 => if (self.zp(pins)) self.ld(pins, &self.a, v), // LDA zp
208
-
0xa6 => if (self.zp(pins)) self.ld(pins, &self.x, v), // LDX zp
209
-
0xa8 => if (self.imm(pins)) self.ld(pins, &self.y, self.a), // TAY
210
-
0xa9 => if (self.imm(pins)) self.ld(pins, &self.a, v), // LDA #
211
-
0xaa => if (self.imm(pins)) self.ld(pins, &self.x, self.a), // TAX
212
-
0xac => if (self.abs(pins)) self.ld(pins, &self.y, v), // LDY abs
213
-
0xad => if (self.abs(pins)) self.ld(pins, &self.a, v), // LDA abs
214
-
0xae => if (self.abs(pins)) self.ld(pins, &self.x, v), // LDX abs
216
-
0xb0 => if (self.imm(pins)) self.branch(pins, self.status.carry), // BCS
217
-
0xb1 => if (self.zpIndY(pins)) self.ld(pins, &self.a, v), // LDA (zp),Y
218
-
0xb4 => if (self.zpOff(pins, self.x)) self.ld(pins, &self.y, v), // LDY zp,X
219
-
0xb5 => if (self.zpOff(pins, self.x)) self.ld(pins, &self.a, v), // LDA zp,X
220
-
0xb6 => if (self.zpOff(pins, self.y)) self.ld(pins, &self.x, v), // LDX zp,Y
183
+
0x79 => if (self.absOff(pins, self.y)) |_| self.adc(pins, v), // ADC abs,Y
184
+
0x7d => if (self.absOff(pins, self.x)) |_| self.adc(pins, v), // ADC abs,X
185
+
0x7e => if (self.absOff(pins, self.x)) |_| self.ror(pins, .mem), // ROR abs,X
187
+
0x81 => if (self.zpXInd(pins)) |_| self.st(pins, self.y), // STA (zp,X)
188
+
0x84 => if (self.zp(pins)) |_| self.st(pins, self.y), // STY zp
189
+
0x85 => if (self.zp(pins)) |_| self.st(pins, self.a), // STA zp
190
+
0x86 => if (self.zp(pins)) |_| self.st(pins, self.x), // STX zp
191
+
0x88 => if (self.imm(pins)) |_| self.dexy(pins, &self.y), // DEY
192
+
0x8a => if (self.imm(pins)) |_| self.ld(pins, &self.a, self.x), // TXA
193
+
0x8c => if (self.abs(pins)) |_| self.st(pins, self.y), // STY abs
194
+
0x8d => if (self.abs(pins)) |_| self.st(pins, self.a), // STA abs
195
+
0x8e => if (self.abs(pins)) |_| self.st(pins, self.x), // STX abs
197
+
0x90 => if (self.imm(pins)) |_| self.branch(pins, !self.status.carry), // BCC
198
+
0x91 => if (self.zpIndY(pins)) |_| self.ld(pins, &self.a, v), // STA (zp),Y
199
+
0x94 => if (self.zpOff(pins, self.x)) |_| self.st(pins, self.y), // STY zp,X
200
+
0x95 => if (self.zpOff(pins, self.x)) |_| self.st(pins, self.a), // STA zp,X
201
+
0x96 => if (self.zpOff(pins, self.y)) |_| self.st(pins, self.x), // STX zp,Y
202
+
0x99 => if (self.absOff(pins, self.y)) |_| self.st(pins, self.a), // STA abs,Y
203
+
0x9a => if (self.imm(pins)) |_| self.ld(pins, &self.sp, self.x), // TXS
204
+
0x9c => if (self.absOff(pins, self.x)) |_| self.st(pins, self.y), // STY abs,X
205
+
0x9d => if (self.absOff(pins, self.x)) |_| self.st(pins, self.a), // STA abs,X
206
+
0x9e => if (self.absOff(pins, self.y)) |_| self.st(pins, self.x), // STX abs,Y
208
+
0xa0 => if (self.imm(pins)) |_| self.ld(pins, &self.y, v), // LDY #
209
+
0xa1 => if (self.zpXInd(pins)) |_| self.ld(pins, &self.y, v), // LDA (zp,X)
210
+
0xa2 => if (self.imm(pins)) |_| self.ld(pins, &self.x, v), // LDX #
211
+
0xa4 => if (self.zp(pins)) |_| self.ld(pins, &self.y, v), // LDY zp
212
+
0xa5 => if (self.zp(pins)) |_| self.ld(pins, &self.a, v), // LDA zp
213
+
0xa6 => if (self.zp(pins)) |_| self.ld(pins, &self.x, v), // LDX zp
214
+
0xa8 => if (self.imm(pins)) |_| self.ld(pins, &self.y, self.a), // TAY
215
+
0xa9 => if (self.imm(pins)) |_| self.ld(pins, &self.a, v), // LDA #
216
+
0xaa => if (self.imm(pins)) |_| self.ld(pins, &self.x, self.a), // TAX
217
+
0xac => if (self.abs(pins)) |_| self.ld(pins, &self.y, v), // LDY abs
218
+
0xad => if (self.abs(pins)) |_| self.ld(pins, &self.a, v), // LDA abs
219
+
0xae => if (self.abs(pins)) |_| self.ld(pins, &self.x, v), // LDX abs
221
+
0xb0 => if (self.imm(pins)) |_| self.branch(pins, self.status.carry), // BCS
222
+
0xb1 => if (self.zpIndY(pins)) |_| self.ld(pins, &self.a, v), // LDA (zp),Y
223
+
0xb4 => if (self.zpOff(pins, self.x)) |_| self.ld(pins, &self.y, v), // LDY zp,X
224
+
0xb5 => if (self.zpOff(pins, self.x)) |_| self.ld(pins, &self.a, v), // LDA zp,X
225
+
0xb6 => if (self.zpOff(pins, self.y)) |_| self.ld(pins, &self.x, v), // LDX zp,Y
0xb8 => self.set(pins, .overflow, true), // SEV
222
-
0xb9 => if (self.absOff(pins, self.y)) self.ld(pins, &self.a, v), // LDA abs,Y
223
-
0xba => if (self.imm(pins)) self.ld(pins, &self.x, self.sp), // TSX
224
-
0xbc => if (self.absOff(pins, self.x)) self.ld(pins, &self.y, v), // LDY abs,X
225
-
0xbd => if (self.absOff(pins, self.x)) self.ld(pins, &self.a, v), // LDA abs,X
226
-
0xbe => if (self.absOff(pins, self.y)) self.ld(pins, &self.x, v), // LDX abs,Y
228
-
0xd0 => if (self.imm(pins)) self.branch(pins, !self.status.zero), // BNE
227
+
0xb9 => if (self.absOff(pins, self.y)) |_| self.ld(pins, &self.a, v), // LDA abs,Y
228
+
0xba => if (self.imm(pins)) |_| self.ld(pins, &self.x, self.sp), // TSX
229
+
0xbc => if (self.absOff(pins, self.x)) |_| self.ld(pins, &self.y, v), // LDY abs,X
230
+
0xbd => if (self.absOff(pins, self.x)) |_| self.ld(pins, &self.a, v), // LDA abs,X
231
+
0xbe => if (self.absOff(pins, self.y)) |_| self.ld(pins, &self.x, v), // LDX abs,Y
233
+
0xc0 => if (self.imm(pins)) |_| self.cmp(pins, self.y), // CPY #
234
+
0xc1 => if (self.zpXInd(pins)) |_| self.cmp(pins, self.a), // CMP (zp,X)
235
+
0xc4 => if (self.zp(pins)) |_| self.cmp(pins, self.y), // CPY zp
236
+
0xc5 => if (self.zp(pins)) |_| self.cmp(pins, self.a), // CMP zp
237
+
0xc6 => if (self.zp(pins)) |c| self.dec(pins, c), // DEC zp
238
+
0xc8 => if (self.imm(pins)) |_| self.inxy(pins, &self.y), // INY
239
+
0xc9 => if (self.imm(pins)) |_| self.cmp(pins, self.a), // CMP #
240
+
0xca => if (self.imm(pins)) |_| self.dexy(pins, &self.x), // DEY
241
+
0xcc => if (self.abs(pins)) |_| self.cmp(pins, self.y), // CPY abs
242
+
0xcd => if (self.abs(pins)) |_| self.cmp(pins, self.a), // CMP abs
243
+
0xce => if (self.abs(pins)) |c| self.dec(pins, c), // DEC abs
245
+
0xd0 => if (self.imm(pins)) |_| self.branch(pins, !self.status.zero), // BNE
246
+
0xd1 => if (self.zpIndY(pins)) |_| self.cmp(pins, self.a), // CMP (zp),Y
247
+
0xd5 => if (self.zpOff(pins, self.x)) |_| self.cmp(pins, self.a), // CMP zp,X
248
+
0xd6 => if (self.zpOff(pins, self.x)) |c| self.dec(pins, c), // DEC zp,X
0xd8 => self.set(pins, .decimal, false), // CLD
231
-
0xea => if (self.imm(pins)) self.fetch(pins), // NOP
233
-
0xf0 => if (self.imm(pins)) self.branch(pins, self.status.zero), // BEQ
250
+
0xd9 => if (self.absOff(pins, self.y)) |_| self.cmp(pins, self.a), // CMP abs,Y
251
+
0xdd => if (self.absOff(pins, self.x)) |_| self.cmp(pins, self.a), // CMP abs,X
252
+
0xde => if (self.absOff(pins, self.x)) |c| self.dec(pins, c), // DEC abs,X
254
+
0xe0 => if (self.imm(pins)) |_| self.cmp(pins, self.x), // CPX #
255
+
0xe1 => if (self.zpXInd(pins)) |_| self.sbc(pins, v), // SBC (zp,X)
256
+
0xe4 => if (self.zp(pins)) |_| self.cmp(pins, self.x), // CPX zp
257
+
0xe5 => if (self.zp(pins)) |_| self.sbc(pins, v), // SBC zp
258
+
0xe6 => if (self.zp(pins)) |c| self.inc(pins, c), // INC zp
259
+
0xe8 => if (self.imm(pins)) |_| self.inxy(pins, &self.x), // INX
260
+
0xe9 => if (self.imm(pins)) |_| self.sbc(pins, v), // SBC #
261
+
0xea => if (self.imm(pins)) |_| self.fetch(pins), // NOP
262
+
0xec => if (self.abs(pins)) |_| self.cmp(pins, self.x), // CPX abs
263
+
0xed => if (self.abs(pins)) |_| self.sbc(pins, v), // SBC abs
264
+
0xee => if (self.abs(pins)) |c| self.inc(pins, c), // INC abs
266
+
0xf0 => if (self.imm(pins)) |_| self.branch(pins, self.status.zero), // BEQ
267
+
0xf1 => if (self.zpIndY(pins)) |_| self.sbc(pins, v), // SBC (zp),Y
268
+
0xf5 => if (self.zpOff(pins, self.x)) |_| self.sbc(pins, v), // SBC zp,X
269
+
0xf6 => if (self.zpOff(pins, self.x)) |c| self.inc(pins, c), // INC zp,X
0xf8 => self.set(pins, .decimal, true), // SED
271
+
0xf9 => if (self.absOff(pins, self.y)) |_| self.sbc(pins, v), // SBC abs,Y
272
+
0xfd => if (self.absOff(pins, self.x)) |_| self.sbc(pins, v), // SBC abs,X
273
+
0xfe => if (self.absOff(pins, self.x)) |c| self.inc(pins, c), // INC abs,X
236
-
else => log.err("UNHANDLED OP={X}", .{self.opcode}),
276
+
log.err("UNHANDLED OP={X}", .{self.opcode});
240
-
inline fn imm(self: *Cpu, pins: *zesty.Pins) bool {
282
+
inline fn imm(self: *Cpu, pins: *zesty.Pins) ?u3 {
246
-
else => return true,
288
+
else => return self.cycle - 1,
250
-
inline fn zp(self: *Cpu, pins: *zesty.Pins) bool {
292
+
inline fn zp(self: *Cpu, pins: *zesty.Pins) ?u3 {
···
self.hilo = .{ .lo = pins.cpu_data };
pins.cpu_addr = self.hilo.addr();
260
-
else => return true,
302
+
else => return self.cycle - 2,
264
-
inline fn zpOff(self: *Cpu, pins: *zesty.Pins, v: u8) bool {
306
+
inline fn zpOff(self: *Cpu, pins: *zesty.Pins, v: u8) ?u3 {
···
pins.cpu_addr = self.hilo.addr();
278
-
else => return true,
320
+
else => return self.cycle - 3,
282
-
inline fn abs(self: *Cpu, pins: *zesty.Pins) bool {
324
+
inline fn abs(self: *Cpu, pins: *zesty.Pins) ?u3 {
···
self.hilo.hi = pins.cpu_data;
pins.cpu_addr = self.hilo.addr();
297
-
else => return true,
339
+
else => return self.cycle - 3,
301
-
inline fn absOff(self: *Cpu, pins: *zesty.Pins, v: u8) bool {
343
+
inline fn absOff(self: *Cpu, pins: *zesty.Pins, v: u8) ?u3 {
···
pins.cpu_addr = self.hilo.addr();
320
-
else => return true,
362
+
else => return self.cycle - 4,
324
-
inline fn zpXInd(self: *Cpu, pins: *zesty.Pins) bool {
366
+
inline fn zpXInd(self: *Cpu, pins: *zesty.Pins) ?u3 {
···
self.hilo.hi = pins.cpu_data;
pins.cpu_addr = self.hilo.addr();
347
-
else => return true,
389
+
else => return self.cycle - 5,
351
-
inline fn zpIndY(self: *Cpu, pins: *zesty.Pins) bool {
393
+
inline fn zpIndY(self: *Cpu, pins: *zesty.Pins) ?u3 {
···
pins.cpu_addr = self.hilo.addr();
370
-
else => return true,
412
+
else => return self.cycle - 5,
inline fn fetch(self: *Cpu, pins: *zesty.Pins) void {
···
486
-
inline fn dec(self: *Cpu, pins: *zesty.Pins, v: *u8) void {
528
+
inline fn adc(self: *Cpu, pins: *zesty.Pins, v: u8) void {
529
+
var result, var carry = @addWithOverflow(self.a, @intFromBool(self.status.carry));
530
+
// TODO: implement optional support for decimal mode
531
+
result, carry = @addWithOverflow(result, v);
533
+
self.status.carry = carry > 0;
534
+
self.setNZ(result);
535
+
// Overflow bit is set if both inputs have the same sign,
536
+
// and the output has a different sign
537
+
self.status.overflow = ~(self.a ^ v) & (self.a ^ result) & 0x80 > 0;
541
+
inline fn sbc(self: *Cpu, pins: *zesty.Pins, v: u8) void {
542
+
self.adc(pins, ~v);
544
+
inline fn cmp(self: *Cpu, pins: *zesty.Pins, v: u8) void {
545
+
// a CMP is basically a SBC in disguise
546
+
const result, const carry = @addWithOverflow(v, ~pins.cpu_data +% 1);
547
+
self.status.carry = carry > 0;
548
+
self.setNZ(result);
551
+
inline fn inxy(self: *Cpu, pins: *zesty.Pins, v: *u8) void {
557
+
inline fn dexy(self: *Cpu, pins: *zesty.Pins, v: *u8) void {
562
+
inline fn inc(self: *Cpu, pins: *zesty.Pins, c: u3) void {
565
+
// Dummy write? (Not sure why the processor does this)
566
+
self.hilo = .{ .lo = pins.cpu_data };
567
+
pins.cpu_rw = .write;
570
+
self.hilo.lo +%= 1;
571
+
self.setNZ(self.hilo.lo);
572
+
pins.cpu_data = self.hilo.lo;
573
+
pins.cpu_rw = .write;
575
+
else => self.fetch(pins),
578
+
inline fn dec(self: *Cpu, pins: *zesty.Pins, c: u3) void {
581
+
// Dummy write? (Not sure why the processor does this)
582
+
self.hilo = .{ .lo = pins.cpu_data };
583
+
pins.cpu_rw = .write;
586
+
self.hilo.lo -%= 1;
587
+
self.setNZ(self.hilo.lo);
588
+
pins.cpu_data = self.hilo.lo;
589
+
pins.cpu_rw = .write;
591
+
else => self.fetch(pins),
594
+
inline fn bit(self: *Cpu, pins: *zesty.Pins) void {
595
+
const status: Status = .from(pins.cpu_data);
596
+
self.status.negative = status.negative;
597
+
self.status.overflow = status.overflow;
598
+
self.status.zero = (self.a & pins.cpu_data) == 0;
//------------------------------------------------------
···
514
-
pins.cpu_addr = self.pc;
624
+
pins.cpu_addr = pc;
if (!page_crossed) self.fetchAt(pins, pc);
else => self.fetchAt(pins, self.hilo.addr()),
···
inline fn offsetWithPageFaultBehavior(
810
+
comptime signed: bool,
702
-
self.lo, const page_crossed = if (!signed and v < 0x80)
703
-
@addWithOverflow(self.lo, v)
812
+
const is_negative = signed and v >= 0x80;
813
+
self.lo, const page_crossed = if (is_negative)
// v should NEVER be lower than 0x80, but saturate down to 0 to be safe
706
-
@subWithOverflow(self.lo, v -| 0x80);
815
+
@subWithOverflow(self.lo, v - 0x80)
817
+
@addWithOverflow(self.lo, v);
// If we haven't crossed the page boundary, skip over the next cycle.
709
-
defer self.hi +%= page_crossed;
822
+
self.hi -%= page_crossed
824
+
self.hi +%= page_crossed;
return .{ self.addr(), page_crossed > 0 };
pluie.me