← Back to branch summary

~ubuntu-branches/ubuntu/lucid/fceux/lucid

« back to all changes in this revision

Viewing changes to fceu/src/ops.inc

  • Committer: Bazaar Package Importer
  • Author(s): Fabrice Coutadeur
  • Date: 2009-12-14 08:05:17 UTC
  • Revision ID: james.westby@ubuntu.com-20091214080517-abi5tj8avthfan7c
Tags: upstream-2.1.2+repack
Import upstream version 2.1.2+repack

Show diffs side-by-side

added added

removed removed

Lines of Context:
fceu/src/ops.inc
 
1
/* FCE Ultra - NES/Famicom Emulator
 
2
 *
 
3
 * Copyright notice for this file:
 
4
 *  Copyright (C) 2002 Xodnizel
 
5
 *
 
6
 * This program is free software; you can redistribute it and/or modify
 
7
 * it under the terms of the GNU General Public License as published by
 
8
 * the Free Software Foundation; either version 2 of the License, or
 
9
 * (at your option) any later version.
 
10
 *
 
11
 * This program is distributed in the hope that it will be useful,
 
12
 * but WITHOUT ANY WARRANTY; without even the implied warranty of
 
13
 * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
 
14
 * GNU General Public License for more details.
 
15
 *
 
16
 * You should have received a copy of the GNU General Public License
 
17
 * along with this program; if not, write to the Free Software
 
18
 * Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA  02111-1307  USA
 
19
 */
 
20
 
 
21
case 0x00:  /* BRK */
 
22
            _PC++;
 
23
            PUSH(_PC>>8);
 
24
            PUSH(_PC);
 
25
            PUSH(_P|U_FLAG|B_FLAG);
 
26
            _P|=I_FLAG;
 
27
            _PI|=I_FLAG;
 
28
            _PC=RdMem(0xFFFE);
 
29
            _PC|=RdMem(0xFFFF)<<8;
 
30
            break;
 
31
 
 
32
case 0x40:  /* RTI */
 
33
            _P=POP();
 
34
            /* _PI=_P; This is probably incorrect, so it's commented out. */
 
35
            _PI = _P;
 
36
            _PC=POP();
 
37
            _PC|=POP()<<8;
 
38
            break;
 
39
            
 
40
case 0x60:  /* RTS */
 
41
            _PC=POP();
 
42
            _PC|=POP()<<8;
 
43
            _PC++;
 
44
            break;
 
45
 
 
46
case 0x48: /* PHA */
 
47
           PUSH(_A);
 
48
           break;
 
49
case 0x08: /* PHP */
 
50
           PUSH(_P|U_FLAG|B_FLAG);
 
51
           break;
 
52
case 0x68: /* PLA */
 
53
           _A=POP();
 
54
           X_ZN(_A);
 
55
           break;
 
56
case 0x28: /* PLP */
 
57
           _P=POP();
 
58
           break;
 
59
case 0x4C:
 
60
          {
 
61
           uint16 ptmp=_PC;
 
62
           unsigned int npc;
 
63
 
 
64
           npc=RdMem(ptmp);
 
65
           ptmp++;
 
66
           npc|=RdMem(ptmp)<<8;
 
67
           _PC=npc;
 
68
          }
 
69
          break; /* JMP ABSOLUTE */
 
70
case 0x6C: 
 
71
           {
 
72
            uint32 tmp;
 
73
            GetAB(tmp);
 
74
            _PC=RdMem(tmp);
 
75
            _PC|=RdMem( ((tmp+1)&0x00FF) | (tmp&0xFF00))<<8;
 
76
           }
 
77
           break;
 
78
case 0x20: /* JSR */
 
79
           {
 
80
            uint8 npc;
 
81
            npc=RdMem(_PC);
 
82
            _PC++;
 
83
            PUSH(_PC>>8);
 
84
            PUSH(_PC);
 
85
            _PC=RdMem(_PC)<<8;
 
86
            _PC|=npc;
 
87
           }
 
88
           break;
 
89
 
 
90
case 0xAA: /* TAX */
 
91
           _X=_A;
 
92
           X_ZN(_A);
 
93
           break;
 
94
 
 
95
case 0x8A: /* TXA */
 
96
           _A=_X;
 
97
           X_ZN(_A);
 
98
           break;
 
99
 
 
100
case 0xA8: /* TAY */
 
101
           _Y=_A;
 
