00001
00016 #include "cpu.h"
00017
00018
00019 #define TRUE 1
00020 #define FALSE 0
00021
00022 #define PAGESIZE 8
00023
00026 #define FN 0x80
00027 #define FV 0x40
00028 #define FB 0x10
00029 #define FD 0x08
00030 #define FI 0x04
00031 #define FZ 0x02
00032 #define FC 0x01
00034
00035
00038 #define RESETVKT 0xFFFC
00039 #define IRQVKT 0xFFFE
00040 #define NMIVKT 0xFFFA
00041
00046 #define GETFLAG(X) \
00047 ((regs.P & (X))!=0)
00048
00049 #define SETFLAG(X) \
00050 regs.P=((regs.P) | (X))
00051
00052 #define CLFLAG(X) \
00053 (regs.P=regs.P & (~(X)))
00054
00055 #define FLAG(BL, FL) \
00056 if (BL) SETFLAG(FL); else CLFLAG(FL)
00057
00058 #define SETNZFLAGS(X) \
00059 FLAG((X) & 0x80, FN); FLAG(!(X), FZ)
00060
00065 #define ADR(X, Y) \
00066 (((Y) << PAGESIZE)+(X))
00067
00068 #define M2PC(X) \
00069 regs.PC=((*memgetb)((X) + 1) << PAGESIZE) + (*memgetb)(X)
00070
00071 #define HI(X) \
00072 ((unsigned char) (((X) >> PAGESIZE) & 0xFF))
00073
00074 #define LO(X) \
00075 ((unsigned char) ((X) & 0xFF))
00076
00077 #define PCSTEP(X) \
00078 regs.PC+=(X)
00079
00080 #define HEX2DEC(X) \
00081 ((((X)>>4) & 0x0F)*10 + ((X) & 0x0F))
00082
00083 #define DEC2HEX(X) \
00084 (((((X)/10) % 10)<<4) + (X) % 10)
00085
00091 #define STACKADD(X) \
00092 (*memsetb)(regs.S, (X)); regs.S--; if (regs.S<0x100) regs.S=0x1FF
00093
00094 #define STACKREMOVE(X) \
00095 regs.S++; if (regs.S>0x1FF) regs.S=0x100; X=(*memgetb)(regs.S)
00096
00103 #define CONSUME(X) \
00104 cycles += X
00105
00106 #define CONSREL \
00107 if ((oldpc & 0xFF00) != (regs.PC & 0xFF00)) CONSUME(1)
00108
00109 #define CONSABSX \
00110 if ((ADR((*memgetb)(regs.PC+1), (*memgetb)(regs.PC+2)) & 0xFF00) != \
00111 ((ADR((*memgetb)(regs.PC+1), (*memgetb)(regs.PC+2)) + regs.X) & 0xFF00)) \
00112 CONSUME(1)
00113
00114 #define CONSABSY \
00115 if ((ADR((*memgetb)(regs.PC+1), (*memgetb)(regs.PC+2)) & 0xFF00) != \
00116 ((ADR((*memgetb)(regs.PC+1), (*memgetb)(regs.PC+2)) + regs.Y) & 0xFF00)) \
00117 CONSUME(1)
00118
00119 #define CONSINDY \
00120 if ((ADR((*memgetb)((*memgetb)(regs.PC+1)), (*memgetb)((*memgetb)(regs.PC+1))+1) & 0xFF00) != \
00121 ((ADR((*memgetb)((*memgetb)(regs.PC+1)), (*memgetb)((*memgetb)(regs.PC+1))+1) + regs.Y) & 0xFF00)) \
00122 CONSUME(1)
00123
00128 #define IMM \
00129 regs.PC+1
00130
00131 #define ZP \
00132 (*memgetb)(regs.PC+1)&0xFF
00133
00134 #define ZPX \
00135 ((*memgetb)(regs.PC+1)+regs.X)&0xFF
00136
00137 #define ZPY \
00138 ((*memgetb)(regs.PC+1)+regs.Y)&0xFF
00139
00140 #define ABS \
00141 ADR((*memgetb)(regs.PC+1), (*memgetb)(regs.PC+2))
00142
00143 #define ABSX \
00144 ADR((*memgetb)(regs.PC+1), (*memgetb)(regs.PC+2))+regs.X
00145
00146 #define ABSY \
00147 ADR((*memgetb)(regs.PC+1), (*memgetb)(regs.PC+2))+regs.Y
00148
00149 #define INDX \
00150 ADR((*memgetb)(((*memgetb)(regs.PC+1)+regs.X) & 0xFF), (*memgetb)(((*memgetb)(regs.PC+1)+regs.X+1) & 0xFF))
00151
00152 #define INDY \
00153 ADR((*memgetb)((*memgetb)(regs.PC+1)), (*memgetb)(((*memgetb)(regs.PC+1)+1)) & 0xFF) + regs.Y
00154
00155 #define REL \
00156 regs.PC+1
00157
00158 #define JMPADR \
00159 ADR((*memgetb)(regs.PC+1), (*memgetb)(regs.PC+2))
00160
00169 #define ADC(MEMREAD, STEP) \
00170 if (regs.P & FD) { \
00171 tmp=HEX2DEC(regs.A)+HEX2DEC((*memgetb)(MEMREAD))+GETFLAG(FC); \
00172 if( tmp > 99 ) { \
00173 tmp=DEC2HEX(tmp); \
00174 SETFLAG(FC); \
00175 if ((tmp & 0x40)==(regs.A & 0x40)) SETFLAG(FV); \
00176 } \
00177 else { \
00178 tmp=DEC2HEX(tmp); \
00179 if (!(tmp & 0x40) && (regs.A & 0x40)) SETFLAG(FV); \
00180 } \
00181 regs.A=tmp; \
00182 } \
00183 else { \
00184 tmp=regs.A+(*memgetb)(MEMREAD)+GETFLAG(FC); \
00185 if(tmp<regs.A) { \
00186 SETFLAG(FC); \
00187 if ((tmp & 0x40)==(regs.A & 0x40)) SETFLAG(FV); \
00188 } \
00189 else { \
00190 if (!(tmp & 0x40) && (regs.A & 0x40)) SETFLAG(FV); \
00191 } \
00192 regs.A=tmp; \
00193 } \
00194 SETNZFLAGS(regs.A); \
00195 PCSTEP(STEP)
00196
00198 #define AND(MEMREAD, STEP) \
00199 regs.A=regs.A & (*memgetb)(MEMREAD); \
00200 SETNZFLAGS(regs.A); \
00201 PCSTEP(STEP)
00202
00204 #define ASL(MEMREAD, STEP) \
00205 tmp=(*memgetb)(MEMREAD); \
00206 FLAG(FC, tmp & 0x80); \
00207 tmp=(tmp << 1); \
00208 (*memsetb)(MEMREAD, tmp); \
00209 SETNZFLAGS(tmp); \
00210 PCSTEP(STEP)
00211
00213 #define ASLA \
00214 FLAG(FC, regs.A & 0x80); \
00215 regs.A=(regs.A << 1); \
00216 SETNZFLAGS(regs.A); \
00217 PCSTEP(1)
00218
00220 #define BCC(MEMREAD, STEP) \
00221 if (!GETFLAG(FC)) { \
00222 CONSUME(3); \
00223 tmp=(*memgetb)(MEMREAD); \
00224 if (tmp>0x7F) { \
00225 PCSTEP(STEP-0x100+tmp); \
00226 } \
00227 else { \
00228 PCSTEP(STEP+tmp); \
00229 } \
00230 } \
00231 else { \
00232 PCSTEP(STEP); \
00233 CONSUME(2); \
00234 }
00235
00237 #define BCS(MEMREAD, STEP) \
00238 if (GETFLAG(FC)) { \
00239 CONSUME(3); \
00240 tmp=(*memgetb)(MEMREAD); \
00241 if (tmp>0x7F) { \
00242 PCSTEP(STEP-0x100+tmp); \
00243 } \
00244 else { \
00245 PCSTEP(STEP+tmp); \
00246 } \
00247 } \
00248 else { \
00249 PCSTEP(STEP); \
00250 CONSUME(2); \
00251 }
00252
00254 #define BEQ(MEMREAD, STEP) \
00255 if (GETFLAG(FZ)) { \
00256 CONSUME(3); \
00257 tmp=(*memgetb)(MEMREAD); \
00258 if (tmp>0x7F) { \
00259 PCSTEP(STEP-0x100+tmp); \
00260 } \
00261 else { \
00262 PCSTEP(STEP+tmp); \
00263 } \
00264 } \
00265 else { \
00266 PCSTEP(STEP); \
00267 CONSUME(2); \
00268 }
00269
00271 #define BNE(MEMREAD, STEP) \
00272 if (!GETFLAG(FZ)) { \
00273 CONSUME(3); \
00274 tmp=(*memgetb)(MEMREAD); \
00275 if (tmp>0x7F) { \
00276 PCSTEP(STEP-0x100+tmp); \
00277 } \
00278 else { \
00279 PCSTEP(STEP+tmp); \
00280 } \
00281 } \
00282 else { \
00283 PCSTEP(STEP); \
00284 CONSUME(2); \
00285 }
00286
00288 #define BMI(MEMREAD, STEP) \
00289 if (GETFLAG(FN)) { \
00290 CONSUME(3); \
00291 tmp=(*memgetb)(MEMREAD); \
00292 if (tmp>0x7F) { \
00293 PCSTEP(STEP-0x100+tmp); \
00294 } \
00295 else { \
00296 PCSTEP(STEP+tmp); \
00297 } \
00298 } \
00299 else { \
00300 PCSTEP(STEP); \
00301 CONSUME(2); \
00302 }
00303
00305 #define BPL(MEMREAD, STEP) \
00306 if (!GETFLAG(FN)) { \
00307 CONSUME(3); \
00308 tmp=(*memgetb)(MEMREAD); \
00309 if (tmp>0x7F) { \
00310 PCSTEP(STEP-0x100+tmp); \
00311 } \
00312 else { \
00313 PCSTEP(STEP+tmp); \
00314 } \
00315 } \
00316 else { \
00317 PCSTEP(STEP); \
00318 CONSUME(2); \
00319 }
00320
00322 #define BVC(MEMREAD, STEP) \
00323 if (!GETFLAG(FV)) { \
00324 CONSUME(3); \
00325 tmp=(*memgetb)(MEMREAD); \
00326 if (tmp>0x7F) { \
00327 PCSTEP(STEP-0x100+tmp); \
00328 } \
00329 else { \
00330 PCSTEP(STEP+tmp); \
00331 } \
00332 } \
00333 else { \
00334 PCSTEP(STEP); \
00335 CONSUME(2); \
00336 }
00337
00339 #define BVS(MEMREAD, STEP) \
00340 if (GETFLAG(FC)) { \
00341 CONSUME(3); \
00342 tmp=(*memgetb)(MEMREAD); \
00343 if (tmp>0x7F) { \
00344 PCSTEP(STEP-0x100+tmp); \
00345 } \
00346 else { \
00347 PCSTEP(STEP+tmp); \
00348 } \
00349 } \
00350 else { \
00351 PCSTEP(STEP); \
00352 CONSUME(2); \
00353 }
00354
00356 #define BIT(MEMREAD, STEP) \
00357 tmp=(*memgetb)(MEMREAD); \
00358 FLAG(FN, tmp & 0x80); \
00359 FLAG(FV, tmp & 0x40); \
00360 tmp=tmp & regs.A; \
00361 FLAG(FZ, ~tmp); \
00362 PCSTEP(STEP)
00363
00367 #define BRK \
00368 PCSTEP(2); \
00369 SETFLAG(FB); \
00370 STACKADD(HI(regs.PC)); \
00371 STACKADD(LO(regs.PC)); \
00372 STACKADD(regs.P); \
00373 SETFLAG(FI); \
00374 CLFLAG(FD); \
00375 M2PC(IRQVKT)
00376
00378 #define CLC \
00379 CLFLAG(FC); \
00380 PCSTEP(1)
00381
00383 #define CLD \
00384 CLFLAG(FD); \
00385 PCSTEP(1)
00386
00388 #define CLI \
00389 CLFLAG(FI); \
00390 PCSTEP(1)
00391
00393 #define CLV \
00394 CLFLAG(FV); \
00395 PCSTEP(1)
00396
00398 #define CMP(MEMREAD, STEP) \
00399 tmp=(*memgetb)(MEMREAD); \
00400 if (regs.A<tmp) SETFLAG(FC); \
00401 SETNZFLAGS(regs.A-tmp); \
00402 PCSTEP(STEP)
00403
00405 #define CPX(MEMREAD, STEP) \
00406 tmp=(*memgetb)(MEMREAD); \
00407 if (regs.X<tmp) SETFLAG(FC); \
00408 SETNZFLAGS(regs.X-tmp); \
00409 PCSTEP(STEP)
00410
00412 #define CPY(MEMREAD, STEP) \
00413 tmp=(*memgetb)(MEMREAD); \
00414 if (regs.Y<tmp) SETFLAG(FC); \
00415 SETNZFLAGS(regs.Y-tmp); \
00416 PCSTEP(STEP)
00417
00419 #define DEC(MEMREAD, STEP) \
00420 tmp=(*memgetb)(MEMREAD); \
00421 tmp--; \
00422 SETNZFLAGS(tmp); \
00423 (*memsetb)(MEMREAD, tmp); \
00424 PCSTEP(STEP)
00425
00427 #define DEX \
00428 regs.X--; \
00429 SETNZFLAGS(regs.X); \
00430 PCSTEP(1)
00431
00433 #define DEY \
00434 regs.Y--; \
00435 SETNZFLAGS(regs.Y); \
00436 PCSTEP(1)
00437
00439 #define EOR(MEMREAD, STEP) \
00440 regs.A=regs.A ^ (*memgetb)(MEMREAD); \
00441 SETNZFLAGS(regs.A); \
00442 PCSTEP(STEP)
00443
00445 #define INC(MEMREAD, STEP) \
00446 tmp=(*memgetb)(MEMREAD); \
00447 tmp++; \
00448 SETNZFLAGS(tmp); \
00449 (*memsetb)(MEMREAD, tmp); \
00450 PCSTEP(STEP)
00451
00453 #define INX \
00454 regs.X++; \
00455 SETNZFLAGS(regs.X); \
00456 PCSTEP(1)
00457
00459 #define INY \
00460 regs.Y++; \
00461 SETNZFLAGS(regs.Y); \
00462 PCSTEP(1)
00463
00467 #define JMP(MEMREAD) \
00468 regs.PC=MEMREAD
00469
00473 #define JMPIND \
00474 regs.PC=ADR( \
00475 (*memgetb)(ADR((*memgetb)(regs.PC+1), (*memgetb)(regs.PC+2))), \
00476 (*memgetb)(ADR(((*memgetb)(regs.PC+1)+1) & 0xFF, (*memgetb)(regs.PC+2))))
00477
00481 #define JSR(MEMREAD) \
00482 tmpjsr=MEMREAD; \
00483 PCSTEP(2); \
00484 STACKADD(HI(regs.PC)); \
00485 STACKADD(LO(regs.PC)); \
00486 regs.PC=tmpjsr
00487
00489 #define LDA(MEMREAD, STEP) \
00490 regs.A=(*memgetb)(MEMREAD); \
00491 SETNZFLAGS(regs.A); \
00492 PCSTEP(STEP)
00493
00495 #define LDX(MEMREAD, STEP) \
00496 regs.X=(*memgetb)(MEMREAD); \
00497 SETNZFLAGS(regs.X); \
00498 PCSTEP(STEP)
00499
00501 #define LDY(MEMREAD, STEP) \
00502 regs.Y=(*memgetb)(MEMREAD); \
00503 SETNZFLAGS(regs.Y); \
00504 PCSTEP(STEP)
00505
00507 #define LSR(MEMREAD, STEP) \
00508 tmp=(*memgetb)(MEMREAD); \
00509 FLAG(FC, tmp & 0x01); \
00510 tmp=(tmp >> 1); \
00511 (*memsetb)(MEMREAD, tmp); \
00512 SETNZFLAGS(tmp); \
00513 PCSTEP(STEP)
00514
00516 #define LSRA \
00517 FLAG(FC, regs.A & 0x01); \
00518 regs.A=(regs.A >> 1); \
00519 SETNZFLAGS(regs.A); \
00520 PCSTEP(1)
00521
00523 #define NOP \
00524 PCSTEP(1)
00525
00527 #define ORA(MEMREAD, STEP) \
00528 regs.A=regs.A | (*memgetb)(MEMREAD); \
00529 SETNZFLAGS(regs.A); \
00530 PCSTEP(STEP)
00531
00533 #define PHA \
00534 STACKADD(regs.A); \
00535 PCSTEP(1)
00536
00538 #define PHP \
00539 STACKADD(regs.P); \
00540 PCSTEP(1)
00541
00543 #define PLA \
00544 STACKREMOVE(regs.A); \
00545 SETNZFLAGS(regs.A); \
00546 PCSTEP(1)
00547
00549 #define PLP \
00550 STACKREMOVE(regs.P); \
00551 regs.P=regs.P | 0x20; \
00552 PCSTEP(1)
00553
00555 #define ROL(MEMREAD, STEP) \
00556 tmp=(*memgetb)(MEMREAD); \
00557 tmpc=GETFLAG(FC); \
00558 FLAG(FC, tmp & 0x80); \
00559 tmp=(tmp << 1) | ((tmpc) ? 0x01 : 0x00); \
00560 (*memsetb)(MEMREAD, tmp); \
00561 PCSTEP(STEP)
00562
00564 #define ROLA \
00565 tmpc=GETFLAG(FC); \
00566 FLAG(FC, regs.A & 0x80); \
00567 regs.A=(regs.A << 1) | ((tmpc) ? 0x01 : 0x00); \
00568 PCSTEP(1)
00569
00571 #define ROR(MEMREAD, STEP) \
00572 tmp=(*memgetb)(MEMREAD); \
00573 tmpc=GETFLAG(FC); \
00574 FLAG(FC, tmp & 0x01); \
00575 tmp=(tmp >> 1) | ((tmpc) ? 0x80 : 0x00); \
00576 (*memsetb)(MEMREAD, tmp); \
00577 PCSTEP(STEP)
00578
00580 #define RORA \
00581 tmpc=GETFLAG(FC); \
00582 FLAG(FC, regs.A & 0x01); \
00583 regs.A=(regs.A >> 1) | ((tmpc) ? 0x80 : 0x00); \
00584 PCSTEP(1)
00585
00587 #define RTI \
00588 STACKREMOVE(regs.P); \
00589 STACKREMOVE(tmp); \
00590 STACKREMOVE(regs.PC); \
00591 regs.PC=(regs.PC << 8) + tmp
00592
00594 #define RTS \
00595 STACKREMOVE(tmp); \
00596 STACKREMOVE(regs.PC); \
00597 regs.PC=(regs.PC << 8) + tmp + 1
00598
00600 #define SBC(MEMREAD, STEP) \
00601 if (regs.P & FD) { \
00602 tmp=HEX2DEC(regs.A)-HEX2DEC((*memgetb)(MEMREAD))- (1-GETFLAG(FC)); \
00603 if(tmp<=99) { \
00604 tmp=DEC2HEX(tmp); \
00605 SETFLAG(FC); \
00606 if ((tmp & 0x40) && !(regs.A & 0x40)) SETFLAG(FV); \
00607 } \
00608 else { \
00609 tmp=tmp-156; \
00610 tmp=DEC2HEX(tmp); \
00611 if ((tmp & 0x40)==(regs.A & 0x40)) SETFLAG(FV); \
00612 } \
00613 regs.A=tmp; \
00614 } \
00615 else { \
00616 tmp=regs.A-(*memgetb)(MEMREAD)-(1-GETFLAG(FC)); \
00617 if(tmp<=regs.A) { \
00618 SETFLAG(FC); \
00619 if ((tmp & 0x40) && !(regs.A & 0x40)) SETFLAG(FV); \
00620 } \
00621 else { \
00622 if ((tmp & 0x40)==(regs.A & 0x40)) SETFLAG(FV); \
00623 } \
00624 regs.A=tmp; \
00625 } \
00626 SETNZFLAGS(regs.A); \
00627 PCSTEP(STEP)
00628
00630 #define SEC \
00631 SETFLAG(FC); \
00632 PCSTEP(1)
00633
00635 #define SED \
00636 SETFLAG(FD); \
00637 PCSTEP(1)
00638
00640 #define SEI \
00641 SETFLAG(FI); \
00642 PCSTEP(1)
00643
00645 #define STA(MEMREAD, STEP) \
00646 (*memsetb)(MEMREAD, regs.A); \
00647 PCSTEP(STEP)
00648
00650 #define STX(MEMREAD, STEP) \
00651 (*memsetb)(MEMREAD, regs.X); \
00652 PCSTEP(STEP)
00653
00655 #define STY(MEMREAD, STEP) \
00656 (*memsetb)(MEMREAD, regs.Y); \
00657 PCSTEP(STEP)
00658
00660 #define TAX \
00661 regs.X=regs.A; \
00662 SETNZFLAGS(regs.X); \
00663 PCSTEP(1)
00664
00666 #define TXA \
00667 regs.A=regs.X; \
00668 SETNZFLAGS(regs.A); \
00669 PCSTEP(1)
00670
00672 #define TAY \
00673 regs.Y=regs.A; \
00674 SETNZFLAGS(regs.Y); \
00675 PCSTEP(1)
00676
00678 #define TYA \
00679 regs.A=regs.Y; \
00680 SETNZFLAGS(regs.A); \
00681 PCSTEP(1)
00682
00684 #define TSX \
00685 regs.X=regs.S; \
00686 SETNZFLAGS(regs.X); \
00687 PCSTEP(1)
00688
00690 #define TXS \
00691 regs.S=regs.X; \
00692 PCSTEP(1)
00693
00696 Regs regs;
00697
00706 UINT InstrStep()
00707 {
00708 unsigned char tmp, tmpc;
00709 UINT tmpjsr;
00710 UINT oldpc = regs.PC;
00711 UINT cycles = 0;
00712 switch((*memgetb)(regs.PC)) {
00713 case 0:
00714 BRK;
00715 CONSUME(7);
00716 break;
00717 case 1:
00718 ORA(INDX, 2);
00719 CONSUME(6);
00720 break;
00721 case 5:
00722 ORA(ZP, 2);
00723 CONSUME(3);
00724 break;
00725 case 6:
00726 ASL(ZP, 2);
00727 CONSUME(5);
00728 break;
00729 case 8:
00730 PHP;
00731 CONSUME(3);
00732 break;
00733 case 9:
00734 ORA(IMM, 2);
00735 CONSUME(2);
00736 break;
00737 case 10:
00738 ASLA;
00739 CONSUME(2);
00740 break;
00741 case 13:
00742 ORA(ABS, 3);
00743 CONSUME(4);
00744 break;
00745 case 14:
00746 ASL(ABS, 3);
00747 CONSUME(6);
00748 break;
00749 case 16:
00750 BPL(IMM, 2);
00751 CONSREL;
00752 break;
00753 case 17:
00754 CONSINDY;
00755 ORA(INDY, 2);
00756 CONSUME(4);
00757 break;
00758 case 21:
00759 ORA(ZPX, 2);
00760 CONSUME(4);
00761 break;
00762 case 22:
00763 ASL(ZPX, 2);
00764 CONSUME(6);
00765 break;
00766 case 24:
00767 CLC;
00768 CONSUME(2);
00769 break;
00770 case 25:
00771 CONSABSY;
00772 ORA(ABSY, 3);
00773 CONSUME(4);
00774 break;
00775 case 29:
00776 CONSABSX;
00777 ORA(ABSX, 3);
00778 CONSUME(4);
00779 break;
00780 case 30:
00781 ASL(ABSX, 3);
00782 CONSUME(7);
00783 break;
00784 case 32:
00785 JSR(JMPADR);
00786 CONSUME(6);
00787 break;
00788 case 33:
00789 AND(INDX, 2);
00790 CONSUME(6);
00791 break;
00792 case 36:
00793 BIT(ZP, 2);
00794 CONSUME(3);
00795 break;
00796 case 37:
00797 AND(ZP, 2);
00798 CONSUME(3);
00799 break;
00800 case 38:
00801 ROL(ZP, 2);
00802 CONSUME(5);
00803 break;
00804 case 40:
00805 PLP;
00806 CONSUME(4);
00807 break;
00808 case 41:
00809 AND(IMM, 2);
00810 CONSUME(2);
00811 break;
00812 case 42:
00813 ROLA;
00814 CONSUME(2);
00815 break;
00816 case 44:
00817 BIT(ABS, 3);
00818 CONSUME(4);
00819 break;
00820 case 45:
00821 AND(ABS, 3);
00822 CONSUME(4);
00823 break;
00824 case 46:
00825 ROL(ABS, 3);
00826 CONSUME(6);
00827 break;
00828 case 48:
00829 BMI(IMM, 2);
00830 CONSREL;
00831 break;
00832 case 49:
00833 CONSINDY;
00834 AND(INDY, 2);
00835 CONSUME(5);
00836 break;
00837 case 53:
00838 AND(ZPX, 2);
00839 CONSUME(4);
00840 break;
00841 case 54:
00842 ROL(ZPX, 2);
00843 CONSUME(6);
00844 break;
00845 case 56:
00846 SEC;
00847 CONSUME(2);
00848 break;
00849 case 57:
00850 CONSABSY;
00851 AND(ABSY, 3);
00852 CONSUME(4);
00853 break;
00854 case 61:
00855 CONSABSX;
00856 AND(ABSX, 3);
00857 CONSUME(4);
00858 break;
00859 case 62:
00860 ROL(ABSX, 3);
00861 CONSUME(7);
00862 break;
00863 case 64:
00864 RTI;
00865 CONSUME(6);
00866 break;
00867 case 65:
00868 EOR(INDX, 2);
00869 CONSUME(6);
00870 break;
00871 case 69:
00872 EOR(ZP, 2);
00873 CONSUME(3);
00874 break;
00875 case 70:
00876 LSR(ZP, 2);
00877 CONSUME(5);
00878 break;
00879 case 72:
00880 PHA;
00881 CONSUME(3);
00882 break;
00883 case 73:
00884 EOR(IMM, 2);
00885 CONSUME(2);
00886 break;
00887 case 74:
00888 LSRA;
00889 CONSUME(2);
00890 break;
00891 case 76:
00892 JMP(JMPADR);
00893 CONSUME(3);
00894 break;
00895 case 77:
00896 EOR(ABS, 3);
00897 CONSUME(4);
00898 break;
00899 case 78:
00900 LSR(ABS, 3);
00901 CONSUME(6);
00902 break;
00903 case 80:
00904 BVC(IMM, 2);
00905 CONSREL;
00906 break;
00907 case 81:
00908 CONSINDY;
00909 EOR(INDY, 2);
00910 CONSUME(5);
00911 break;
00912 case 85:
00913 EOR(ZPX, 2);
00914 CONSUME(4);
00915 break;
00916 case 86:
00917 LSR(ZPX, 2);
00918 CONSUME(6);
00919 break;
00920 case 88:
00921 CLI;
00922 CONSUME(2);
00923 break;
00924 case 89:
00925 CONSABSY;
00926 EOR(ABSY, 3);
00927 CONSUME(4);
00928 break;
00929 case 93:
00930 CONSABSX;
00931 EOR(ABSX, 3);
00932 CONSUME(4);
00933 break;
00934 case 94:
00935 LSR(ABSX, 3);
00936 CONSUME(7);
00937 break;
00938 case 96:
00939 RTS;
00940 CONSUME(6);
00941 break;
00942 case 97:
00943 ADC(INDX, 2);
00944 CONSUME(6);
00945 break;
00946 case 101:
00947 ADC(ZP, 2);
00948 CONSUME(3);
00949 break;
00950 case 102:
00951 ROR(ZP, 2);
00952 CONSUME(5);
00953 break;
00954 case 104:
00955 PLA;
00956 CONSUME(4);
00957 break;
00958 case 105:
00959 ADC(IMM, 2);
00960 CONSUME(2);
00961 break;
00962 case 106:
00963 RORA;
00964 CONSUME(2);
00965 break;
00966 case 108:
00967 JMPIND;
00968 CONSUME(5);
00969 break;
00970 case 109:
00971 ADC(ABS, 3);
00972 CONSUME(4);
00973 break;
00974 case 110:
00975 ROR(ABS, 3);
00976 CONSUME(2);
00977 break;
00978 case 112:
00979 BVS(IMM, 2);
00980 CONSREL;
00981 break;
00982 case 113:
00983 CONSINDY;
00984 ADC(INDY, 2);
00985 CONSUME(4);
00986 break;
00987 case 117:
00988 ADC(ZPX, 2);
00989 CONSUME(4);
00990 break;
00991 case 118:
00992 ROR(ZPX, 2);
00993 CONSUME(6);
00994 break;
00995 case 120:
00996 SEI;
00997 CONSUME(2);
00998 break;
00999 case 121:
01000 CONSABSY;
01001 ADC(ABSY, 3);
01002 CONSUME(4);
01003 break;
01004 case 125:
01005 CONSABSX;
01006 ADC(ABSX, 3);
01007 CONSUME(4);
01008 break;
01009 case 126:
01010 ROR(ABSX, 3);
01011 CONSUME(7);
01012 break;
01013 case 129:
01014 STA(INDX, 2);
01015 CONSUME(6);
01016 break;
01017 case 132:
01018 STY(ZP, 2);
01019 CONSUME(3);
01020 break;
01021 case 133:
01022 STA(ZP, 2);
01023 CONSUME(3);
01024 break;
01025 case 134:
01026 STX(ZP, 2);
01027 CONSUME(3);
01028 break;
01029 case 136:
01030 DEY;
01031 CONSUME(2);
01032 break;
01033 case 138:
01034 TXA;
01035 CONSUME(2);
01036 break;
01037 case 140:
01038 STY(ABS, 3);
01039 CONSUME(4);
01040 break;
01041 case 141:
01042 STA(ABS, 3);
01043 CONSUME(4);
01044 break;
01045 case 142:
01046 STX(ABS, 3);
01047 CONSUME(4);
01048 break;
01049 case 144:
01050 BCC(IMM, 2);
01051 CONSREL;
01052 break;
01053 case 145:
01054 STA(INDY, 2);
01055 CONSUME(6);
01056 break;
01057 case 148:
01058 STY(ZPX, 2);
01059 CONSUME(4);
01060 break;
01061 case 149:
01062 STA(ZPX, 2);
01063 CONSUME(4);
01064 break;
01065 case 150:
01066 STX(ZPX, 2);
01067 CONSUME(4);
01068 break;
01069 case 152:
01070 TYA;
01071 CONSUME(2);
01072 break;
01073 case 153:
01074 STA(ABSY, 3);
01075 CONSUME(5);
01076 break;
01077 case 154:
01078 TXS;
01079 CONSUME(2);
01080 break;
01081 case 157:
01082 STA(ABSX, 3);
01083 CONSUME(5);
01084 break;
01085 case 160:
01086 LDY(IMM, 2);
01087 CONSUME(2);
01088 break;
01089 case 161:
01090 LDA(INDX, 2);
01091 CONSUME(6);
01092 break;
01093 case 162:
01094 LDX(IMM, 2);
01095 CONSUME(2);
01096 break;
01097 case 164:
01098 LDY(ZP, 2);
01099 CONSUME(3);
01100 break;
01101 case 165:
01102 LDA(ZP, 2);
01103 CONSUME(3);
01104 break;
01105 case 166:
01106 LDX(ZP, 2);
01107 CONSUME(3);
01108 break;
01109 case 168:
01110 TAY;
01111 CONSUME(2);
01112 break;
01113 case 169:
01114 LDA(IMM, 2);
01115 CONSUME(2);
01116 break;
01117 case 170:
01118 TAX;
01119 CONSUME(2);
01120 break;
01121 case 172:
01122 LDY(ABS, 3);
01123 CONSUME(4);
01124 break;
01125 case 173:
01126 LDA(ABS, 3);
01127 CONSUME(4);
01128 break;
01129 case 174:
01130 LDX(ABS, 3);
01131 CONSUME(4);
01132 break;
01133 case 175:
01134 BCS(IMM, 2);
01135 CONSREL;
01136 break;
01137 case 177:
01138 CONSINDY;
01139 LDA(INDY, 2);
01140 CONSUME(5);
01141 break;
01142 case 180:
01143 LDY(ZPX, 2);
01144 CONSUME(4);
01145 break;
01146 case 181:
01147 LDA(ZPX, 2);
01148 CONSUME(4);
01149 break;
01150 case 182:
01151 LDX(ZPY, 2);
01152 CONSUME(4);
01153 break;
01154 case 184:
01155 CLV;
01156 CONSUME(2);
01157 break;
01158 case 185:
01159 CONSABSY;
01160 LDA(ABSY, 3);
01161 CONSUME(4);
01162 break;
01163 case 186:
01164 TSX;
01165 CONSUME(2);
01166 break;
01167 case 188:
01168 CONSABSY;
01169 LDY(ABSX, 3);
01170 CONSUME(4);
01171 break;
01172 case 189:
01173 CONSABSX;
01174 LDA(ABSX, 3);
01175 CONSUME(4);
01176 break;
01177 case 190:
01178 CONSABSY;
01179 LDX(ABSY, 3);
01180 CONSUME(4);
01181 break;
01182 case 192:
01183 CPY(IMM, 2);
01184 CONSUME(2);
01185 break;
01186 case 193:
01187 CMP(INDX, 2);
01188 CONSUME(6);
01189 break;
01190 case 196:
01191 CPY(ZP, 2);
01192 CONSUME(3);
01193 break;
01194 case 197:
01195 CMP(ZP, 2);
01196 CONSUME(3);
01197 break;
01198 case 198:
01199 DEC(ZP, 2);
01200 CONSUME(5);
01201 break;
01202 case 200:
01203 INY;
01204 CONSUME(2);
01205 break;
01206 case 201:
01207 CMP(IMM, 2);
01208 CONSUME(2);
01209 break;
01210 case 202:
01211 DEX;
01212 CONSUME(2);
01213 break;
01214 case 204:
01215 CPY(ABS, 3);
01216 CONSUME(4);
01217 break;
01218 case 205:
01219 CMP(ABS, 3);
01220 CONSUME(4);
01221 break;
01222 case 206:
01223 DEC(ABS, 3);
01224 CONSUME(6);
01225 break;
01226 case 208:
01227 BNE(IMM, 2);
01228 CONSREL;
01229 break;
01230 case 209:
01231 CONSINDY;
01232 CMP(INDY, 2);
01233 CONSUME(5);
01234 break;
01235 case 213:
01236 CMP(ZPX, 2);
01237 CONSUME(4);
01238 break;
01239 case 214:
01240 DEC(ZPX, 2);
01241 CONSUME(6);
01242 break;
01243 case 216:
01244 CLD;
01245 CONSUME(2);
01246 break;
01247 case 217:
01248 CONSABSY;
01249 CMP(ABSY, 3);
01250 CONSUME(4);
01251 break;
01252 case 221:
01253 CONSABSX;
01254 CMP(ABSX, 3);
01255 CONSUME(4);
01256 break;
01257 case 222:
01258 DEC(ABSX, 3);
01259 CONSUME(7);
01260 break;
01261 case 224:
01262 CPX(IMM, 2);
01263 CONSUME(2);
01264 break;
01265 case 225:
01266 SBC(INDX, 2);
01267 CONSUME(6);
01268 break;
01269 case 228:
01270 CPX(ZP, 2);
01271 CONSUME(3);
01272 break;
01273 case 229:
01274 SBC(ZP, 2);
01275 CONSUME(3);
01276 break;
01277 case 230:
01278 INC(ZP, 2);
01279 CONSUME(5);
01280 break;
01281 case 232:
01282 INX;
01283 CONSUME(2);
01284 break;
01285 case 233:
01286 SBC(IMM, 2);
01287 CONSUME(2);
01288 break;
01289 case 234:
01290 NOP;
01291 CONSUME(2);
01292 break;
01293 case 236:
01294 CPX(ABS, 3);
01295 CONSUME(4);
01296 break;
01297 case 237:
01298 SBC(ABS, 3);
01299 CONSUME(4);
01300 break;
01301 case 238:
01302 INC(ABS, 3);
01303 CONSUME(6);
01304 break;
01305 case 240:
01306 BEQ(IMM, 2);
01307 CONSREL;
01308 break;
01309 case 241:
01310 CONSINDY;
01311 SBC(INDY, 2);
01312 CONSUME(5);
01313 break;
01314 case 245:
01315 SBC(ZPX, 2);
01316 CONSUME(4);
01317 break;
01318 case 248:
01319 SED;
01320 CONSUME(2);
01321 break;
01322 case 249:
01323 CONSABSY;
01324 SBC(ABSY, 3);
01325 CONSUME(4);
01326 break;
01327 case 253:
01328 CONSABSX;
01329 SBC(ABSX, 3);
01330 CONSUME(4);
01331 break;
01332 case 254:
01333 INC(ABSX, 3);
01334 CONSUME(7);
01335 break;
01336 default:
01337 PCSTEP(1);
01338 CONSUME(2);
01339 }
01340 regs.PC = regs.PC & 0xFFFF;
01341 return cycles;
01342 }
01343
01344 Regs* GetRegs()
01345 {
01346 return ®s;
01347 }
01348
01349 void SetRegs(Regs r)
01350 {
01351 regs = r;
01352 }
01353
01362 void Reset()
01363 {
01364 regs.A=0;
01365 regs.X=0;
01366 regs.Y=0;
01367 regs.P=0x20 | FI;
01368 regs.S=0x1FF;
01369 M2PC(RESETVKT);
01370 }
01371
01379 void Irq()
01380 {
01381 if (regs.P & FI != 0) {
01382 return;
01383 }
01384 STACKADD(HI(regs.PC));
01385 STACKADD(LO(regs.PC));
01386 STACKADD(regs.P);
01387 SETFLAG(FI);
01388 M2PC(IRQVKT);
01389 }
01390
01398 void Nmi()
01399 {
01400 STACKADD(HI(regs.PC));
01401 STACKADD(LO(regs.PC));
01402 STACKADD(regs.P);
01403 SETFLAG(FI);
01404 M2PC(NMIVKT);
01405 }
