00001
00002
00003
00004
00005
00006
00007
00008
00009
00010
00011
00012
00013
00014
00015 #if PC_IS_POINTER
00016 #define read_byte_imm() (*pc++)
00017 #else
00018 #define read_byte_imm() read_byte(pc++)
00019 #endif
00020
00021
00022 #define read_adr_zero() ((uint16)read_byte_imm())
00023
00024
00025 #define read_adr_zero_x() ((read_byte_imm() + x) & 0xff)
00026
00027
00028 #define read_adr_zero_y() ((read_byte_imm() + y) & 0xff)
00029
00030
00031 #if PC_IS_POINTER
00032 #if LITTLE_ENDIAN_UNALIGNED
00033 #define read_adr_abs() (adr = *(UWORD *)pc, pc+=2, adr)
00034 #else
00035 #define read_adr_abs() (adr = ((*(pc+1)) << 8) | *pc, pc+=2, adr)
00036 #endif
00037 #else
00038 #define read_adr_abs() (adr = read_word(pc), pc+=2, adr)
00039 #endif
00040
00041
00042 #define read_adr_abs_x() (read_adr_abs() + x)
00043
00044
00045 #define read_adr_abs_y() (read_adr_abs() + y)
00046
00047
00048 #define read_adr_ind_x() (read_zp_word(read_byte_imm() + x))
00049
00050
00051 #define read_adr_ind_y() (read_zp_word(read_byte_imm()) + y)
00052
00053
00054 #define read_byte_zero() read_zp(read_adr_zero())
00055
00056
00057 #define read_byte_zero_x() read_zp(read_adr_zero_x())
00058
00059
00060 #define read_byte_zero_y() read_zp(read_adr_zero_y())
00061
00062
00063 #define read_byte_abs() read_byte(read_adr_abs())
00064
00065 #if PRECISE_CPU_CYCLES
00066
00067 #define page_plus(exp, reg) \
00068 (adr = exp, page_cycles = (adr & 0xff) + reg >= 0x100, adr + reg)
00069
00070
00071 #define read_byte_abs_x() read_byte(page_plus(read_adr_abs(), x))
00072
00073
00074 #define read_byte_abs_y() read_byte(page_plus(read_adr_abs(), y))
00075
00076
00077 #define read_byte_ind_y() read_byte(page_plus(read_zp_word(read_byte_imm()), y))
00078
00079 #else
00080
00081
00082 #define read_byte_abs_x() read_byte(read_adr_abs_x())
00083
00084
00085 #define read_byte_abs_y() read_byte(read_adr_abs_y())
00086
00087
00088 #define read_byte_ind_y() read_byte(read_adr_ind_y())
00089 #endif
00090
00091
00092 #define read_byte_ind_x() read_byte(read_adr_ind_x())
00093
00094
00095
00096
00097
00098
00099 #define set_nz(x) (z_flag = n_flag = (uint8)(x)) //AEH 991113
00100
00101
00102
00103
00104
00105
00106 #define ENDOP(cyc) last_cycles = cyc; break;
00107
00108
00109
00110 #if PRECISE_CPU_CYCLES
00111 if (cycles_left != 1)
00112 cycles_left -= borrowed_cycles;
00113 int page_cycles = 0;
00114 for (;;) {
00115 if (last_cycles) {
00116 last_cycles += page_cycles;
00117 page_cycles = 0;
00118 #if PRECISE_CIA_CYCLES && !defined(IS_CPU_1541)
00119 TheCIA1->EmulateLine(last_cycles);
00120 TheCIA2->EmulateLine(last_cycles);
00121 #endif
00122 }
00123 if ((cycles_left -= last_cycles) < 0) {
00124 borrowed_cycles = -cycles_left;
00125 break;
00126 }
00127 #else
00128 while ((cycles_left -= last_cycles) >= 0) {
00129 #endif
00130
00131 switch (read_byte_imm()) {
00132
00133
00134
00135 case 0xa9:
00136 set_nz(a = read_byte_imm());
00137 ENDOP(2);
00138
00139 case 0xa5:
00140 set_nz(a = read_byte_zero());
00141 ENDOP(3);
00142
00143 case 0xb5:
00144 set_nz(a = read_byte_zero_x());
00145 ENDOP(4);
00146
00147 case 0xad:
00148 set_nz(a = read_byte_abs());
00149 ENDOP(4);
00150
00151 case 0xbd:
00152 set_nz(a = read_byte_abs_x());
00153 ENDOP(4);
00154
00155 case 0xb9:
00156 set_nz(a = read_byte_abs_y());
00157 ENDOP(4);
00158
00159 case 0xa1:
00160 set_nz(a = read_byte_ind_x());
00161 ENDOP(6);
00162
00163 case 0xb1:
00164 set_nz(a = read_byte_ind_y());
00165 ENDOP(5);
00166
00167 case 0xa2:
00168 set_nz(x = read_byte_imm());
00169 ENDOP(2);
00170
00171 case 0xa6:
00172 set_nz(x = read_byte_zero());
00173 ENDOP(3);
00174
00175 case 0xb6:
00176 set_nz(x = read_byte_zero_y());
00177 ENDOP(4);
00178
00179 case 0xae:
00180 set_nz(x = read_byte_abs());
00181 ENDOP(4);
00182
00183 case 0xbe:
00184 set_nz(x = read_byte_abs_y());
00185 ENDOP(4);
00186
00187 case 0xa0:
00188 set_nz(y = read_byte_imm());
00189 ENDOP(2);
00190
00191 case 0xa4:
00192 set_nz(y = read_byte_zero());
00193 ENDOP(3);
00194
00195 case 0xb4:
00196 set_nz(y = read_byte_zero_x());
00197 ENDOP(4);
00198
00199 case 0xac:
00200 set_nz(y = read_byte_abs());
00201 ENDOP(4);
00202
00203 case 0xbc:
00204 set_nz(y = read_byte_abs_x());
00205 ENDOP(4);
00206
00207
00208
00209 case 0x85:
00210 write_byte(read_adr_zero(), a);
00211 ENDOP(3);
00212
00213 case 0x95:
00214 write_byte(read_adr_zero_x(), a);
00215 ENDOP(4);
00216
00217 case 0x8d:
00218 write_byte(read_adr_abs(), a);
00219 ENDOP(4);
00220
00221 case 0x9d:
00222 write_byte(read_adr_abs_x(), a);
00223 ENDOP(5);
00224
00225 case 0x99:
00226 write_byte(read_adr_abs_y(), a);
00227 ENDOP(5);
00228
00229 case 0x81:
00230 write_byte(read_adr_ind_x(), a);
00231 ENDOP(6);
00232
00233 case 0x91:
00234 write_byte(read_adr_ind_y(), a);
00235 ENDOP(6);
00236
00237 case 0x86:
00238 write_byte(read_adr_zero(), x);
00239 ENDOP(3);
00240
00241 case 0x96:
00242 write_byte(read_adr_zero_y(), x);
00243 ENDOP(4);
00244
00245 case 0x8e:
00246 write_byte(read_adr_abs(), x);
00247 ENDOP(4);
00248
00249 case 0x84:
00250 write_byte(read_adr_zero(), y);
00251 ENDOP(3);
00252
00253 case 0x94:
00254 write_byte(read_adr_zero_x(), y);
00255 ENDOP(4);
00256
00257 case 0x8c:
00258 write_byte(read_adr_abs(), y);
00259 ENDOP(4);
00260
00261
00262
00263 case 0xaa:
00264 set_nz(x = a);
00265 ENDOP(2);
00266
00267 case 0x8a:
00268 set_nz(a = x);
00269 ENDOP(2);
00270
00271 case 0xa8:
00272 set_nz(y = a);
00273 ENDOP(2);
00274
00275 case 0x98:
00276 set_nz(a = y);
00277 ENDOP(2);
00278
00279 case 0xba:
00280 set_nz(x = sp);
00281 ENDOP(2);
00282
00283 case 0x9a:
00284 sp = x;
00285 ENDOP(2);
00286
00287
00288
00289 case 0x69:
00290 do_adc(read_byte_imm());
00291 ENDOP(2);
00292
00293 case 0x65:
00294 do_adc(read_byte_zero());
00295 ENDOP(3);
00296
00297 case 0x75:
00298 do_adc(read_byte_zero_x());
00299 ENDOP(4);
00300
00301 case 0x6d:
00302 do_adc(read_byte_abs());
00303 ENDOP(4);
00304
00305 case 0x7d:
00306 do_adc(read_byte_abs_x());
00307 ENDOP(4);
00308
00309 case 0x79:
00310 do_adc(read_byte_abs_y());
00311 ENDOP(4);
00312
00313 case 0x61:
00314 do_adc(read_byte_ind_x());
00315 ENDOP(6);
00316
00317 case 0x71:
00318 do_adc(read_byte_ind_y());
00319 ENDOP(5);
00320
00321 case 0xe9:
00322 case 0xeb:
00323 do_sbc(read_byte_imm());
00324 ENDOP(2);
00325
00326 case 0xe5:
00327 do_sbc(read_byte_zero());
00328 ENDOP(3);
00329
00330 case 0xf5:
00331 do_sbc(read_byte_zero_x());
00332 ENDOP(4);
00333
00334 case 0xed:
00335 do_sbc(read_byte_abs());
00336 ENDOP(4);
00337
00338 case 0xfd:
00339 do_sbc(read_byte_abs_x());
00340 ENDOP(4);
00341
00342 case 0xf9:
00343 do_sbc(read_byte_abs_y());
00344 ENDOP(4);
00345
00346 case 0xe1:
00347 do_sbc(read_byte_ind_x());
00348 ENDOP(6);
00349
00350 case 0xf1:
00351 do_sbc(read_byte_ind_y());
00352 ENDOP(5);
00353
00354
00355
00356 case 0xe8:
00357 set_nz(++x);
00358 ENDOP(2);
00359
00360 case 0xca:
00361 set_nz(--x);
00362 ENDOP(2);
00363
00364 case 0xc8:
00365 set_nz(++y);
00366 ENDOP(2);
00367
00368 case 0x88:
00369 set_nz(--y);
00370 ENDOP(2);
00371
00372 case 0xe6:
00373 adr = read_adr_zero();
00374 write_zp(adr, set_nz(read_zp(adr) + 1));
00375 ENDOP(5);
00376
00377 case 0xf6:
00378 adr = read_adr_zero_x();
00379 write_zp(adr, set_nz(read_zp(adr) + 1));
00380 ENDOP(6);
00381
00382 case 0xee:
00383 adr = read_adr_abs();
00384 write_byte(adr, set_nz(read_byte(adr) + 1));
00385 ENDOP(6);
00386
00387 case 0xfe:
00388 adr = read_adr_abs_x();
00389 write_byte(adr, set_nz(read_byte(adr) + 1));
00390 ENDOP(7);
00391
00392 case 0xc6:
00393 adr = read_adr_zero();
00394 write_zp(adr, set_nz(read_zp(adr) - 1));
00395 ENDOP(5);
00396
00397 case 0xd6:
00398 adr = read_adr_zero_x();
00399 write_zp(adr, set_nz(read_zp(adr) - 1));
00400 ENDOP(6);
00401
00402 case 0xce:
00403 adr = read_adr_abs();
00404 write_byte(adr, set_nz(read_byte(adr) - 1));
00405 ENDOP(6);
00406
00407 case 0xde:
00408 adr = read_adr_abs_x();
00409 write_byte(adr, set_nz(read_byte(adr) - 1));
00410 ENDOP(7);
00411
00412
00413
00414 case 0x29:
00415 set_nz(a &= read_byte_imm());
00416 ENDOP(2);
00417
00418 case 0x25:
00419 set_nz(a &= read_byte_zero());
00420 ENDOP(3);
00421
00422 case 0x35:
00423 set_nz(a &= read_byte_zero_x());
00424 ENDOP(4);
00425
00426 case 0x2d:
00427 set_nz(a &= read_byte_abs());
00428 ENDOP(4);
00429
00430 case 0x3d:
00431 set_nz(a &= read_byte_abs_x());
00432 ENDOP(4);
00433
00434 case 0x39:
00435 set_nz(a &= read_byte_abs_y());
00436 ENDOP(4);
00437
00438 case 0x21:
00439 set_nz(a &= read_byte_ind_x());
00440 ENDOP(6);
00441
00442 case 0x31:
00443 set_nz(a &= read_byte_ind_y());
00444 ENDOP(5);
00445
00446 case 0x09:
00447 set_nz(a |= read_byte_imm());
00448 ENDOP(2);
00449
00450 case 0x05:
00451 set_nz(a |= read_byte_zero());
00452 ENDOP(3);
00453
00454 case 0x15:
00455 set_nz(a |= read_byte_zero_x());
00456 ENDOP(4);
00457
00458 case 0x0d:
00459 set_nz(a |= read_byte_abs());
00460 ENDOP(4);
00461
00462 case 0x1d:
00463 set_nz(a |= read_byte_abs_x());
00464 ENDOP(4);
00465
00466 case 0x19:
00467 set_nz(a |= read_byte_abs_y());
00468 ENDOP(4);
00469
00470 case 0x01:
00471 set_nz(a |= read_byte_ind_x());
00472 ENDOP(6);
00473
00474 case 0x11:
00475 set_nz(a |= read_byte_ind_y());
00476 ENDOP(5);
00477
00478 case 0x49:
00479 set_nz(a ^= read_byte_imm());
00480 ENDOP(2);
00481
00482 case 0x45:
00483 set_nz(a ^= read_byte_zero());
00484 ENDOP(3);
00485
00486 case 0x55:
00487 set_nz(a ^= read_byte_zero_x());
00488 ENDOP(4);
00489
00490 case 0x4d:
00491 set_nz(a ^= read_byte_abs());
00492 ENDOP(4);
00493
00494 case 0x5d:
00495 set_nz(a ^= read_byte_abs_x());
00496 ENDOP(4);
00497
00498 case 0x59:
00499 set_nz(a ^= read_byte_abs_y());
00500 ENDOP(4);
00501
00502 case 0x41:
00503 set_nz(a ^= read_byte_ind_x());
00504 ENDOP(6);
00505
00506 case 0x51:
00507 set_nz(a ^= read_byte_ind_y());
00508 ENDOP(5);
00509
00510
00511
00512 case 0xc9:
00513 set_nz(adr = a - read_byte_imm());
00514 c_flag = adr < 0x100;
00515 ENDOP(2);
00516
00517 case 0xc5:
00518 set_nz(adr = a - read_byte_zero());
00519 c_flag = adr < 0x100;
00520 ENDOP(3);
00521
00522 case 0xd5:
00523 set_nz(adr = a - read_byte_zero_x());
00524 c_flag = adr < 0x100;
00525 ENDOP(4);
00526
00527 case 0xcd:
00528 set_nz(adr = a - read_byte_abs());
00529 c_flag = adr < 0x100;
00530 ENDOP(4);
00531
00532 case 0xdd:
00533 set_nz(adr = a - read_byte_abs_x());
00534 c_flag = adr < 0x100;
00535 ENDOP(4);
00536
00537 case 0xd9:
00538 set_nz(adr = a - read_byte_abs_y());
00539 c_flag = adr < 0x100;
00540 ENDOP(4);
00541
00542 case 0xc1:
00543 set_nz(adr = a - read_byte_ind_x());
00544 c_flag = adr < 0x100;
00545 ENDOP(6);
00546
00547 case 0xd1:
00548 set_nz(adr = a - read_byte_ind_y());
00549 c_flag = adr < 0x100;
00550 ENDOP(5);
00551
00552 case 0xe0:
00553 set_nz(adr = x - read_byte_imm());
00554 c_flag = adr < 0x100;
00555 ENDOP(2);
00556
00557 case 0xe4:
00558 set_nz(adr = x - read_byte_zero());
00559 c_flag = adr < 0x100;
00560 ENDOP(3);
00561
00562 case 0xec:
00563 set_nz(adr = x - read_byte_abs());
00564 c_flag = adr < 0x100;
00565 ENDOP(4);
00566
00567 case 0xc0:
00568 set_nz(adr = y - read_byte_imm());
00569 c_flag = adr < 0x100;
00570 ENDOP(2);
00571
00572 case 0xc4:
00573 set_nz(adr = y - read_byte_zero());
00574 c_flag = adr < 0x100;
00575 ENDOP(3);
00576
00577 case 0xcc:
00578 set_nz(adr = y - read_byte_abs());
00579 c_flag = adr < 0x100;
00580 ENDOP(4);
00581
00582
00583
00584 case 0x24:
00585 z_flag = a & (tmp = read_byte_zero());
00586 n_flag = tmp;
00587
00588 v_flag = BOOL_BIT(tmp, 0x40);
00589 ENDOP(3);
00590
00591 case 0x2c:
00592 z_flag = a & (tmp = read_byte_abs());
00593 n_flag = tmp;
00594
00595 v_flag = BOOL_BIT(tmp,0x40);
00596 ENDOP(4);
00597
00598
00599
00600 case 0x0a:
00601
00602 c_flag = BOOL_BIT(a, 0x80);
00603 set_nz(a <<= 1);
00604 ENDOP(2);
00605
00606 case 0x06:
00607 tmp = read_zp(adr = read_adr_zero());
00608
00609 c_flag = BOOL_BIT(tmp, 0x80);
00610 write_zp(adr, set_nz(tmp << 1));
00611 ENDOP(5);
00612
00613 case 0x16:
00614 tmp = read_zp(adr = read_adr_zero_x());
00615
00616 c_flag = BOOL_BIT(tmp, 0x80);
00617 write_zp(adr, set_nz(tmp << 1));
00618 ENDOP(6);
00619
00620 case 0x0e:
00621 tmp = read_byte(adr = read_adr_abs());
00622
00623 c_flag = BOOL_BIT(tmp, 0x80);
00624 write_byte(adr, set_nz(tmp << 1));
00625 ENDOP(6);
00626
00627 case 0x1e:
00628 tmp = read_byte(adr = read_adr_abs_x());
00629
00630 c_flag = BOOL_BIT(tmp, 0x80);
00631 write_byte(adr, set_nz(tmp << 1));
00632 ENDOP(7);
00633
00634 case 0x4a:
00635 c_flag = a & 0x01;
00636 set_nz(a >>= 1);
00637 ENDOP(2);
00638
00639 case 0x46:
00640 tmp = read_zp(adr = read_adr_zero());
00641 c_flag = tmp & 0x01;
00642 write_zp(adr, set_nz(tmp >> 1));
00643 ENDOP(5);
00644
00645 case 0x56:
00646 tmp = read_zp(adr = read_adr_zero_x());
00647 c_flag = tmp & 0x01;
00648 write_zp(adr, set_nz(tmp >> 1));
00649 ENDOP(6);
00650
00651 case 0x4e:
00652 tmp = read_byte(adr = read_adr_abs());
00653 c_flag = tmp & 0x01;
00654 write_byte(adr, set_nz(tmp >> 1));
00655 ENDOP(6);
00656
00657 case 0x5e:
00658 tmp = read_byte(adr = read_adr_abs_x());
00659 c_flag = tmp & 0x01;
00660 write_byte(adr, set_nz(tmp >> 1));
00661 ENDOP(7);
00662
00663 case 0x2a:
00664
00665 tmpb = BOOL_BIT(a, 0x80);
00666 set_nz(a = c_flag ? (a << 1) | 0x01 : a << 1);
00667 c_flag = tmpb;
00668 ENDOP(2);
00669
00670 case 0x26:
00671 tmp = read_zp(adr = read_adr_zero());
00672
00673 tmpb = BOOL_BIT(tmp, 0x80);
00674 write_zp(adr, set_nz(c_flag ? (tmp << 1) | 0x01 : tmp << 1));
00675 c_flag = tmpb;
00676 ENDOP(5);
00677
00678 case 0x36:
00679 tmp = read_zp(adr = read_adr_zero_x());
00680
00681 tmpb = BOOL_BIT(tmp, 0x80);
00682 write_zp(adr, set_nz(c_flag ? (tmp << 1) | 0x01 : tmp << 1));
00683 c_flag = tmpb;
00684 ENDOP(6);
00685
00686 case 0x2e:
00687 tmp = read_byte(adr = read_adr_abs());
00688
00689 tmpb = BOOL_BIT(tmp, 0x80);
00690 write_byte(adr, set_nz(c_flag ? (tmp << 1) | 0x01 : tmp << 1));
00691 c_flag = tmpb;
00692 ENDOP(6);
00693
00694 case 0x3e:
00695 tmp = read_byte(adr = read_adr_abs_x());
00696
00697 tmpb = BOOL_BIT(tmp, 0x80);
00698 write_byte(adr, set_nz(c_flag ? (tmp << 1) | 0x01 : tmp << 1));
00699 c_flag = tmpb;
00700 ENDOP(7);
00701
00702 case 0x6a:
00703
00704 tmpb = BOOL_BIT(a, 0x01);
00705 set_nz(a = (c_flag ? (a >> 1) | 0x80 : a >> 1));
00706 c_flag = tmpb;
00707 ENDOP(2);
00708
00709 case 0x66:
00710 tmp = read_zp(adr = read_adr_zero());
00711
00712 tmpb = BOOL_BIT(tmp, 0x01);
00713 write_zp(adr, set_nz(c_flag ? (tmp >> 1) | 0x80 : tmp >> 1));
00714 c_flag = tmpb;
00715 ENDOP(5);
00716
00717 case 0x76:
00718 tmp = read_zp(adr = read_adr_zero_x());
00719
00720 tmpb = BOOL_BIT(tmp, 0x01);
00721 write_zp(adr, set_nz(c_flag ? (tmp >> 1) | 0x80 : tmp >> 1));
00722 c_flag = tmpb;
00723 ENDOP(6);
00724
00725 case 0x6e:
00726 tmp = read_byte(adr = read_adr_abs());
00727
00728 tmpb = BOOL_BIT(tmp, 0x01);
00729 write_byte(adr, set_nz(c_flag ? (tmp >> 1) | 0x80 : tmp >> 1));
00730 c_flag = tmpb;
00731 ENDOP(6);
00732
00733 case 0x7e:
00734 tmp = read_byte(adr = read_adr_abs_x());
00735
00736 tmpb = BOOL_BIT(tmp, 0x01);
00737 write_byte(adr, set_nz(c_flag ? (tmp >> 1) | 0x80 : tmp >> 1));
00738 c_flag = tmpb;
00739 ENDOP(7);
00740
00741
00742
00743 case 0x48:
00744 push_byte(a);
00745 ENDOP(3);
00746
00747 case 0x68:
00748 set_nz(a = pop_byte());
00749 ENDOP(4);
00750
00751 case 0x08:
00752 push_flags(true);
00753 ENDOP(3);
00754
00755 case 0x28:
00756 pop_flags();
00757 if (interrupt.intr_any && !i_flag)
00758 goto handle_int;
00759 ENDOP(4);
00760
00761
00762
00763 case 0x4c:
00764 jump(read_adr_abs());
00765 ENDOP(3);
00766
00767 case 0x6c:
00768 adr = read_adr_abs();
00769 jump(read_byte(adr) | (read_byte((adr + 1) & 0xff | adr & 0xff00) << 8));
00770 ENDOP(5);
00771
00772 case 0x20:
00773 #if PC_IS_POINTER
00774 push_byte((pc-pc_base+1) >> 8); push_byte(pc-pc_base+1);
00775 #else
00776 push_byte(pc+1 >> 8); push_byte(pc+1);
00777 #endif
00778 jump(read_adr_abs());
00779 ENDOP(6);
00780
00781 case 0x60:
00782 adr = pop_byte();
00783 jump((adr | pop_byte() << 8) + 1);
00784 ENDOP(6);
00785
00786 case 0x40:
00787 pop_flags();
00788 adr = pop_byte();
00789 jump(adr | pop_byte() << 8);
00790 if (interrupt.intr_any && !i_flag)
00791 goto handle_int;
00792 ENDOP(6);
00793
00794 case 0x00:
00795 #if PC_IS_POINTER
00796 push_byte((pc+1-pc_base) >> 8); push_byte(pc+1-pc_base);
00797 #else
00798 push_byte((pc+1) >> 8); push_byte(pc+1);
00799 #endif
00800 push_flags(true);
00801 i_flag = true;
00802 jump(read_word(0xfffe));
00803 ENDOP(7);
00804
00805 #if PC_IS_POINTER
00806 #if PRECISE_CPU_CYCLES
00807 #define Branch(flag) \
00808 if (flag) { \
00809 pc += (int8)*pc + 1; \
00810 if (((pc-pc_base) ^ (old_pc - pc_base)) & 0xff00) { \
00811 ENDOP(4); \
00812 } else { \
00813 ENDOP(3); \
00814 } \
00815 } else { \
00816 pc++; \
00817 ENDOP(2); \
00818 }
00819 #else
00820 #define Branch(flag) \
00821 if (flag) { \
00822 pc += (int8)*pc + 1; \
00823 ENDOP(3); \
00824 } else { \
00825 pc++; \
00826 ENDOP(2); \
00827 }
00828 #endif
00829 #else
00830 #define Branch(flag) \
00831 if (flag) { \
00832 uint16 old_pc = pc; \
00833 pc += (int8)read_byte(pc) + 1; \
00834 if ((pc ^ old_pc) & 0xff00) { \
00835 ENDOP(4); \
00836 } else { \
00837 ENDOP(3); \
00838 } \
00839 } else { \
00840 pc++; \
00841 ENDOP(2); \
00842 }
00843 #endif
00844
00845 case 0xb0:
00846 Branch(c_flag);
00847
00848 case 0x90:
00849 Branch(!c_flag);
00850
00851 case 0xf0:
00852 Branch(!z_flag);
00853
00854 case 0xd0:
00855 Branch(z_flag);
00856
00857 case 0x70:
00858 #ifndef IS_CPU_1541
00859 Branch(v_flag);
00860 #else
00861 Branch((via2_pcr & 0x0e) == 0x0e ? 1 : v_flag);
00862 #endif
00863
00864 case 0x50:
00865 #ifndef IS_CPU_1541
00866 Branch(!v_flag);
00867 #else
00868 Branch(!((via2_pcr & 0x0e) == 0x0e) ? 0 : v_flag);
00869 #endif
00870
00871 case 0x30:
00872 Branch(n_flag & 0x80);
00873
00874 case 0x10:
00875 Branch(!(n_flag & 0x80));
00876
00877
00878
00879 case 0x38:
00880 c_flag = true;
00881 ENDOP(2);
00882
00883 case 0x18:
00884 c_flag = false;
00885 ENDOP(2);
00886
00887 case 0xf8:
00888 d_flag = true;
00889 ENDOP(2);
00890
00891 case 0xd8:
00892 d_flag = false;
00893 ENDOP(2);
00894
00895 case 0x78:
00896 i_flag = true;
00897 ENDOP(2);
00898
00899 case 0x58:
00900 i_flag = false;
00901 if (interrupt.intr_any)
00902 goto handle_int;
00903 ENDOP(2);
00904
00905 case 0xb8:
00906 v_flag = false;
00907 ENDOP(2);
00908
00909
00910
00911 case 0xea:
00912 ENDOP(2);
00913
00914
00915
00916
00917
00918
00919
00920 case 0x1a:
00921 case 0x3a:
00922 case 0x5a:
00923 case 0x7a:
00924 case 0xda:
00925 case 0xfa:
00926 ENDOP(2);
00927
00928 case 0x80:
00929 case 0x82:
00930 case 0x89:
00931 case 0xc2:
00932 case 0xe2:
00933 pc++;
00934 ENDOP(2);
00935
00936 case 0x04:
00937 case 0x44:
00938 case 0x64:
00939 pc++;
00940 ENDOP(3);
00941
00942 case 0x14:
00943 case 0x34:
00944 case 0x54:
00945 case 0x74:
00946 case 0xd4:
00947 case 0xf4:
00948 pc++;
00949 ENDOP(4);
00950
00951 case 0x0c:
00952 pc+=2;
00953 ENDOP(4);
00954
00955 case 0x1c:
00956 case 0x3c:
00957 case 0x5c:
00958 case 0x7c:
00959 case 0xdc:
00960 case 0xfc:
00961 #if PRECISE_CPU_CYCLES
00962 read_byte_abs_x();
00963 #else
00964 pc+=2;
00965 #endif
00966 ENDOP(4);
00967
00968
00969
00970 case 0xa7:
00971 set_nz(a = x = read_byte_zero());
00972 ENDOP(3);
00973
00974 case 0xb7:
00975 set_nz(a = x = read_byte_zero_y());
00976 ENDOP(4);
00977
00978 case 0xaf:
00979 set_nz(a = x = read_byte_abs());
00980 ENDOP(4);
00981
00982 case 0xbf:
00983 set_nz(a = x = read_byte_abs_y());
00984 ENDOP(4);
00985
00986 case 0xa3:
00987 set_nz(a = x = read_byte_ind_x());
00988 ENDOP(6);
00989
00990 case 0xb3:
00991 set_nz(a = x = read_byte_ind_y());
00992 ENDOP(5);
00993
00994
00995
00996 case 0x87:
00997 write_byte(read_adr_zero(), a & x);
00998 ENDOP(3);
00999
01000 case 0x97:
01001 write_byte(read_adr_zero_y(), a & x);
01002 ENDOP(4);
01003
01004 case 0x8f:
01005 write_byte(read_adr_abs(), a & x);
01006 ENDOP(4);
01007
01008 case 0x83:
01009 write_byte(read_adr_ind_x(), a & x);
01010 ENDOP(6);
01011
01012
01013
01014 #define ShiftLeftOr \
01015 c_flag = BOOL_BIT(tmp, 0x80); \
01016 tmp <<= 1; \
01017 set_nz(a |= tmp);
01018
01019 case 0x07:
01020 tmp = read_zp(adr = read_adr_zero());
01021 ShiftLeftOr;
01022 write_zp(adr, tmp);
01023 ENDOP(5);
01024
01025 case 0x17:
01026 tmp = read_zp(adr = read_adr_zero_x());
01027 ShiftLeftOr;
01028 write_zp(adr, tmp);
01029 ENDOP(6);
01030
01031 case 0x0f:
01032 tmp = read_byte(adr = read_adr_abs());
01033 ShiftLeftOr;
01034 write_byte(adr, tmp);
01035 ENDOP(6);
01036
01037 case 0x1f:
01038 tmp = read_byte(adr = read_adr_abs_x());
01039 ShiftLeftOr;
01040 write_byte(adr, tmp);
01041 ENDOP(7);
01042
01043 case 0x1b:
01044 tmp = read_byte(adr = read_adr_abs_y());
01045 ShiftLeftOr;
01046 write_byte(adr, tmp);
01047 ENDOP(7);
01048
01049 case 0x03:
01050 tmp = read_byte(adr = read_adr_ind_x());
01051 ShiftLeftOr;
01052 write_byte(adr, tmp);
01053 ENDOP(8);
01054
01055 case 0x13:
01056 tmp = read_byte(adr = read_adr_ind_y());
01057 ShiftLeftOr;
01058 write_byte(adr, tmp);
01059 ENDOP(8);
01060
01061
01062
01063 #define RoLeftAnd \
01064 tmpb = BOOL_BIT(tmp, 0x80); \
01065 tmp = c_flag ? (tmp << 1) | 0x01 : tmp << 1; \
01066 set_nz(a &= tmp); \
01067 c_flag = tmpb;
01068
01069 case 0x27:
01070 tmp = read_zp(adr = read_adr_zero());
01071 RoLeftAnd;
01072 write_zp(adr, tmp);
01073 ENDOP(5);
01074
01075 case 0x37:
01076 tmp = read_zp(adr = read_adr_zero_x());
01077 RoLeftAnd;
01078 write_zp(adr, tmp);
01079 ENDOP(6);
01080
01081 case 0x2f:
01082 tmp = read_byte(adr = read_adr_abs());
01083 RoLeftAnd;
01084 write_byte(adr, tmp);
01085 ENDOP(6);
01086
01087 case 0x3f:
01088 tmp = read_byte(adr = read_adr_abs_x());
01089 RoLeftAnd;
01090 write_byte(adr, tmp);
01091 ENDOP(7);
01092
01093 case 0x3b:
01094 tmp = read_byte(adr = read_adr_abs_y());
01095 RoLeftAnd;
01096 write_byte(adr, tmp);
01097 ENDOP(7);
01098
01099 case 0x23:
01100 tmp = read_byte(adr = read_adr_ind_x());
01101 RoLeftAnd;
01102 write_byte(adr, tmp);
01103 ENDOP(8);
01104
01105 case 0x33:
01106 tmp = read_byte(adr = read_adr_ind_y());
01107 RoLeftAnd;
01108 write_byte(adr, tmp);
01109 ENDOP(8);
01110
01111
01112
01113 #define ShiftRightEor \
01114 c_flag = tmp & 0x01; \
01115 tmp >>= 1; \
01116 set_nz(a ^= tmp);
01117
01118 case 0x47:
01119 tmp = read_zp(adr = read_adr_zero());
01120 ShiftRightEor;
01121 write_zp(adr, tmp);
01122 ENDOP(5);
01123
01124 case 0x57:
01125 tmp = read_zp(adr = read_adr_zero_x());
01126 ShiftRightEor;
01127 write_zp(adr, tmp);
01128 ENDOP(6);
01129
01130 case 0x4f:
01131 tmp = read_byte(adr = read_adr_abs());
01132 ShiftRightEor;
01133 write_byte(adr, tmp);
01134 ENDOP(6);
01135
01136 case 0x5f:
01137 tmp = read_byte(adr = read_adr_abs_x());
01138 ShiftRightEor;
01139 write_byte(adr, tmp);
01140 ENDOP(7);
01141
01142 case 0x5b:
01143 tmp = read_byte(adr = read_adr_abs_y());
01144 ShiftRightEor;
01145 write_byte(adr, tmp);
01146 ENDOP(7);
01147
01148 case 0x43:
01149 tmp = read_byte(adr = read_adr_ind_x());
01150 ShiftRightEor;
01151 write_byte(adr, tmp);
01152 ENDOP(8);
01153
01154 case 0x53:
01155 tmp = read_byte(adr = read_adr_ind_y());
01156 ShiftRightEor;
01157 write_byte(adr, tmp);
01158 ENDOP(8);
01159
01160
01161
01162 #define RoRightAdc \
01163 tmpb = BOOL_BIT(tmp, 0x01); \
01164 tmp = c_flag ? (tmp >> 1) | 0x80 : tmp >> 1; \
01165 c_flag = tmpb; \
01166 do_adc(tmp);
01167
01168 case 0x67:
01169 tmp = read_zp(adr = read_adr_zero());
01170 RoRightAdc;
01171 write_zp(adr, tmp);
01172 ENDOP(5);
01173
01174 case 0x77:
01175 tmp = read_zp(adr = read_adr_zero_x());
01176 RoRightAdc;
01177 write_zp(adr, tmp);
01178 ENDOP(6);
01179
01180 case 0x6f:
01181 tmp = read_byte(adr = read_adr_abs());
01182 RoRightAdc;
01183 write_byte(adr, tmp);
01184 ENDOP(6);
01185
01186 case 0x7f:
01187 tmp = read_byte(adr = read_adr_abs_x());
01188 RoRightAdc;
01189 write_byte(adr, tmp);
01190 ENDOP(7);
01191
01192 case 0x7b:
01193 tmp = read_byte(adr = read_adr_abs_y());
01194 RoRightAdc;
01195 write_byte(adr, tmp);
01196 ENDOP(7);
01197
01198 case 0x63:
01199 tmp = read_byte(adr = read_adr_ind_x());
01200 RoRightAdc;
01201 write_byte(adr, tmp);
01202 ENDOP(8);
01203
01204 case 0x73:
01205 tmp = read_byte(adr = read_adr_ind_y());
01206 RoRightAdc;
01207 write_byte(adr, tmp);
01208 ENDOP(8);
01209
01210
01211
01212 #define DecCompare \
01213 set_nz(adr = a - tmp); \
01214 c_flag = adr < 0x100;
01215
01216 case 0xc7:
01217 tmp = read_zp(adr = read_adr_zero()) - 1;
01218 write_zp(adr, tmp);
01219 DecCompare;
01220 ENDOP(5);
01221
01222 case 0xd7:
01223 tmp = read_zp(adr = read_adr_zero_x()) - 1;
01224 write_zp(adr, tmp);
01225 DecCompare;
01226 ENDOP(6);
01227
01228 case 0xcf:
01229 tmp = read_byte(adr = read_adr_abs()) - 1;
01230 write_byte(adr, tmp);
01231 DecCompare;
01232 ENDOP(6);
01233
01234 case 0xdf:
01235 tmp = read_byte(adr = read_adr_abs_x()) - 1;
01236 write_byte(adr, tmp);
01237 DecCompare;
01238 ENDOP(7);
01239
01240 case 0xdb:
01241 tmp = read_byte(adr = read_adr_abs_y()) - 1;
01242 write_byte(adr, tmp);
01243 DecCompare;
01244 ENDOP(7);
01245
01246 case 0xc3:
01247 tmp = read_byte(adr = read_adr_ind_x()) - 1;
01248 write_byte(adr, tmp);
01249 DecCompare;
01250 ENDOP(8);
01251
01252 case 0xd3:
01253 tmp = read_byte(adr = read_adr_ind_y()) - 1;
01254 write_byte(adr, tmp);
01255 DecCompare;
01256 ENDOP(8);
01257
01258
01259
01260 case 0xe7:
01261 tmp = read_zp(adr = read_adr_zero()) + 1;
01262 do_sbc(tmp);
01263 write_zp(adr, tmp);
01264 ENDOP(5);
01265
01266 case 0xf7:
01267 tmp = read_zp(adr = read_adr_zero_x()) + 1;
01268 do_sbc(tmp);
01269 write_zp(adr, tmp);
01270 ENDOP(6);
01271
01272 case 0xef:
01273 tmp = read_byte(adr = read_adr_abs()) + 1;
01274 do_sbc(tmp);
01275 write_byte(adr, tmp);
01276 ENDOP(6);
01277
01278 case 0xff:
01279 tmp = read_byte(adr = read_adr_abs_x()) + 1;
01280 do_sbc(tmp);
01281 write_byte(adr, tmp);
01282 ENDOP(7);
01283
01284 case 0xfb:
01285 tmp = read_byte(adr = read_adr_abs_y()) + 1;
01286 do_sbc(tmp);
01287 write_byte(adr, tmp);
01288 ENDOP(7);
01289
01290 case 0xe3:
01291 tmp = read_byte(adr = read_adr_ind_x()) + 1;
01292 do_sbc(tmp);
01293 write_byte(adr, tmp);
01294 ENDOP(8);
01295
01296 case 0xf3:
01297 tmp = read_byte(adr = read_adr_ind_y()) + 1;
01298 do_sbc(tmp);
01299 write_byte(adr, tmp);
01300 ENDOP(8);
01301
01302
01303
01304 case 0x0b:
01305 case 0x2b:
01306 set_nz(a &= read_byte_imm());
01307
01308 c_flag = BOOL_BIT(n_flag, 0x80);
01309 ENDOP(2);
01310
01311 case 0x4b:
01312 a &= read_byte_imm();
01313
01314 c_flag = BOOL_BIT(a, 0x01);
01315 set_nz(a >>= 1);
01316 ENDOP(2);
01317
01318 case 0x6b:
01319 tmp2 = read_byte_imm() & a;
01320 a = (c_flag ? (tmp2 >> 1) | 0x80 : tmp2 >> 1);
01321 if (!d_flag) {
01322 set_nz(a);
01323
01324 c_flag = BOOL_BIT(a, 0x40);
01325
01326 v_flag = (((a & 0x40) ^ ((a & 0x20) << 1)) == 0x40);
01327 } else {
01328 n_flag = c_flag ? 0x80 : 0;
01329 z_flag = a;
01330
01331 v_flag = (((tmp2 ^ a) & 0x40) == 0x40);
01332 if ((tmp2 & 0x0f) + (tmp2 & 0x01) > 5)
01333 a = a & 0xf0 | (a + 6) & 0x0f;
01334 if (c_flag = ((tmp2 + (tmp2 & 0x10)) & 0x1f0) > 0x50)
01335 a += 0x60;
01336 }
01337 ENDOP(2);
01338
01339 case 0x8b:
01340 set_nz(a = read_byte_imm() & x & (a | 0xee));
01341 ENDOP(2);
01342
01343 case 0x93:
01344 #if PC_IS_POINTER
01345 tmp2 = read_zp(pc[0] + 1);
01346 #else
01347 tmp2 = read_zp(read_byte(pc) + 1);
01348 #endif
01349 write_byte(read_adr_ind_y(), a & x & (tmp2+1));
01350 ENDOP(6);
01351
01352 case 0x9b:
01353 #if PC_IS_POINTER
01354 tmp2 = pc[1];
01355 #else
01356 tmp2 = read_byte(pc+1);
01357 #endif
01358 write_byte(read_adr_abs_y(), a & x & (tmp2+1));
01359 sp = a & x;
01360 ENDOP(5);
01361
01362 case 0x9c:
01363 #if PC_IS_POINTER
01364 tmp2 = pc[1];
01365 #else
01366 tmp2 = read_byte(pc+1);
01367 #endif
01368 write_byte(read_adr_abs_x(), y & (tmp2+1));
01369 ENDOP(5);
01370
01371 case 0x9e:
01372 #if PC_IS_POINTER
01373 tmp2 = pc[1];
01374 #else
01375 tmp2 = read_byte(pc+1);
01376 #endif
01377 write_byte(read_adr_abs_y(), x & (tmp2+1));
01378 ENDOP(5);
01379
01380 case 0x9f:
01381 #if PC_IS_POINTER
01382 tmp2 = pc[1];
01383 #else
01384 tmp2 = read_byte(pc+1);
01385 #endif
01386 write_byte(read_adr_abs_y(), a & x & (tmp2+1));
01387 ENDOP(5);
01388
01389 case 0xab:
01390 set_nz(a = x = (a | 0xee) & read_byte_imm());
01391 ENDOP(2);
01392
01393 case 0xbb:
01394 set_nz(a = x = sp = read_byte_abs_y() & sp);
01395 ENDOP(4);
01396
01397 case 0xcb:
01398 x &= a;
01399 adr = x - read_byte_imm();
01400 c_flag = adr < 0x100;
01401
01402 set_nz(x = (uint8)adr);
01403 ENDOP(2);
01404
01405 case 0x02:
01406 case 0x12:
01407 case 0x22:
01408 case 0x32:
01409 case 0x42:
01410 case 0x52:
01411 case 0x62:
01412 case 0x72:
01413 case 0x92:
01414 case 0xb2:
01415 case 0xd2:
01416 #if PC_IS_POINTER
01417 illegal_op(*(pc-1), pc-pc_base-1);
01418 #else
01419 illegal_op(read_byte(pc-1), pc-1);
01420 #endif
01421 break;