102
           X_ZN(_A);
 
103
           break;
 
104
case 0x98: /* TYA */
 
105
           _A=_Y;
 
106
           X_ZN(_A);
 
107
           break;
 
108
 
 
109
case 0xBA: /* TSX */
 
110
           _X=_S;
 
111
           X_ZN(_X);
 
112
           break;
 
113
case 0x9A: /* TXS */
 
114
           _S=_X;
 
115
           break;
 
116
 
 
117
case 0xCA: /* DEX */
 
118
           _X--;
 
119
           X_ZN(_X);
 
120
           break;
 
121
case 0x88: /* DEY */
 
122
           _Y--;
 
123
           X_ZN(_Y);
 
124
           break;
 
125
 
 
126
case 0xE8: /* INX */
 
127
           _X++;
 
128
           X_ZN(_X);
 
129
           break;
 
130
case 0xC8: /* INY */
 
131
           _Y++;
 
132
           X_ZN(_Y);
 
133
           break;
 
134
 
 
135
case 0x18: /* CLC */
 
136
           _P&=~C_FLAG;
 
137
           break;
 
138
case 0xD8: /* CLD */
 
139
           _P&=~D_FLAG;
 
140
           break;
 
141
case 0x58: /* CLI */
 
142
           _P&=~I_FLAG;
 
143
           break;
 
144
case 0xB8: /* CLV */
 
145
           _P&=~V_FLAG;
 
146
           break;
 
147
 
 
148
case 0x38: /* SEC */
 
149
           _P|=C_FLAG;
 
150
           break;
 
151
case 0xF8: /* SED */
 
152
           _P|=D_FLAG;
 
153
           break;
 
154
case 0x78: /* SEI */
 
155
           _P|=I_FLAG;
 
156
           break;
 
157
 
 
158
case 0xEA: /* NOP */
 
159
           break;
 
160
 
 
161
case 0x0A: RMW_A(ASL);
 
162
case 0x06: RMW_ZP(ASL);
 
163
case 0x16: RMW_ZPX(ASL);
 
164
case 0x0E: RMW_AB(ASL);
 
165
case 0x1E: RMW_ABX(ASL);
 
166
 
 
167
case 0xC6: RMW_ZP(DEC);
 
168
case 0xD6: RMW_ZPX(DEC);
 
169
case 0xCE: RMW_AB(DEC);
 
170
case 0xDE: RMW_ABX(DEC);
 
171
 
 
172
case 0xE6: RMW_ZP(INC);
 
173
case 0xF6: RMW_ZPX(INC);
 
174
case 0xEE: RMW_AB(INC);
 
175
case 0xFE: RMW_ABX(INC);
 
176
 
 
177
case 0x4A: RMW_A(LSR);
 
178
case 0x46: RMW_ZP(LSR);
 
179
case 0x56: RMW_ZPX(LSR);
 
180
case 0x4E: RMW_AB(LSR);
 
181
case 0x5E: RMW_ABX(LSR);
 
182
 
 
183
case 0x2A: RMW_A(ROL);
 
184
case 0x26: RMW_ZP(ROL);
 
185
case 0x36: RMW_ZPX(ROL);
 
186
case 0x2E: RMW_AB(ROL);
 
187
case 0x3E: RMW_ABX(ROL);
 
188
 
 
189
case 0x6A: RMW_A(ROR);
 
190
case 0x66: RMW_ZP(ROR);
 
191
case 0x76: RMW_ZPX(ROR);
 
192
case 0x6E: RMW_AB(ROR);
 
193
case 0x7E: RMW_ABX(ROR);
 
194
 
 
195
case 0x69: LD_IM(ADC);
 
196
case 0x65: LD_ZP(ADC);
 
197
case 0x75: LD_ZPX(ADC);
 
198
case 0x6D: LD_AB(ADC);
 
199
case 0x7D: LD_ABX(ADC);
 
200
case 0x79: LD_ABY(ADC);
 
201
case 0x61: LD_IX(ADC);
 
202
case 0x71: LD_IY(ADC);
 
203
 
 
204
case 0x29: LD_IM(AND);
 
205
case 0x25: LD_ZP(AND);
 
206
case 0x35: LD_ZPX(AND);
 
207
case 0x2D: LD_AB(AND);
 
208
case 0x3D: LD_ABX(AND);
 
209
case 0x39: LD_ABY(AND);
 
210
case 0x21: LD_IX(AND);
 
