Main Page | Class Hierarchy | Compound List | File List | Compound Members | File Members | Related Pages

CPU_emulline.i

Go to the documentation of this file.
00001 /*
00002  *  CPU_emulline.i - 6510/6502 emulation core (body of
00003  *                   EmulateLine() function, the same for
00004  *                   both 6510 and 6502)
00005  *
00006  *  Frodo (C) 1994-1997 Christian Bauer
00007  */
00008 
00009 
00010 /*
00011  *  Addressing mode macros
00012  */
00013 
00014 // Read immediate operand
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 // Read zeropage operand address
00022 #define read_adr_zero() ((uint16)read_byte_imm())
00023 
00024 // Read zeropage x-indexed operand address
00025 #define read_adr_zero_x() ((read_byte_imm() + x) & 0xff)
00026 
00027 // Read zeropage y-indexed operand address
00028 #define read_adr_zero_y() ((read_byte_imm() + y) & 0xff)
00029 
00030 // Read absolute operand address (uses adr!)
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 // Read absolute x-indexed operand address
00042 #define read_adr_abs_x() (read_adr_abs() + x)
00043 
00044 // Read absolute y-indexed operand address
00045 #define read_adr_abs_y() (read_adr_abs() + y)
00046 
00047 // Read indexed indirect operand address
00048 #define read_adr_ind_x() (read_zp_word(read_byte_imm() + x))
00049 
00050 // Read indirect indexed operand address
00051 #define read_adr_ind_y() (read_zp_word(read_byte_imm()) + y)
00052 
00053 // Read zeropage operand
00054 #define read_byte_zero() read_zp(read_adr_zero())
00055 
00056 // Read zeropage x-indexed operand
00057 #define read_byte_zero_x() read_zp(read_adr_zero_x())
00058 
00059 // Read zeropage y-indexed operand
00060 #define read_byte_zero_y() read_zp(read_adr_zero_y())
00061 
00062 // Read absolute operand
00063 #define read_byte_abs() read_byte(read_adr_abs())
00064 
00065 #if PRECISE_CPU_CYCLES
00066 // Acount for cyles due to crossing page boundaries
00067 #define page_plus(exp, reg) \
00068         (adr = exp, page_cycles = (adr & 0xff) + reg >= 0x100, adr + reg)
00069 
00070 // Read absolute x-indexed operand
00071 #define read_byte_abs_x() read_byte(page_plus(read_adr_abs(), x))
00072 
00073 // Read absolute x-indexed operand
00074 #define read_byte_abs_y() read_byte(page_plus(read_adr_abs(), y))
00075 
00076 // Read indirect y-indexed operand
00077 #define read_byte_ind_y() read_byte(page_plus(read_zp_word(read_byte_imm()), y))
00078 
00079 #else
00080 
00081 // Read absolute x-indexed operand
00082 #define read_byte_abs_x() read_byte(read_adr_abs_x())
00083 
00084 // Read absolute x-indexed operand
00085 #define read_byte_abs_y() read_byte(read_adr_abs_y())
00086 
00087 // Read indirect y-indexed operand
00088 #define read_byte_ind_y() read_byte(read_adr_ind_y())
00089 #endif
00090 
00091 // Read indexed indirect operand
00092 #define read_byte_ind_x() read_byte(read_adr_ind_x())
00093 
00094 
00095 /*
00096  *  Set N and Z flags according to byte
00097  */
00098 
00099 #define set_nz(x) (z_flag = n_flag = (uint8)(x))        //AEH 991113
00100 
00101 
00102 /*
00103  * End of opcode, decrement cycles left
00104  */
00105 
00106 #define ENDOP(cyc) last_cycles = cyc; break;
00107 
00108 
00109         // Main opcode fetch/execute loop
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                 // Load group
00135                 case 0xa9:      // LDA #imm
00136                         set_nz(a = read_byte_imm());
00137                         ENDOP(2);
00138 
00139                 case 0xa5:      // LDA zero
00140                         set_nz(a = read_byte_zero());
00141                         ENDOP(3);
00142 
00143                 case 0xb5:      // LDA zero,X
00144                         set_nz(a = read_byte_zero_x());
00145                         ENDOP(4);
00146 
00147                 case 0xad:      // LDA abs
00148                         set_nz(a = read_byte_abs());
00149                         ENDOP(4);
00150 
00151                 case 0xbd:      // LDA abs,X
00152                         set_nz(a = read_byte_abs_x());
00153                         ENDOP(4);
00154 
00155                 case 0xb9:      // LDA abs,Y
00156                         set_nz(a = read_byte_abs_y());
00157                         ENDOP(4);
00158 
00159                 case 0xa1:      // LDA (ind,X)
00160                         set_nz(a = read_byte_ind_x());
00161                         ENDOP(6);
00162                 
00163                 case 0xb1:      // LDA (ind),Y
00164                         set_nz(a = read_byte_ind_y());
00165                         ENDOP(5);
00166 
00167                 case 0xa2:      // LDX #imm
00168                         set_nz(x = read_byte_imm());
00169                         ENDOP(2);
00170 
00171                 case 0xa6:      // LDX zero
00172                         set_nz(x = read_byte_zero());
00173                         ENDOP(3);
00174 
00175                 case 0xb6:      // LDX zero,Y
00176                         set_nz(x = read_byte_zero_y());
00177                         ENDOP(4);
00178 
00179                 case 0xae:      // LDX abs
00180                         set_nz(x = read_byte_abs());
00181                         ENDOP(4);
00182 
00183                 case 0xbe:      // LDX abs,Y
00184                         set_nz(x = read_byte_abs_y());
00185                         ENDOP(4);
00186 
00187                 case 0xa0:      // LDY #imm
00188                         set_nz(y = read_byte_imm());
00189                         ENDOP(2);
00190 
00191                 case 0xa4:      // LDY zero
00192                         set_nz(y = read_byte_zero());
00193                         ENDOP(3);
00194 
00195                 case 0xb4:      // LDY zero,X
00196                         set_nz(y = read_byte_zero_x());
00197                         ENDOP(4);
00198 
00199                 case 0xac:      // LDY abs
00200                         set_nz(y = read_byte_abs());
00201                         ENDOP(4);
00202 
00203                 case 0xbc:      // LDY abs,X
00204                         set_nz(y = read_byte_abs_x());
00205                         ENDOP(4);
00206 
00207 
00208                 // Store group
00209                 case 0x85:      // STA zero
00210                         write_byte(read_adr_zero(), a);
00211                         ENDOP(3);
00212 
00213                 case 0x95:      // STA zero,X
00214                         write_byte(read_adr_zero_x(), a);
00215                         ENDOP(4);
00216 
00217                 case 0x8d:      // STA abs
00218                         write_byte(read_adr_abs(), a);
00219                         ENDOP(4);
00220 
00221                 case 0x9d:      // STA abs,X
00222                         write_byte(read_adr_abs_x(), a);
00223                         ENDOP(5);
00224 
00225                 case 0x99:      // STA abs,Y
00226                         write_byte(read_adr_abs_y(), a);
00227                         ENDOP(5);
00228 
00229                 case 0x81:      // STA (ind,X)
00230                         write_byte(read_adr_ind_x(), a);
00231                         ENDOP(6);
00232 
00233                 case 0x91:      // STA (ind),Y
00234                         write_byte(read_adr_ind_y(), a);
00235                         ENDOP(6);
00236 
00237                 case 0x86:      // STX zero
00238                         write_byte(read_adr_zero(), x);
00239                         ENDOP(3);
00240 
00241                 case 0x96:      // STX zero,Y
00242                         write_byte(read_adr_zero_y(), x);
00243                         ENDOP(4);
00244 
00245                 case 0x8e:      // STX abs
00246                         write_byte(read_adr_abs(), x);
00247                         ENDOP(4);
00248 
00249                 case 0x84:      // STY zero
00250                         write_byte(read_adr_zero(), y);
00251                         ENDOP(3);
00252 
00253                 case 0x94:      // STY zero,X
00254                         write_byte(read_adr_zero_x(), y);
00255                         ENDOP(4);
00256 
00257                 case 0x8c:      // STY abs
00258                         write_byte(read_adr_abs(), y);
00259                         ENDOP(4);
00260 
00261 
00262                 // Transfer group
00263                 case 0xaa:      // TAX
00264                         set_nz(x = a);
00265                         ENDOP(2);
00266 
00267                 case 0x8a:      // TXA
00268                         set_nz(a = x);
00269                         ENDOP(2);
00270 
00271                 case 0xa8:      // TAY
00272                         set_nz(y = a);
00273                         ENDOP(2);
00274 
00275                 case 0x98:      // TYA
00276                         set_nz(a = y);
00277                         ENDOP(2);
00278 
00279                 case 0xba:      // TSX
00280                         set_nz(x = sp);
00281                         ENDOP(2);
00282 
00283                 case 0x9a:      // TXS
00284                         sp = x;
00285                         ENDOP(2);
00286 
00287 
00288                 // Arithmetic group
00289                 case 0x69:      // ADC #imm
00290                         do_adc(read_byte_imm());
00291                         ENDOP(2);
00292 
00293                 case 0x65:      // ADC zero
00294                         do_adc(read_byte_zero());
00295                         ENDOP(3);
00296 
00297                 case 0x75:      // ADC zero,X
00298                         do_adc(read_byte_zero_x());
00299                         ENDOP(4);
00300 
00301                 case 0x6d:      // ADC abs
00302                         do_adc(read_byte_abs());
00303                         ENDOP(4);
00304 
00305                 case 0x7d:      // ADC abs,X
00306                         do_adc(read_byte_abs_x());
00307                         ENDOP(4);
00308 
00309                 case 0x79:      // ADC abs,Y
00310                         do_adc(read_byte_abs_y());
00311                         ENDOP(4);
00312 
00313                 case 0x61:      // ADC (ind,X)
00314                         do_adc(read_byte_ind_x());
00315                         ENDOP(6);
00316 
00317                 case 0x71:      // ADC (ind),Y
00318                         do_adc(read_byte_ind_y());
00319                         ENDOP(5);
00320 
00321                 case 0xe9:      // SBC #imm
00322                 case 0xeb:      // Undocumented opcode
00323                         do_sbc(read_byte_imm());
00324                         ENDOP(2);
00325 
00326                 case 0xe5:      // SBC zero
00327                         do_sbc(read_byte_zero());
00328                         ENDOP(3);
00329 
00330                 case 0xf5:      // SBC zero,X
00331                         do_sbc(read_byte_zero_x());
00332                         ENDOP(4);
00333 
00334                 case 0xed:      // SBC abs
00335                         do_sbc(read_byte_abs());
00336                         ENDOP(4);
00337 
00338                 case 0xfd:      // SBC abs,X
00339                         do_sbc(read_byte_abs_x());
00340                         ENDOP(4);
00341 
00342                 case 0xf9:      // SBC abs,Y
00343                         do_sbc(read_byte_abs_y());
00344                         ENDOP(4);
00345 
00346                 case 0xe1:      // SBC (ind,X)
00347                         do_sbc(read_byte_ind_x());
00348                         ENDOP(6);
00349 
00350                 case 0xf1:      // SBC (ind),Y
00351                         do_sbc(read_byte_ind_y());
00352                         ENDOP(5);
00353 
00354 
00355                 // Increment/decrement group
00356                 case 0xe8:      // INX
00357                         set_nz(++x);
00358                         ENDOP(2);
00359 
00360                 case 0xca:      // DEX
00361                         set_nz(--x);
00362                         ENDOP(2);
00363 
00364                 case 0xc8:      // INY
00365                         set_nz(++y);
00366                         ENDOP(2);
00367 
00368                 case 0x88:      // DEY
00369                         set_nz(--y);
00370                         ENDOP(2);
00371 
00372                 case 0xe6:      // INC zero
00373                         adr = read_adr_zero();
00374                         write_zp(adr, set_nz(read_zp(adr) + 1));
00375                         ENDOP(5);
00376 
00377                 case 0xf6:      // INC zero,X
00378                         adr = read_adr_zero_x();
00379                         write_zp(adr, set_nz(read_zp(adr) + 1));
00380                         ENDOP(6);
00381 
00382                 case 0xee:      // INC abs
00383                         adr = read_adr_abs();
00384                         write_byte(adr, set_nz(read_byte(adr) + 1));
00385                         ENDOP(6);
00386 
00387                 case 0xfe:      // INC abs,X
00388                         adr = read_adr_abs_x();
00389                         write_byte(adr, set_nz(read_byte(adr) + 1));
00390                         ENDOP(7);
00391 
00392                 case 0xc6:      // DEC zero
00393                         adr = read_adr_zero();
00394                         write_zp(adr, set_nz(read_zp(adr) - 1));
00395                         ENDOP(5);
00396 
00397                 case 0xd6:      // DEC zero,X
00398                         adr = read_adr_zero_x();
00399                         write_zp(adr, set_nz(read_zp(adr) - 1));
00400                         ENDOP(6);
00401 
00402                 case 0xce:      // DEC abs
00403                         adr = read_adr_abs();
00404                         write_byte(adr, set_nz(read_byte(adr) - 1));
00405                         ENDOP(6);
00406 
00407                 case 0xde:      // DEC abs,X
00408                         adr = read_adr_abs_x();
00409                         write_byte(adr, set_nz(read_byte(adr) - 1));
00410                         ENDOP(7);
00411 
00412 
00413                 // Logic group
00414                 case 0x29:      // AND #imm
00415                         set_nz(a &= read_byte_imm());
00416                         ENDOP(2);
00417 
00418                 case 0x25:      // AND zero
00419                         set_nz(a &= read_byte_zero());
00420                         ENDOP(3);
00421 
00422                 case 0x35:      // AND zero,X
00423                         set_nz(a &= read_byte_zero_x());
00424                         ENDOP(4);
00425 
00426                 case 0x2d:      // AND abs
00427                         set_nz(a &= read_byte_abs());
00428                         ENDOP(4);
00429 
00430                 case 0x3d:      // AND abs,X
00431                         set_nz(a &= read_byte_abs_x());
00432                         ENDOP(4);
00433 
00434                 case 0x39:      // AND abs,Y
00435                         set_nz(a &= read_byte_abs_y());
00436                         ENDOP(4);
00437 
00438                 case 0x21:      // AND (ind,X)
00439                         set_nz(a &= read_byte_ind_x());
00440                         ENDOP(6);
00441 
00442                 case 0x31:      // AND (ind),Y
00443                         set_nz(a &= read_byte_ind_y());
00444                         ENDOP(5);
00445 
00446                 case 0x09:      // ORA #imm
00447                         set_nz(a |= read_byte_imm());
00448                         ENDOP(2);
00449 
00450                 case 0x05:      // ORA zero
00451                         set_nz(a |= read_byte_zero());
00452                         ENDOP(3);
00453 
00454                 case 0x15:      // ORA zero,X
00455                         set_nz(a |= read_byte_zero_x());
00456                         ENDOP(4);
00457 
00458                 case 0x0d:      // ORA abs
00459                         set_nz(a |= read_byte_abs());
00460                         ENDOP(4);
00461 
00462                 case 0x1d:      // ORA abs,X
00463                         set_nz(a |= read_byte_abs_x());
00464                         ENDOP(4);
00465 
00466                 case 0x19:      // ORA abs,Y
00467                         set_nz(a |= read_byte_abs_y());
00468                         ENDOP(4);
00469 
00470                 case 0x01:      // ORA (ind,X)
00471                         set_nz(a |= read_byte_ind_x());
00472                         ENDOP(6);
00473 
00474                 case 0x11:      // ORA (ind),Y
00475                         set_nz(a |= read_byte_ind_y());
00476                         ENDOP(5);
00477 
00478                 case 0x49:      // EOR #imm
00479                         set_nz(a ^= read_byte_imm());
00480                         ENDOP(2);
00481 
00482                 case 0x45:      // EOR zero
00483                         set_nz(a ^= read_byte_zero());
00484                         ENDOP(3);
00485 
00486                 case 0x55:      // EOR zero,X
00487                         set_nz(a ^= read_byte_zero_x());
00488                         ENDOP(4);
00489 
00490                 case 0x4d:      // EOR abs
00491                         set_nz(a ^= read_byte_abs());
00492                         ENDOP(4);
00493 
00494                 case 0x5d:      // EOR abs,X
00495                         set_nz(a ^= read_byte_abs_x());
00496                         ENDOP(4);
00497 
00498                 case 0x59:      // EOR abs,Y
00499                         set_nz(a ^= read_byte_abs_y());
00500                         ENDOP(4);
00501 
00502                 case 0x41:      // EOR (ind,X)
00503                         set_nz(a ^= read_byte_ind_x());
00504                         ENDOP(6);
00505 
00506                 case 0x51:      // EOR (ind),Y
00507                         set_nz(a ^= read_byte_ind_y());
00508                         ENDOP(5);
00509 
00510 
00511                 // Compare group
00512                 case 0xc9:      // CMP #imm
00513                         set_nz(adr = a - read_byte_imm());
00514                         c_flag = adr < 0x100;
00515                         ENDOP(2);
00516 
00517                 case 0xc5:      // CMP zero
00518                         set_nz(adr = a - read_byte_zero());
00519                         c_flag = adr < 0x100;
00520                         ENDOP(3);
00521 
00522                 case 0xd5:      // CMP zero,X
00523                         set_nz(adr = a - read_byte_zero_x());
00524                         c_flag = adr < 0x100;
00525                         ENDOP(4);
00526 
00527                 case 0xcd:      // CMP abs
00528                         set_nz(adr = a - read_byte_abs());
00529                         c_flag = adr < 0x100;
00530                         ENDOP(4);
00531 
00532                 case 0xdd:      // CMP abs,X
00533                         set_nz(adr = a - read_byte_abs_x());
00534                         c_flag = adr < 0x100;
00535                         ENDOP(4);
00536 
00537                 case 0xd9:      // CMP abs,Y
00538                         set_nz(adr = a - read_byte_abs_y());
00539                         c_flag = adr < 0x100;
00540                         ENDOP(4);
00541 
00542                 case 0xc1:      // CMP (ind,X)
00543                         set_nz(adr = a - read_byte_ind_x());
00544                         c_flag = adr < 0x100;
00545                         ENDOP(6);
00546 
00547                 case 0xd1:      // CMP (ind),Y
00548                         set_nz(adr = a - read_byte_ind_y());
00549                         c_flag = adr < 0x100;
00550                         ENDOP(5);
00551 
00552                 case 0xe0:      // CPX #imm
00553                         set_nz(adr = x - read_byte_imm());
00554                         c_flag = adr < 0x100;
00555                         ENDOP(2);
00556 
00557                 case 0xe4:      // CPX zero
00558                         set_nz(adr = x - read_byte_zero());
00559                         c_flag = adr < 0x100;
00560                         ENDOP(3);
00561 
00562                 case 0xec:      // CPX abs
00563                         set_nz(adr = x - read_byte_abs());
00564                         c_flag = adr < 0x100;
00565                         ENDOP(4);
00566 
00567                 case 0xc0:      // CPY #imm
00568                         set_nz(adr = y - read_byte_imm());
00569                         c_flag = adr < 0x100;
00570                         ENDOP(2);
00571 
00572                 case 0xc4:      // CPY zero
00573                         set_nz(adr = y - read_byte_zero());
00574                         c_flag = adr < 0x100;
00575                         ENDOP(3);
00576 
00577                 case 0xcc:      // CPY abs
00578                         set_nz(adr = y - read_byte_abs());
00579                         c_flag = adr < 0x100;
00580                         ENDOP(4);
00581 
00582 
00583                 // Bit-test group
00584                 case 0x24:      // BIT zero
00585                         z_flag = a & (tmp = read_byte_zero());
00586                         n_flag = tmp;
00587 //                      v_flag = tmp & 0x40;
00588                         v_flag = BOOL_BIT(tmp, 0x40);   //AEH 991113
00589                         ENDOP(3);
00590 
00591                 case 0x2c:      // BIT abs
00592                         z_flag = a & (tmp = read_byte_abs());
00593                         n_flag = tmp;
00594 //                      v_flag = tmp & 0x40;
00595                         v_flag = BOOL_BIT(tmp,0x40);    //AEH 991113
00596                         ENDOP(4);
00597 
00598 
00599                 // Shift/rotate group
00600                 case 0x0a:      // ASL A
00601 //                      c_flag = a & 0x80;
00602                         c_flag = BOOL_BIT(a, 0x80);     //AEH 991113
00603                         set_nz(a <<= 1);
00604                         ENDOP(2);
00605 
00606                 case 0x06:      // ASL zero
00607                         tmp = read_zp(adr = read_adr_zero());
00608 //                      c_flag = tmp & 0x80;
00609                         c_flag = BOOL_BIT(tmp, 0x80);   //AEH 991113
00610                         write_zp(adr, set_nz(tmp << 1));
00611                         ENDOP(5);
00612 
00613                 case 0x16:      // ASL zero,X
00614                         tmp = read_zp(adr = read_adr_zero_x());
00615 //                      c_flag = tmp & 0x80;
00616                         c_flag = BOOL_BIT(tmp, 0x80);   //AEH 991113
00617                         write_zp(adr, set_nz(tmp << 1));
00618                         ENDOP(6);
00619 
00620                 case 0x0e:      // ASL abs
00621                         tmp = read_byte(adr = read_adr_abs());
00622 //                      c_flag = tmp & 0x80;
00623                         c_flag = BOOL_BIT(tmp, 0x80);   //AEH 991113
00624                         write_byte(adr, set_nz(tmp << 1));
00625                         ENDOP(6);
00626 
00627                 case 0x1e:      // ASL abs,X
00628                         tmp = read_byte(adr = read_adr_abs_x());
00629 //                      c_flag = tmp & 0x80;
00630                         c_flag = BOOL_BIT(tmp, 0x80);   //AEH 991113
00631                         write_byte(adr, set_nz(tmp << 1));
00632                         ENDOP(7);
00633 
00634                 case 0x4a:      // LSR A
00635                         c_flag = a & 0x01;
00636                         set_nz(a >>= 1);
00637                         ENDOP(2);
00638 
00639                 case 0x46:      // LSR zero
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:      // LSR zero,X
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:      // LSR abs
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:      // LSR abs,X
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:      // ROL A
00664 //                      tmp2 = a & 0x80;
00665                         tmpb = BOOL_BIT(a, 0x80);       //AEH 991113
00666                         set_nz(a = c_flag ? (a << 1) | 0x01 : a << 1);
00667                         c_flag = tmpb;
00668                         ENDOP(2);
00669 
00670                 case 0x26:      // ROL zero
00671                         tmp = read_zp(adr = read_adr_zero());
00672 //                      tmp2 = tmp & 0x80;
00673                         tmpb = BOOL_BIT(tmp, 0x80);     //AEH 991113
00674                         write_zp(adr, set_nz(c_flag ? (tmp << 1) | 0x01 : tmp << 1));
00675                         c_flag = tmpb;
00676                         ENDOP(5);
00677 
00678                 case 0x36:      // ROL zero,X
00679                         tmp = read_zp(adr = read_adr_zero_x());
00680 //                      tmp2 = tmp & 0x80;
00681                         tmpb = BOOL_BIT(tmp, 0x80);     //AEH 991113
00682                         write_zp(adr, set_nz(c_flag ? (tmp << 1) | 0x01 : tmp << 1));
00683                         c_flag = tmpb;
00684                         ENDOP(6);
00685 
00686                 case 0x2e:      // ROL abs
00687                         tmp = read_byte(adr = read_adr_abs());
00688 //                      tmp2 = tmp & 0x80;
00689                         tmpb = BOOL_BIT(tmp, 0x80);     //AEH 991113
00690                         write_byte(adr, set_nz(c_flag ? (tmp << 1) | 0x01 : tmp << 1));
00691                         c_flag = tmpb;
00692                         ENDOP(6);
00693 
00694                 case 0x3e:      // ROL abs,X
00695                         tmp = read_byte(adr = read_adr_abs_x());
00696 //                      tmp2 = tmp & 0x80;
00697                         tmpb = BOOL_BIT(tmp, 0x80);     //AEH 991113
00698                         write_byte(adr, set_nz(c_flag ? (tmp << 1) | 0x01 : tmp << 1));
00699                         c_flag = tmpb;
00700                         ENDOP(7);
00701 
00702                 case 0x6a:      // ROR A
00703 //                      tmp2 = a & 0x01;
00704                         tmpb = BOOL_BIT(a, 0x01);       //AEH 991113
00705                         set_nz(a = (c_flag ? (a >> 1) | 0x80 : a >> 1));
00706                         c_flag = tmpb;
00707                         ENDOP(2);
00708 
00709                 case 0x66:      // ROR zero
00710                         tmp = read_zp(adr = read_adr_zero());
00711 //                      tmp2 = tmp & 0x01;
00712                         tmpb = BOOL_BIT(tmp, 0x01);     //AEH 991113
00713                         write_zp(adr, set_nz(c_flag ? (tmp >> 1) | 0x80 : tmp >> 1));
00714                         c_flag = tmpb;
00715                         ENDOP(5);
00716 
00717                 case 0x76:      // ROR zero,X
00718                         tmp = read_zp(adr = read_adr_zero_x());
00719 //                      tmp2 = tmp & 0x01;
00720                         tmpb = BOOL_BIT(tmp, 0x01);     //AEH 991113
00721                         write_zp(adr, set_nz(c_flag ? (tmp >> 1) | 0x80 : tmp >> 1));
00722                         c_flag = tmpb;
00723                         ENDOP(6);
00724 
00725                 case 0x6e:      // ROR abs
00726                         tmp = read_byte(adr = read_adr_abs());
00727 //                      tmp2 = tmp & 0x01;
00728                         tmpb = BOOL_BIT(tmp, 0x01);     //AEH 991113
00729                         write_byte(adr, set_nz(c_flag ? (tmp >> 1) | 0x80 : tmp >> 1));
00730                         c_flag = tmpb;
00731                         ENDOP(6);
00732 
00733                 case 0x7e:      // ROR abs,X
00734                         tmp = read_byte(adr = read_adr_abs_x());
00735 //                      tmp2 = tmp & 0x01;
00736                         tmpb = BOOL_BIT(tmp, 0x01);     //AEH 991113
00737                         write_byte(adr, set_nz(c_flag ? (tmp >> 1) | 0x80 : tmp >> 1));
00738                         c_flag = tmpb;
00739                         ENDOP(7);
00740 
00741 
00742                 // Stack group
00743                 case 0x48:      // PHA
00744                         push_byte(a);
00745                         ENDOP(3);
00746 
00747                 case 0x68:      // PLA
00748                         set_nz(a = pop_byte());
00749                         ENDOP(4);
00750 
00751                 case 0x08:      // PHP
00752                         push_flags(true);
00753                         ENDOP(3);
00754 
00755                 case 0x28:      // PLP
00756                         pop_flags();
00757                         if (interrupt.intr_any && !i_flag)
00758                                 goto handle_int;
00759                         ENDOP(4);
00760 
00761 
00762                 // Jump/branch group
00763                 case 0x4c:      // JMP abs
00764                         jump(read_adr_abs());
00765                         ENDOP(3);
00766 
00767                 case 0x6c:      // JMP (ind)
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:      // JSR abs
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:      // RTS
00782                         adr = pop_byte();       // Split because of pop_byte ++sp side-effect
00783                         jump((adr | pop_byte() << 8) + 1);
00784                         ENDOP(6);
00785 
00786                 case 0x40:      // RTI
00787                         pop_flags();
00788                         adr = pop_byte();       // Split because of pop_byte ++sp side-effect
00789                         jump(adr | pop_byte() << 8);
00790                         if (interrupt.intr_any && !i_flag)
00791                                 goto handle_int;
00792                         ENDOP(6);
00793 
00794                 case 0x00:      // BRK
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:      // BCS rel
00846                         Branch(c_flag);
00847 
00848                 case 0x90:      // BCC rel
00849                         Branch(!c_flag);
00850 
00851                 case 0xf0:      // BEQ rel
00852                         Branch(!z_flag);
00853 
00854                 case 0xd0:      // BNE rel
00855                         Branch(z_flag);
00856 
00857                 case 0x70:      // BVS rel
00858 #ifndef IS_CPU_1541
00859                         Branch(v_flag);
00860 #else
00861                         Branch((via2_pcr & 0x0e) == 0x0e ? 1 : v_flag); // GCR byte ready flag
00862 #endif
00863 
00864                 case 0x50:      // BVC rel
00865 #ifndef IS_CPU_1541
00866                         Branch(!v_flag);
00867 #else
00868                         Branch(!((via2_pcr & 0x0e) == 0x0e) ? 0 : v_flag);      // GCR byte ready flag
00869 #endif
00870 
00871                 case 0x30:      // BMI rel
00872                         Branch(n_flag & 0x80);
00873 
00874                 case 0x10:      // BPL rel
00875                         Branch(!(n_flag & 0x80));
00876 
00877 
00878                 // Flags group
00879                 case 0x38:      // SEC
00880                         c_flag = true;
00881                         ENDOP(2);
00882 
00883                 case 0x18:      // CLC
00884                         c_flag = false;
00885                         ENDOP(2);
00886 
00887                 case 0xf8:      // SED
00888                         d_flag = true;
00889                         ENDOP(2);
00890 
00891                 case 0xd8:      // CLD
00892                         d_flag = false;
00893                         ENDOP(2);
00894 
00895                 case 0x78:      // SEI
00896                         i_flag = true;
00897                         ENDOP(2);
00898 
00899                 case 0x58:      // CLI
00900                         i_flag = false;
00901                         if (interrupt.intr_any)
00902                                 goto handle_int;
00903                         ENDOP(2);
00904 
00905                 case 0xb8:      // CLV
00906                         v_flag = false;
00907                         ENDOP(2);
00908 
00909 
00910                 // NOP group
00911                 case 0xea:      // NOP
00912                         ENDOP(2);
00913 
00914 
00915 /*
00916  * Undocumented opcodes start here
00917  */
00918 
00919                 // NOP group
00920                 case 0x1a:      // NOP
00921                 case 0x3a:
00922                 case 0x5a:
00923                 case 0x7a:
00924                 case 0xda:
00925                 case 0xfa:
00926                         ENDOP(2);
00927 
00928                 case 0x80:      // NOP #imm
00929                 case 0x82:
00930                 case 0x89:
00931                 case 0xc2:
00932                 case 0xe2:
00933                         pc++;
00934                         ENDOP(2);
00935 
00936                 case 0x04:      // NOP zero
00937                 case 0x44:
00938                 case 0x64:
00939                         pc++;
00940                         ENDOP(3);
00941 
00942                 case 0x14:      // NOP zero,X
00943                 case 0x34:
00944                 case 0x54:
00945                 case 0x74:
00946                 case 0xd4:
00947                 case 0xf4:
00948                         pc++;
00949                         ENDOP(4);
00950 
00951                 case 0x0c:      // NOP abs
00952                         pc+=2;
00953                         ENDOP(4);
00954 
00955                 case 0x1c:      // NOP abs,X
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                 // Load A/X group
00970                 case 0xa7:      // LAX zero
00971                         set_nz(a = x = read_byte_zero());
00972                         ENDOP(3);
00973 
00974                 case 0xb7:      // LAX zero,Y
00975                         set_nz(a = x = read_byte_zero_y());
00976                         ENDOP(4);
00977 
00978                 case 0xaf:      // LAX abs
00979                         set_nz(a = x = read_byte_abs());
00980                         ENDOP(4);
00981 
00982                 case 0xbf:      // LAX abs,Y
00983                         set_nz(a = x = read_byte_abs_y());
00984                         ENDOP(4);
00985 
00986                 case 0xa3:      // LAX (ind,X)
00987                         set_nz(a = x = read_byte_ind_x());
00988                         ENDOP(6);
00989 
00990                 case 0xb3:      // LAX (ind),Y
00991                         set_nz(a = x = read_byte_ind_y());
00992                         ENDOP(5);
00993 
00994 
00995                 // Store A/X group
00996                 case 0x87:      // SAX zero
00997                         write_byte(read_adr_zero(), a & x);
00998                         ENDOP(3);
00999 
01000                 case 0x97:      // SAX zero,Y
01001                         write_byte(read_adr_zero_y(), a & x);
01002                         ENDOP(4);
01003 
01004                 case 0x8f:      // SAX abs
01005                         write_byte(read_adr_abs(), a & x);
01006                         ENDOP(4);
01007 
01008                 case 0x83:      // SAX (ind,X)
01009                         write_byte(read_adr_ind_x(), a & x);
01010                         ENDOP(6);
01011 
01012 
01013                 // ASL/ORA group
01014 #define ShiftLeftOr \
01015         c_flag = BOOL_BIT(tmp, 0x80); \
01016         tmp <<= 1; \
01017         set_nz(a |= tmp);
01018 
01019                 case 0x07:      // SLO zero
01020                         tmp = read_zp(adr = read_adr_zero());
01021                         ShiftLeftOr;
01022                         write_zp(adr, tmp);
01023                         ENDOP(5);
01024 
01025                 case 0x17:      // SLO zero,X
01026                         tmp = read_zp(adr = read_adr_zero_x());
01027                         ShiftLeftOr;
01028                         write_zp(adr, tmp);
01029                         ENDOP(6);
01030 
01031                 case 0x0f:      // SLO abs
01032                         tmp = read_byte(adr = read_adr_abs());
01033                         ShiftLeftOr;
01034                         write_byte(adr, tmp);
01035                         ENDOP(6);
01036 
01037                 case 0x1f:      // SLO abs,X
01038                         tmp = read_byte(adr = read_adr_abs_x());
01039                         ShiftLeftOr;
01040                         write_byte(adr, tmp);
01041                         ENDOP(7);
01042 
01043                 case 0x1b:      // SLO abs,Y
01044                         tmp = read_byte(adr = read_adr_abs_y());
01045                         ShiftLeftOr;
01046                         write_byte(adr, tmp);
01047                         ENDOP(7);
01048 
01049                 case 0x03:      // SLO (ind,X)
01050                         tmp = read_byte(adr = read_adr_ind_x());
01051                         ShiftLeftOr;
01052                         write_byte(adr, tmp);
01053                         ENDOP(8);
01054 
01055                 case 0x13:      // SLO (ind),Y
01056                         tmp = read_byte(adr = read_adr_ind_y());
01057                         ShiftLeftOr;
01058                         write_byte(adr, tmp);
01059                         ENDOP(8);
01060 
01061 
01062                 // ROL/AND group
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:      // RLA zero
01070                         tmp = read_zp(adr = read_adr_zero());
01071                         RoLeftAnd;
01072                         write_zp(adr, tmp);
01073                         ENDOP(5);
01074 
01075                 case 0x37:      // RLA zero,X
01076                         tmp = read_zp(adr = read_adr_zero_x());
01077                         RoLeftAnd;
01078                         write_zp(adr, tmp);
01079                         ENDOP(6);
01080 
01081                 case 0x2f:      // RLA abs
01082                         tmp = read_byte(adr = read_adr_abs());
01083                         RoLeftAnd;
01084                         write_byte(adr, tmp);
01085                         ENDOP(6);
01086 
01087                 case 0x3f:      // RLA abs,X
01088                         tmp = read_byte(adr = read_adr_abs_x());
01089                         RoLeftAnd;
01090                         write_byte(adr, tmp);
01091                         ENDOP(7);
01092 
01093                 case 0x3b:      // RLA abs,Y
01094                         tmp = read_byte(adr = read_adr_abs_y());
01095                         RoLeftAnd;
01096                         write_byte(adr, tmp);
01097                         ENDOP(7);
01098 
01099                 case 0x23:      // RLA (ind,X)
01100                         tmp = read_byte(adr = read_adr_ind_x());
01101                         RoLeftAnd;
01102                         write_byte(adr, tmp);
01103                         ENDOP(8);
01104 
01105                 case 0x33:      // RLA (ind),Y
01106                         tmp = read_byte(adr = read_adr_ind_y());
01107                         RoLeftAnd;
01108                         write_byte(adr, tmp);
01109                         ENDOP(8);
01110 
01111 
01112                 // LSR/EOR group
01113 #define ShiftRightEor \
01114         c_flag = tmp & 0x01; \
01115         tmp >>= 1; \
01116         set_nz(a ^= tmp);
01117 
01118                 case 0x47:      // SRE zero
01119                         tmp = read_zp(adr = read_adr_zero());
01120                         ShiftRightEor;
01121                         write_zp(adr, tmp);
01122                         ENDOP(5);
01123 
01124                 case 0x57:      // SRE zero,X
01125                         tmp = read_zp(adr = read_adr_zero_x());
01126                         ShiftRightEor;
01127                         write_zp(adr, tmp);
01128                         ENDOP(6);
01129 
01130                 case 0x4f:      // SRE abs
01131                         tmp = read_byte(adr = read_adr_abs());
01132                         ShiftRightEor;
01133                         write_byte(adr, tmp);
01134                         ENDOP(6);
01135 
01136                 case 0x5f:      // SRE abs,X
01137                         tmp = read_byte(adr = read_adr_abs_x());
01138                         ShiftRightEor;
01139                         write_byte(adr, tmp);
01140                         ENDOP(7);
01141 
01142                 case 0x5b:      // SRE abs,Y
01143                         tmp = read_byte(adr = read_adr_abs_y());
01144                         ShiftRightEor;
01145                         write_byte(adr, tmp);
01146                         ENDOP(7);
01147 
01148                 case 0x43:      // SRE (ind,X)
01149                         tmp = read_byte(adr = read_adr_ind_x());
01150                         ShiftRightEor;
01151                         write_byte(adr, tmp);
01152                         ENDOP(8);
01153 
01154                 case 0x53:      // SRE (ind),Y
01155                         tmp = read_byte(adr = read_adr_ind_y());
01156                         ShiftRightEor;
01157                         write_byte(adr, tmp);
01158                         ENDOP(8);
01159 
01160 
01161                 // ROR/ADC group
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:      // RRA zero
01169                         tmp = read_zp(adr = read_adr_zero());
01170                         RoRightAdc;
01171                         write_zp(adr, tmp);
01172                         ENDOP(5);
01173 
01174                 case 0x77:      // RRA zero,X
01175                         tmp = read_zp(adr = read_adr_zero_x());
01176                         RoRightAdc;
01177                         write_zp(adr, tmp);
01178                         ENDOP(6);
01179 
01180                 case 0x6f:      // RRA abs
01181                         tmp = read_byte(adr = read_adr_abs());
01182                         RoRightAdc;
01183                         write_byte(adr, tmp);
01184                         ENDOP(6);
01185 
01186                 case 0x7f:      // RRA abs,X
01187                         tmp = read_byte(adr = read_adr_abs_x());
01188                         RoRightAdc;
01189                         write_byte(adr, tmp);
01190                         ENDOP(7);
01191 
01192                 case 0x7b:      // RRA abs,Y
01193                         tmp = read_byte(adr = read_adr_abs_y());
01194                         RoRightAdc;
01195                         write_byte(adr, tmp);
01196                         ENDOP(7);
01197 
01198                 case 0x63:      // RRA (ind,X)
01199                         tmp = read_byte(adr = read_adr_ind_x());
01200                         RoRightAdc;
01201                         write_byte(adr, tmp);
01202                         ENDOP(8);
01203 
01204                 case 0x73:      // RRA (ind),Y
01205                         tmp = read_byte(adr = read_adr_ind_y());
01206                         RoRightAdc;
01207                         write_byte(adr, tmp);
01208                         ENDOP(8);
01209 
01210 
01211                 // DEC/CMP group
01212 #define DecCompare \
01213         set_nz(adr = a - tmp); \
01214         c_flag = adr < 0x100;
01215 
01216                 case 0xc7:      // DCP zero
01217                         tmp = read_zp(adr = read_adr_zero()) - 1;
01218                         write_zp(adr, tmp);
01219                         DecCompare;
01220                         ENDOP(5);
01221 
01222                 case 0xd7:      // DCP zero,X
01223                         tmp = read_zp(adr = read_adr_zero_x()) - 1;
01224                         write_zp(adr, tmp);
01225                         DecCompare;
01226                         ENDOP(6);
01227 
01228                 case 0xcf:      // DCP abs
01229                         tmp = read_byte(adr = read_adr_abs()) - 1;
01230                         write_byte(adr, tmp);
01231                         DecCompare;
01232                         ENDOP(6);
01233 
01234                 case 0xdf:      // DCP abs,X
01235                         tmp = read_byte(adr = read_adr_abs_x()) - 1;
01236                         write_byte(adr, tmp);
01237                         DecCompare;
01238                         ENDOP(7);
01239 
01240                 case 0xdb:      // DCP abs,Y
01241                         tmp = read_byte(adr = read_adr_abs_y()) - 1;
01242                         write_byte(adr, tmp);
01243                         DecCompare;
01244                         ENDOP(7);
01245 
01246                 case 0xc3:      // DCP (ind,X)
01247                         tmp = read_byte(adr = read_adr_ind_x()) - 1;
01248                         write_byte(adr, tmp);
01249                         DecCompare;
01250                         ENDOP(8);
01251 
01252                 case 0xd3:      // DCP (ind),Y
01253                         tmp = read_byte(adr = read_adr_ind_y()) - 1;
01254                         write_byte(adr, tmp);
01255                         DecCompare;
01256                         ENDOP(8);
01257 
01258 
01259                 // INC/SBC group
01260                 case 0xe7:      // ISB zero
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:      // ISB zero,X
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:      // ISB abs
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:      // ISB abs,X
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:      // ISB abs,Y
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:      // ISB (ind,X)
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:      // ISB (ind),Y
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                 // Complex functions
01304                 case 0x0b:      // ANC #imm
01305                 case 0x2b:
01306                         set_nz(a &= read_byte_imm());
01307 //                      c_flag = n_flag & 0x80;
01308                         c_flag = BOOL_BIT(n_flag, 0x80);        //AEH 991113
01309                         ENDOP(2);
01310 
01311                 case 0x4b:      // ASR #imm
01312                         a &= read_byte_imm();
01313 //                      c_flag = a & 0x01;
01314                         c_flag = BOOL_BIT(a, 0x01);     //AEH 991113
01315                         set_nz(a >>= 1);
01316                         ENDOP(2);
01317 
01318                 case 0x6b:      // ARR #imm
01319                         tmp2 = read_byte_imm() & a;
01320                         a = (c_flag ? (tmp2 >> 1) | 0x80 : tmp2 >> 1);
01321                         if (!d_flag) {
01322                                 set_nz(a);
01323 //                              c_flag = a & 0x40;
01324                                 c_flag = BOOL_BIT(a, 0x40);     //AEH 991113
01325 //                              v_flag = (a & 0x40) ^ ((a & 0x20) << 1);
01326                                 v_flag = (((a & 0x40) ^ ((a & 0x20) << 1)) == 0x40);    //AEH 991113
01327                         } else {
01328                                 n_flag = c_flag ? 0x80 : 0;
01329                                 z_flag = a;
01330 //                              v_flag = (tmp2 ^ a) & 0x40;
01331                                 v_flag = (((tmp2 ^ a) & 0x40) == 0x40); //AEH 991113
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:      // ANE #imm
01340                         set_nz(a = read_byte_imm() & x & (a | 0xee));
01341                         ENDOP(2);
01342 
01343                 case 0x93:      // SHA (ind),Y
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:      // SHS abs,Y
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:      // SHY abs,X
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:      // SHX abs,Y
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:      // SHA abs,Y
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:      // LXA #imm
01390                         set_nz(a = x = (a | 0xee) & read_byte_imm());
01391                         ENDOP(2);
01392 
01393                 case 0xbb:      // LAS abs,Y
01394                         set_nz(a = x = sp = read_byte_abs_y() & sp);
01395                         ENDOP(4);
01396 
01397                 case 0xcb:      // SBX #imm
01398                         x &= a;
01399                         adr = x - read_byte_imm();
01400                         c_flag = adr < 0x100;
01401 //                      set_nz(x = adr);
01402                         set_nz(x = (uint8)adr); //AEH 991113
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;

Generated on Tue Feb 8 04:07:37 2005 for E32frodo by doxygen 1.3.3