211
case 0x31: LD_IY(AND);
 
212
 
 
213
case 0x24: LD_ZP(BIT);
 
214
case 0x2C: LD_AB(BIT);
 
215
 
 
216
case 0xC9: LD_IM(CMP);
 
217
case 0xC5: LD_ZP(CMP);
 
218
case 0xD5: LD_ZPX(CMP);
 
219
case 0xCD: LD_AB(CMP);
 
220
case 0xDD: LD_ABX(CMP);
 
221
case 0xD9: LD_ABY(CMP);
 
222
case 0xC1: LD_IX(CMP);
 
223
case 0xD1: LD_IY(CMP);
 
224
 
 
225
case 0xE0: LD_IM(CPX);
 
226
case 0xE4: LD_ZP(CPX);
 
227
case 0xEC: LD_AB(CPX);
 
228
 
 
229
case 0xC0: LD_IM(CPY);
 
230
case 0xC4: LD_ZP(CPY);
 
231
case 0xCC: LD_AB(CPY);
 
232
 
 
233
case 0x49: LD_IM(EOR);
 
234
case 0x45: LD_ZP(EOR);
 
235
case 0x55: LD_ZPX(EOR);
 
236
case 0x4D: LD_AB(EOR);
 
237
case 0x5D: LD_ABX(EOR);
 
238
case 0x59: LD_ABY(EOR);
 
239
case 0x41: LD_IX(EOR);
 
240
case 0x51: LD_IY(EOR);
 
241
 
 
242
case 0xA9: LD_IM(LDA);
 
243
case 0xA5: LD_ZP(LDA);
 
244
case 0xB5: LD_ZPX(LDA);
 
245
case 0xAD: LD_AB(LDA);
 
246
case 0xBD: LD_ABX(LDA);
 
247
case 0xB9: LD_ABY(LDA);
 
248
case 0xA1: LD_IX(LDA);
 
249
case 0xB1: LD_IY(LDA);
 
250
 
 
251
case 0xA2: LD_IM(LDX);
 
252
case 0xA6: LD_ZP(LDX);
 
253
case 0xB6: LD_ZPY(LDX);
 
254
case 0xAE: LD_AB(LDX);
 
255
case 0xBE: LD_ABY(LDX);
 
256
 
 
257
case 0xA0: LD_IM(LDY);
 
258
case 0xA4: LD_ZP(LDY);
 
259
case 0xB4: LD_ZPX(LDY);
 
260
case 0xAC: LD_AB(LDY);
 
261
case 0xBC: LD_ABX(LDY);
 
262
 
 
263
case 0x09: LD_IM(ORA);
 
264
case 0x05: LD_ZP(ORA);
 
265
case 0x15: LD_ZPX(ORA);
 
266
case 0x0D: LD_AB(ORA);
 
267
case 0x1D: LD_ABX(ORA);
 
268
case 0x19: LD_ABY(ORA);
 
269
case 0x01: LD_IX(ORA);
 
270
case 0x11: LD_IY(ORA);
 
271
 
 
272
case 0xEB:  /* (undocumented) */
 
273
case 0xE9: LD_IM(SBC);
 
274
case 0xE5: LD_ZP(SBC);
 
275
case 0xF5: LD_ZPX(SBC);
 
276
case 0xED: LD_AB(SBC);
 
277
case 0xFD: LD_ABX(SBC);
 
278
case 0xF9: LD_ABY(SBC);
 
279
case 0xE1: LD_IX(SBC);
 
280
case 0xF1: LD_IY(SBC);
 
281
 
 
282
case 0x85: ST_ZP(_A);
 
283
case 0x95: ST_ZPX(_A);
 
284
case 0x8D: ST_AB(_A);
 
285
case 0x9D: ST_ABX(_A);
 
286
case 0x99: ST_ABY(_A);
 
287
case 0x81: ST_IX(_A);
 
288
case 0x91: ST_IY(_A);
 
289
 
 
290
case 0x86: ST_ZP(_X);
 
291
case 0x96: ST_ZPY(_X);
 
292
case 0x8E: ST_AB(_X);
 
293
 
 
294
case 0x84: ST_ZP(_Y);
 
295
case 0x94: ST_ZPX(_Y);
 
296
case 0x8C: ST_AB(_Y);
 
297
 
 
298
/* BCC */
 
299
case 0x90: JR(!(_P&C_FLAG)); break;
 
300
 
 
301
/* BCS */
 
302
case 0xB0: JR(_P&C_FLAG); break;
 
303
 
 
304
/* BEQ */
 
305
case 0xF0: JR(_P&Z_FLAG); break;
 
306
 
 
307
/* BNE */
 
308
case 0xD0: JR(!(_P&Z_FLAG)); break;
 
309
 
 
310
/* BMI */
 
311
case 0x30: JR(_P&N_FLAG); break;
 
312
 
 
313
/* BPL */
 
314
case 0x10: JR(!(_P&N_FLAG)); break;
 
315
 
 
316
/* BVC */
 
317
case 0x50: JR(!(_P&V_FLAG)); break;
 
318
 
 
319
/* BVS */
 
320
case 0x70: JR(_P&V_FLAG); break;
 
321
 
 
322
//default: printf("Bad %02x at $%04x\n",b1,X.PC);break;
 
323
//ifdef moo
 
324
/* Here comes the undocumented instructions block.  Note that this implementation
 
325
   may be "wrong".  If so, please tell me.
 
326
*/
 
327
 
 
328
/* AAC */
 
329
case 0x2B:
 
330
case 0x0B: LD_IM(AND;_P&=~C_FLAG;_P|=_A>>7);
 
331
 
 
332
/* AAX */
 
333
case 0x87: ST_ZP(_A&_X);
 
334
case 0x97: ST_ZPY(_A&_X);
 
335
case 0x8F: ST_AB(_A&_X);
 
336
case 0x83: ST_IX(_A&_X);
 
337
 
 
338
/* ARR - ARGH, MATEY! */
 
339
case 0x6B: { 
 
340
             uint8 arrtmp; 
 
341
             LD_IM(AND;_P&=~V_FLAG;_P|=(_A^(_A>>1))&0x40;arrtmp=_A>>7;_A>>=1;_A|=(_P&C_FLAG)<<7;_P&=~C_FLAG;_P|=arrtmp;X_ZN(_A));
 
342
           }
 
343
/* ASR */
 
344
case 0x4B: LD_IM(AND;LSRA);
 
345
 
 
346
/* ATX(OAL) Is this(OR with $EE) correct? Blargg did some test
 
347
   and found the constant to be OR with is $FF for NES */
 
348
case 0xAB: LD_IM(_A|=0xFF;AND;_X=_A);
 
349
 
 
350
/* AXS */ 
 
351
case 0xCB: LD_IM(AXS);
 
352
 
 
353
/* DCP */
 
354
case 0xC7: RMW_ZP(DEC;CMP);
 
355
case 0xD7: RMW_ZPX(DEC;CMP);
 
356
case 0xCF: RMW_AB(DEC;CMP);
 
357
case 0xDF: RMW_ABX(DEC;CMP);
 
358
case 0xDB: RMW_ABY(DEC;CMP);
 
359
case 0xC3: RMW_IX(DEC;CMP);
 
360
case 0xD3: RMW_IY(DEC;CMP);
 
361
 
 
362
/* ISB */
 
363
case 0xE7: RMW_ZP(INC;SBC);
 
364
case 0xF7: RMW_ZPX(INC;SBC);
 
365
case 0xEF: RMW_AB(INC;SBC);
 
366
case 0xFF: RMW_ABX(INC;SBC);
 
367
case 0xFB: RMW_ABY(INC;SBC);
 
368
case 0xE3: RMW_IX(INC;SBC);
 
369
case 0xF3: RMW_IY(INC;SBC);
 
370
 
 
371
/* DOP */
 
372
 
 
373
case 0x04: _PC++;break;
 
374
case 0x14: _PC++;break;
 
375
case 0x34: _PC++;break;
 
376
case 0x44: _PC++;break;
 
377
case 0x54: _PC++;break;
 
378
case 0x64: _PC++;break;
 
379
case 0x74: _PC++;break;
 
380
 
 
381
case 0x80: _PC++;break;
 
382
case 0x82: _PC++;break;
 
383
case 0x89: _PC++;break;
 
384
case 0xC2: _PC++;break;
 
385
case 0xD4: _PC++;break;
 
386
case 0xE2: _PC++;break;
 
387
case 0xF4: _PC++;break;
 
388
 
 
389
/* KIL */
 
390
 
 
391
case 0x02:
 
392
case 0x12:
 
393
case 0x22:
 
394
case 0x32:
 
395
case 0x42:
 
396
case 0x52:
 
397
case 0x62:
 
398
case 0x72:
 
399
case 0x92:
 
400
case 0xB2:
 
401
case 0xD2:
 
402
case 0xF2:ADDCYC(0xFF);
 
403
          _jammed=1;
 
404
          _PC--;
 
405
          break;
 
406
 
 
407
/* LAR */
 
408
case 0xBB: RMW_ABY(_S&=x;_A=_X=_S;X_ZN(_X));
 
409
 
 
410
/* LAX */
 
411
case 0xA7: LD_ZP(LDA;LDX);
 
412
case 0xB7: LD_ZPY(LDA;LDX);
 
413
case 0xAF: LD_AB(LDA;LDX);
 
414
case 0xBF: LD_ABY(LDA;LDX);
 
415
case 0xA3: LD_IX(LDA;LDX);
 
416
case 0xB3: LD_IY(LDA;LDX);
 
417
 
 
418
/* NOP */
 
419
case 0x1A:
 
420
case 0x3A:
 
421
case 0x5A:
 
422
case 0x7A:
 
423
case 0xDA:
 
424
case 0xFA: break;
 
425
 
 
426
/* RLA */
 
427
case 0x27: RMW_ZP(ROL;AND);
 
428
case 0x37: RMW_ZPX(ROL;AND);
 
429
case 0x2F: RMW_AB(ROL;AND);
 
430
case 0x3F: RMW_ABX(ROL;AND);
 
431
case 0x3B: RMW_ABY(ROL;AND);
 
432
case 0x23: RMW_IX(ROL;AND);
 
433
case 0x33: RMW_IY(ROL;AND);
 
434
 
 
435
/* RRA */
 
436
case 0x67: RMW_ZP(ROR;ADC);
 
437
case 0x77: RMW_ZPX(ROR;ADC);
 
438
case 0x6F: RMW_AB(ROR;ADC);
 
439
case 0x7F: RMW_ABX(ROR;ADC);
 
440
case 0x7B: RMW_ABY(ROR;ADC);
 
441
case 0x63: RMW_IX(ROR;ADC);
 
442
case 0x73: RMW_IY(ROR;ADC);
 
443
 
 
444
/* SLO */
 
445
case 0x07: RMW_ZP(ASL;ORA);
 
446
case 0x17: RMW_ZPX(ASL;ORA);
 
447
case 0x0F: RMW_AB(ASL;ORA);
 
448
case 0x1F: RMW_ABX(ASL;ORA);
 
449
case 0x1B: RMW_ABY(ASL;ORA);
 
450
case 0x03: RMW_IX(ASL;ORA);
 
451
case 0x13: RMW_IY(ASL;ORA);
 
452
 
 
453
/* SRE */
 
454
case 0x47: RMW_ZP(LSR;EOR);
 
455
case 0x57: RMW_ZPX(LSR;EOR);
 
456
case 0x4F: RMW_AB(LSR;EOR);
 
457
case 0x5F: RMW_ABX(LSR;EOR);
 
458
case 0x5B: RMW_ABY(LSR;EOR);
 
459
case 0x43: RMW_IX(LSR;EOR);
 
460
case 0x53: RMW_IY(LSR;EOR);
 
461
 
 
462
/* AXA - SHA */
 
463
case 0x93: ST_IY(_A&_X&(((A-_Y)>>8)+1));
 
464
case 0x9F: ST_ABY(_A&_X&(((A-_Y)>>8)+1));
 
465
 
 
466
/* SYA */
 
467
case 0x9C: ST_ABX(_Y&(((A-_X)>>8)+1));
 
468
 
 
469
/* SXA */
 
470
case 0x9E: ST_ABY(_X&(((A-_Y)>>8)+1));
 
471
 
 
472
/* XAS */
 
473
case 0x9B: _S=_A&_X;ST_ABY(_S& (((A-_Y)>>8)+1) );
 
474
 
 
475
/* TOP */
 
476
case 0x0C: LD_AB(;);
 
477
case 0x1C: 
 
478
case 0x3C: 
 
479
case 0x5C: 
 
480
case 0x7C: 
 
481
case 0xDC: 
 
482
case 0xFC: LD_ABX(;);
 
483
 
 
484
/* XAA - BIG QUESTION MARK HERE */
 
485
case 0x8B: _A|=0xEE; _A&=_X; LD_IM(AND);
 
486
//endif