git.sur5r.net Git - cc65/blob - src/sim65/cpucore.c

   1 /*****************************************************************************/
   2 /*                                                                           */
   3 /*                                   cpucore.c                               */
   4 /*                                                                           */
   5 /*                        CPU core for the 6502 simulator                    */
   6 /*                                                                           */
   7 /*                                                                           */
   8 /*                                                                           */
   9 /* (C) 2002      Ullrich von Bassewitz                                       */
  10 /*               Wacholderweg 14                                             */
  11 /*               D-70597 Stuttgart                                           */
  12 /* EMail:        uz@cc65.org                                                 */
  13 /*                                                                           */
  14 /*                                                                           */
  15 /* This software is provided 'as-is', without any expressed or implied       */
  16 /* warranty.  In no event will the authors be held liable for any damages    */
  17 /* arising from the use of this software.                                    */
  18 /*                                                                           */
  19 /* Permission is granted to anyone to use this software for any purpose,     */
  20 /* including commercial applications, and to alter it and redistribute it    */
  21 /* freely, subject to the following restrictions:                            */
  22 /*                                                                           */
  23 /* 1. The origin of this software must not be misrepresented; you must not   */
  24 /*    claim that you wrote the original software. If you use this software   */
  25 /*    in a product, an acknowledgment in the product documentation would be  */
  26 /*    appreciated but is not required.                                       */
  27 /* 2. Altered source versions must be plainly marked as such, and must not   */
  28 /*    be misrepresented as being the original software.                      */
  29 /* 3. This notice may not be removed or altered from any source              */
  30 /*    distribution.                                                          */
  31 /*                                                                           */
  32 /*****************************************************************************/
  33
  34
  35
  36 #include <stdlib.h>
  37
  38 /* common */
  39 #include "abend.h"
  40 #include "print.h"
  41
  42 /* sim65 */
  43 #include "cputype.h"
  44 #include "global.h"
  45 #include "memory.h"
  46 #include "cpucore.h"
  47
  48
  49
  50 /*****************************************************************************/
  51 /*                                   Data                                    */
  52 /*****************************************************************************/
  53
  54
  55
  56 /* Registers */
  57 unsigned char   AC;             /* Accumulator */
  58 unsigned char   XR;             /* X register */
  59 unsigned char   YR;             /* Y register */
  60 unsigned char   SR;             /* Status register */
  61 unsigned char   SP;             /* Stackpointer */
  62 unsigned        PC;             /* Program counter */
  63
  64 /* Count the total number of cylcles */
  65 unsigned        Cycles;         /* Cycles per insn */
  66 unsigned long   TotalCycles;    /* Total cycles */
  67
  68 /* Allow the stack page to be changed */
  69 static unsigned StackPage = 0x100;
  70
  71 /* Status register bits */
  72 #define CF      0x01            /* Carry flag */
  73 #define ZF      0x02            /* Zero flag */
  74 #define IF      0x04            /* Interrupt flag */
  75 #define DF      0x08            /* Decimal flag */
  76 #define BF      0x10            /* Break flag */
  77 #define OF      0x40            /* Overflow flag */
  78 #define SF      0x80            /* Sign flag */
  79
  80 /* */
  81 int CPUHalted;
  82
  83
  84
  85 /*****************************************************************************/
  86 /*                        Helper functions and macros                        */
  87 /*****************************************************************************/
  88
  89
  90
  91 /* Return the flags as a boolean value */
  92 #define GET_CF()        ((SR & CF) != 0)
  93 #define GET_ZF()        ((SR & ZF) != 0)
  94 #define GET_IF()        ((SR & IF) != 0)
  95 #define GET_DF()        ((SR & DF) != 0)
  96 #define GET_BF()        ((SR & BF) != 0)
  97 #define GET_OF()        ((SR & OF) != 0)
  98 #define GET_SF()        ((SR & SF) != 0)
  99
 100 /* Set the flags. The parameter is a boolean flag that says if the flag should be
 101  * set or reset.
 102  */
 103 #define SET_CF(f)       do { if (f) { SR |= CF; } else { SR &= ~CF; } } while (0)
 104 #define SET_ZF(f)       do { if (f) { SR |= ZF; } else { SR &= ~ZF; } } while (0)
 105 #define SET_IF(f)       do { if (f) { SR |= IF; } else { SR &= ~IF; } } while (0)
 106 #define SET_DF(f)       do { if (f) { SR |= DF; } else { SR &= ~DF; } } while (0)
 107 #define SET_BF(f)       do { if (f) { SR |= BF; } else { SR &= ~BF; } } while (0)
 108 #define SET_OF(f)       do { if (f) { SR |= OF; } else { SR &= ~OF; } } while (0)
 109 #define SET_SF(f)       do { if (f) { SR |= SF; } else { SR &= ~SF; } } while (0)
 110
 111 /* Special test and set macros. The meaning of the parameter depends on the
 112  * actual flag that should be set or reset.
 113  */
 114 #define TEST_ZF(v)      SET_ZF (((v) & 0xFF) == 0)
 115 #define TEST_SF(v)      SET_SF (((v) & 0x80) != 0)
 116 #define TEST_CF(v)      SET_CF (((v) & 0xFF00) != 0)
 117
 118 /* Program counter halves */
 119 #define PCL             (PC & 0xFF)
 120 #define PCH             ((PC >> 8) & 0xFF)
 121
 122 /* Stack operations */
 123 #define PUSH(Val)       WriteMem (StackPage + SP--, Val)
 124 #define POP()           ReadMem (StackPage + ++SP)
 125
 126 /* Test for page cross */
 127 #define PAGE_CROSS(addr,offs)   ((((addr) & 0xFF) + offs) >= 0x100)
 128
 129 /* #imm */
 130 #define AC_OP_IMM(op)                           \
 131     Cycles = 2;                                 \
 132     AC = AC op ReadMem (PC+1);                  \
 133     TEST_ZF (AC);                               \
 134     TEST_SF (AC);                               \
 135     PC += 2
 136
 137 /* zp */
 138 #define AC_OP_ZP(op)                            \
 139     Cycles = 3;                                 \
 140     AC = AC op ReadMem (ReadMem (PC+1));        \
 141     TEST_ZF (AC);                               \
 142     TEST_SF (AC);                               \
 143     PC += 2
 144
 145 /* zp,x */
 146 #define AC_OP_ZPX(op)                           \
 147     unsigned char ZPAddr;                       \
 148     Cycles = 4;                                 \
 149     ZPAddr = ReadMem (PC+1) + XR;               \
 150     AC = AC op ReadMem (ZPAddr);                \
 151     TEST_ZF (AC);                               \
 152     TEST_SF (AC);                               \
 153     PC += 2
 154
 155 /* zp,y */
 156 #define AC_OP_ZPY(op)                           \
 157     unsigned char ZPAddr;                       \
 158     Cycles = 4;                                 \
 159     ZPAddr = ReadMem (PC+1) + YR;               \
 160     AC = AC op ReadMem (ZPAddr);                \
 161     TEST_ZF (AC);                               \
 162     TEST_SF (AC);                               \
 163     PC += 2
 164
 165 /* abs */
 166 #define AC_OP_ABS(op)                           \
 167     unsigned Addr;                              \
 168     Cycles = 4;                                 \
 169     Addr = ReadMemW (PC+1);                     \
 170     AC = AC op ReadMem (Addr);                  \
 171     TEST_ZF (AC);                               \
 172     TEST_SF (AC);                               \
 173     PC += 3
 174
 175 /* abs,x */
 176 #define AC_OP_ABSX(op)                          \
 177     unsigned Addr;                              \
 178     Cycles = 4;                                 \
 179     Addr = ReadMemW (PC+1);                     \
 180     if (PAGE_CROSS (Addr, XR)) {                \
 181         ++Cycles;                               \
 182     }                                           \
 183     AC = AC | ReadMem (Addr + XR);              \
 184     TEST_ZF (AC);                               \
 185     TEST_SF (AC);                               \
 186     PC += 3
 187
 188 /* abs,y */
 189 #define AC_OP_ABSY(op)                          \
 190     unsigned Addr;                              \
 191     Cycles = 4;                                 \
 192     Addr = ReadMemW (PC+1);                     \
 193     if (PAGE_CROSS (Addr, YR)) {                \
 194         ++Cycles;                               \
 195     }                                           \
 196     AC = AC | ReadMem (Addr + YR);              \
 197     TEST_ZF (AC);                               \
 198     TEST_SF (AC);                               \
 199     PC += 3
 200
 201 /* (zp,x) */
 202 #define AC_OP_ZPXIND(op)                        \
 203     unsigned char ZPAddr;                       \
 204     unsigned Addr;                              \
 205     Cycles = 6;                                 \
 206     ZPAddr = ReadMem (PC+1) + XR;               \
 207     Addr = ReadZeroPageW (ZPAddr);              \
 208     AC = AC op ReadMem (Addr);                  \
 209     TEST_ZF (AC);                               \
 210     TEST_SF (AC);                               \
 211     PC += 2
 212
 213 /* (zp),y */
 214 #define AC_OP_ZPINDY(op)                        \
 215     unsigned char ZPAddr;                       \
 216     unsigned Addr;                              \
 217     Cycles = 5;                                 \
 218     ZPAddr = ReadMem (PC+1);                    \
 219     Addr = ReadZeroPageW (ZPAddr) + YR;         \
 220     AC = AC op ReadMem (Addr);                  \
 221     TEST_ZF (AC);                               \
 222     TEST_SF (AC);                               \
 223     PC += 2
 224
 225 /* branches */
 226 #define BRANCH(cond)                            \
 227     Cycles = 2;                                 \
 228     if (cond) {                                 \
 229         signed char Offs;                       \
 230         unsigned char OldPCH;                   \
 231         ++Cycles;                               \
 232         Offs = (signed char) ReadMem (PC+1);    \
 233         OldPCH = PCH;                           \
 234         PC += (int) Offs;                       \
 235         if (PCH != OldPCH) {                    \
 236             ++Cycles;                           \
 237         }                                       \
 238     } else {                                    \
 239         PC += 2;                                \
 240     }
 241
 242 /* compares */
 243 #define CMP(v1,v2)                              \
 244     {                                           \
 245         unsigned Result = v1 - v2;              \
 246         TEST_ZF (Result & 0xFF);                \
 247         TEST_SF (Result);                       \
 248         SET_CF (Result <= 0xFF);                \
 249     }
 250
 251
 252
 253 /*****************************************************************************/
 254 /*                               Helper functions                            */
 255 /*****************************************************************************/
 256
 257
 258
 259 static void Illegal (void)
 260 {
 261     fprintf (stderr, "Illegal: $%02X\n", ReadMem (PC));
 262     exit (EXIT_FAILURE);
 263 }
 264
 265
 266
 267 static void NotImplemented (void)
 268 {
 269     fprintf (stderr, "Not implemented: $%02X\n", ReadMem (PC));
 270     exit (EXIT_FAILURE);
 271 }
 272
 273
 274
 275 /*****************************************************************************/
 276 /*                                   Code                                    */
 277 /*****************************************************************************/
 278
 279
 280
 281 static void OPC_6502_00 (void)
 282 /* Opcode $00: BRK */
 283 {
 284     Cycles = 7;
 285     PC += 2;
 286     SET_BF (1);
 287     PUSH (PCH);
 288     PUSH (PCL);
 289     PUSH (SR);
 290     SET_IF (1);
 291     PC = ReadMemW (0xFFFE);
 292 }
 293
 294
 295
 296 static void OPC_6502_01 (void)
 297 /* Opcode $01: ORA (ind,x) */
 298 {
 299     AC_OP_ZPXIND (|);
 300 }
 301
 302
 303
 304 static void OPC_6502_02 (void)
 305 /* Opcode $02 */
 306 {
 307     Illegal ();
 308 }
 309
 310
 311
 312 static void OPC_6502_03 (void)
 313 /* Opcode $03 */
 314 {
 315     Illegal ();
 316 }
 317
 318
 319
 320 static void OPC_6502_04 (void)
 321 /* Opcode $04 */
 322 {
 323     Illegal ();
 324 }
 325
 326
 327
 328 static void OPC_6502_05 (void)
 329 /* Opcode $05: ORA zp */
 330 {
 331     AC_OP_ZP (|);
 332 }
 333
 334
 335
 336 static void OPC_6502_06 (void)
 337 /* Opcode $06: ASL zp */
 338 {
 339     unsigned char ZPAddr;
 340     unsigned Val;
 341     Cycles = 5;
 342     ZPAddr = ReadMem (PC+1);
 343     Val    = ReadMem (ZPAddr) << 1;
 344     WriteMem (ZPAddr, (unsigned char) Val);
 345     TEST_ZF (Val & 0xFF);
 346     TEST_SF (Val);
 347     SET_CF (Val & 0x100);
 348     PC += 2;
 349 }
 350
 351
 352
 353 static void OPC_6502_07 (void)
 354 /* Opcode $07 */
 355 {
 356     Illegal ();
 357 }
 358
 359
 360
 361 static void OPC_6502_08 (void)
 362 /* Opcode $08: PHP */
 363 {
 364     Cycles = 3;
 365     PUSH (SR & ~BF);
 366     PC += 1;
 367 }
 368
 369
 370
 371 static void OPC_6502_09 (void)
 372 /* Opcode $09: ORA #imm */
 373 {
 374     AC_OP_IMM (|);
 375 }
 376
 377
 378
 379 static void OPC_6502_0A (void)
 380 /* Opcode $0A: ASL a */
 381 {
 382     unsigned Val;
 383     Cycles = 2;
 384     Val    = AC << 1;
 385     AC     = (unsigned char) Val;
 386     TEST_ZF (Val & 0xFF);
 387     TEST_SF (Val);
 388     SET_CF (Val & 0x100);
 389     PC += 1;
 390 }
 391
 392
 393
 394 static void OPC_6502_0B (void)
 395 /* Opcode $0B */
 396 {
 397     Illegal ();
 398 }
 399
 400
 401
 402 static void OPC_6502_0C (void)
 403 /* Opcode $0C */
 404 {
 405     Illegal ();
 406 }
 407
 408
 409
 410 static void OPC_6502_0D (void)
 411 /* Opcode $0D: ORA abs */
 412 {
 413     AC_OP_ABS (|);
 414 }
 415
 416
 417
 418 static void OPC_6502_0E (void)
 419 /* Opcode $0E: ALS abs */
 420 {
 421     unsigned Addr;
 422     unsigned Val;
 423     Cycles = 6;
 424     Addr = ReadMemW (PC+1);
 425     Val  = ReadMem (Addr) << 1;
 426     WriteMem (Addr, (unsigned char) Val);
 427     TEST_ZF (Val & 0xFF);
 428     TEST_SF (Val);
 429     SET_CF (Val & 0x100);
 430     PC += 3;
 431 }
 432
 433
 434
 435 static void OPC_6502_0F (void)
 436 /* Opcode $0F */
 437 {
 438     Illegal ();
 439 }
 440
 441
 442
 443 static void OPC_6502_10 (void)
 444 /* Opcode $10: BPL */
 445 {
 446     BRANCH (!GET_SF ());
 447 }
 448
 449
 450
 451 static void OPC_6502_11 (void)
 452 /* Opcode $11: ORA (zp),y */
 453 {
 454     AC_OP_ZPINDY (|);
 455 }
 456
 457
 458
 459 static void OPC_6502_12 (void)
 460 /* Opcode $12 */
 461 {
 462     Illegal ();
 463 }
 464
 465
 466
 467 static void OPC_6502_13 (void)
 468 /* Opcode $13 */
 469 {
 470     Illegal ();
 471 }
 472
 473
 474
 475 static void OPC_6502_14 (void)
 476 /* Opcode $14 */
 477 {
 478     Illegal ();
 479 }
 480
 481
 482
 483 static void OPC_6502_15 (void)
 484 /* Opcode $15: ORA zp,x */
 485 {
 486    AC_OP_ZPX (|);
 487 }
 488
 489
 490
 491 static void OPC_6502_16 (void)
 492 /* Opcode $16: ASL zp,x */
 493 {
 494     unsigned char ZPAddr;
 495     unsigned Val;
 496     Cycles = 6;
 497     ZPAddr = ReadMem (PC+1) + XR;
 498     Val    = ReadMem (ZPAddr) << 1;
 499     WriteMem (ZPAddr, (unsigned char) Val);
 500     TEST_ZF (Val & 0xFF);
 501     TEST_SF (Val);
 502     SET_CF (Val & 0x100);
 503     PC += 2;
 504 }
 505
 506
 507
 508 static void OPC_6502_17 (void)
 509 /* Opcode $17 */
 510 {
 511     Illegal ();
 512 }
 513
 514
 515
 516 static void OPC_6502_18 (void)
 517 /* Opcode $18: CLC */
 518 {
 519     Cycles = 2;
 520     SET_CF (0);
 521     PC += 1;
 522 }
 523
 524
 525
 526 static void OPC_6502_19 (void)
 527 /* Opcode $19: ORA abs,y */
 528 {
 529     AC_OP_ABSY (|);
 530 }
 531
 532
 533
 534 static void OPC_6502_1A (void)
 535 /* Opcode $1A */
 536 {
 537     Illegal ();
 538 }
 539
 540
 541
 542 static void OPC_6502_1B (void)
 543 /* Opcode $1B */
 544 {
 545     Illegal ();
 546 }
 547
 548
 549
 550 static void OPC_6502_1C (void)
 551 /* Opcode $1C */
 552 {
 553     Illegal ();
 554 }
 555
 556
 557
 558 static void OPC_6502_1D (void)
 559 /* Opcode $1D: ORA abs,x */
 560 {
 561     AC_OP_ABSX (|);
 562 }
 563
 564
 565
 566 static void OPC_6502_1E (void)
 567 /* Opcode $1E: ASL abs,x */
 568 {
 569     unsigned Addr;
 570     unsigned Val;
 571     Cycles = 7;
 572     Addr = ReadMemW (PC+1) + XR;
 573     Val  = ReadMem (Addr) << 1;
 574     WriteMem (Addr, (unsigned char) Val);
 575     TEST_ZF (Val & 0xFF);
 576     TEST_SF (Val);
 577     SET_CF (Val & 0x100);
 578     PC += 3;
 579 }
 580
 581
 582
 583 static void OPC_6502_1F (void)
 584 /* Opcode $1F */
 585 {
 586     Illegal ();
 587 }
 588
 589
 590
 591 static void OPC_6502_20 (void)
 592 /* Opcode $20: JSR */
 593 {
 594     unsigned Addr;
 595     Cycles = 6;
 596     Addr   = ReadMemW (PC+1);
 597     PC += 2;
 598     PUSH (PCH);
 599     PUSH (PCL);
 600     PC = Addr;
 601 }
 602
 603
 604
 605 static void OPC_6502_21 (void)
 606 /* Opcode $21: AND (zp,x) */
 607 {
 608     AC_OP_ZPXIND (&);
 609 }
 610
 611
 612
 613 static void OPC_6502_22 (void)
 614 /* Opcode $22 */
 615 {
 616     Illegal ();
 617 }
 618
 619
 620
 621 static void OPC_6502_23 (void)
 622 /* Opcode $23 */
 623 {
 624     Illegal ();
 625 }
 626
 627
 628
 629 static void OPC_6502_24 (void)
 630 /* Opcode $24: BIT zp */
 631 {
 632     unsigned char ZPAddr;
 633     unsigned char Val;
 634     Cycles = 3;
 635     ZPAddr = ReadMem (PC+1);
 636     Val    = ReadMem (ZPAddr);
 637     SET_SF (Val & 0x80);
 638     SET_OF (Val & 0x40);
 639     SET_ZF ((Val & AC) == 0);
 640     PC += 2;
 641 }
 642
 643
 644
 645 static void OPC_6502_25 (void)
 646 /* Opcode $25: AND zp */
 647 {
 648     AC_OP_ZP (&);
 649 }
 650
 651
 652
 653 static void OPC_6502_26 (void)
 654 /* Opcode $26: ROL zp */
 655 {
 656     unsigned char ZPAddr;
 657     unsigned Val;
 658     Cycles = 5;
 659     ZPAddr = ReadMem (PC+1);
 660     Val    = ReadMem (ZPAddr) << 1;
 661     if (GET_CF ()) {
 662         Val |= 0x01;
 663     }
 664     AC = (unsigned char) Val;
 665     TEST_ZF (AC);
 666     TEST_SF (AC);
 667     TEST_CF (Val);
 668     PC += 2;
 669 }
 670
 671
 672
 673 static void OPC_6502_27 (void)
 674 /* Opcode $27 */
 675 {
 676     Illegal ();
 677 }
 678
 679
 680
 681 static void OPC_6502_28 (void)
 682 /* Opcode $28: PLP */
 683 {
 684     Cycles = 4;
 685     SR = (POP () & ~BF);
 686     PC += 1;
 687 }
 688
 689
 690
 691 static void OPC_6502_29 (void)
 692 /* Opcode $29: AND #imm */
 693 {
 694     AC_OP_IMM (&);
 695 }
 696
 697
 698
 699 static void OPC_6502_2A (void)
 700 /* Opcode $2A: ROL a */
 701 {
 702     unsigned Val;
 703     Cycles = 2;
 704     Val    = AC << 1;
 705     if (GET_CF ()) {
 706         Val |= 0x01;
 707     }
 708     AC = (unsigned char) Val;
 709     TEST_ZF (AC);
 710     TEST_SF (AC);
 711     TEST_CF (Val);
 712     PC += 1;
 713 }
 714
 715
 716
 717 static void OPC_6502_2B (void)
 718 /* Opcode $2B */
 719 {
 720     Illegal ();
 721 }
 722
 723
 724
 725 static void OPC_6502_2C (void)
 726 /* Opcode $2C: BIT abs */
 727 {
 728     unsigned Addr;
 729     unsigned char Val;
 730     Cycles = 4;
 731     Addr = ReadMem (PC+1);
 732     Val  = ReadMem (Addr);
 733     SET_SF (Val & 0x80);
 734     SET_OF (Val & 0x40);
 735     SET_ZF ((Val & AC) == 0);
 736     PC += 3;
 737 }
 738
 739
 740
 741 static void OPC_6502_2D (void)
 742 /* Opcode $2D: AND abs */
 743 {
 744     AC_OP_ABS (&);
 745 }
 746
 747
 748
 749 static void OPC_6502_2E (void)
 750 /* Opcode $2E: ROL abs */
 751 {
 752     unsigned Addr;
 753     unsigned Val;
 754     Cycles = 6;
 755     Addr = ReadMemW (PC+1);
 756     Val  = ReadMem (Addr) << 1;
 757     if (GET_CF ()) {
 758         Val |= 0x01;
 759     }
 760     AC = (unsigned char) Val;
 761     TEST_ZF (AC);
 762     TEST_SF (AC);
 763     TEST_CF (Val);
 764     PC += 3;
 765 }
 766
 767
 768
 769 static void OPC_6502_2F (void)
 770 /* Opcode $2F */
 771 {
 772     Illegal ();
 773 }
 774
 775
 776
 777 static void OPC_6502_30 (void)
 778 /* Opcode $30: BMI */
 779 {
 780     BRANCH (GET_SF ());
 781 }
 782
 783
 784
 785 static void OPC_6502_31 (void)
 786 /* Opcode $31: AND (zp),y */
 787 {
 788     AC_OP_ZPINDY (&);
 789 }
 790
 791
 792
 793 static void OPC_6502_32 (void)
 794 /* Opcode $32 */
 795 {
 796     Illegal ();
 797 }
 798
 799
 800
 801 static void OPC_6502_33 (void)
 802 /* Opcode $33 */
 803 {
 804     Illegal ();
 805 }
 806
 807
 808
 809 static void OPC_6502_34 (void)
 810 /* Opcode $34 */
 811 {
 812     Illegal ();
 813 }
 814
 815
 816
 817 static void OPC_6502_35 (void)
 818 /* Opcode $35: AND zp,x */
 819 {
 820     AC_OP_ZPX (&);
 821 }
 822
 823
 824
 825 static void OPC_6502_36 (void)
 826 /* Opcode $36: ROL zp,x */
 827 {
 828     unsigned char ZPAddr;
 829     unsigned Val;
 830     Cycles = 6;
 831     ZPAddr = ReadMem (PC+1) + XR;
 832     Val    = ReadMem (ZPAddr) << 1;
 833     if (GET_CF ()) {
 834         Val |= 0x01;
 835     }
 836     AC = (unsigned char) Val;
 837     TEST_ZF (AC);
 838     TEST_SF (AC);
 839     TEST_CF (Val);
 840     PC += 2;
 841 }
 842
 843
 844
 845 static void OPC_6502_37 (void)
 846 /* Opcode $37 */
 847 {
 848     Illegal ();
 849 }
 850
 851
 852
 853 static void OPC_6502_38 (void)
 854 /* Opcode $38: SEC */
 855 {
 856     Cycles = 2;
 857     SET_CF (1);
 858     PC += 1;
 859 }
 860
 861
 862
 863 static void OPC_6502_39 (void)
 864 /* Opcode $39: AND abs,y */
 865 {
 866     AC_OP_ABSY (&);
 867 }
 868
 869
 870
 871 static void OPC_6502_3A (void)
 872 /* Opcode $3A */
 873 {
 874     Illegal ();
 875 }
 876
 877
 878
 879 static void OPC_6502_3B (void)
 880 /* Opcode $3B */
 881 {
 882     Illegal ();
 883 }
 884
 885
 886
 887 static void OPC_6502_3C (void)
 888 /* Opcode $3C */
 889 {
 890     Illegal ();
 891 }
 892
 893
 894
 895 static void OPC_6502_3D (void)
 896 /* Opcode $3D: AND abs,x */
 897 {
 898     AC_OP_ABSX (&);
 899 }
 900
 901
 902
 903 static void OPC_6502_3E (void)
 904 /* Opcode $3E: ROL abs,x */
 905 {
 906     unsigned Addr;
 907     unsigned Val;
 908     Cycles = 7;
 909     Addr = ReadMemW (PC+1) + XR;
 910     Val  = ReadMem (Addr) << 1;
 911     if (GET_CF ()) {
 912         Val |= 0x01;
 913     }
 914     AC = (unsigned char) Val;
 915     TEST_ZF (AC);
 916     TEST_SF (AC);
 917     TEST_CF (Val);
 918     PC += 2;
 919 }
 920
 921
 922
 923 static void OPC_6502_3F (void)
 924 /* Opcode $3F */
 925 {
 926     Illegal ();
 927 }
 928
 929
 930
 931 static void OPC_6502_40 (void)
 932 /* Opcode $40: RTI */
 933 {
 934     Cycles = 6;
 935     SR = POP ();
 936     PC = POP ();                /* PCL */
 937     PC |= (POP () << 8);        /* PCH */
 938 }
 939
 940
 941
 942 static void OPC_6502_41 (void)
 943 /* Opcode $41: EOR (zp,x) */
 944 {
 945     AC_OP_ZPXIND (^);
 946 }
 947
 948
 949
 950 static void OPC_6502_42 (void)
 951 /* Opcode $42 */
 952 {
 953     Illegal ();
 954 }
 955
 956
 957
 958 static void OPC_6502_43 (void)
 959 /* Opcode $43 */
 960 {
 961     Illegal ();
 962 }
 963
 964
 965
 966 static void OPC_6502_44 (void)
 967 /* Opcode $44 */
 968 {
 969     Illegal ();
 970 }
 971
 972
 973
 974 static void OPC_6502_45 (void)
 975 /* Opcode $45: EOR zp */
 976 {
 977     AC_OP_ZP (^);
 978 }
 979
 980
 981
 982 static void OPC_6502_46 (void)
 983 /* Opcode $46: LSR zp */
 984 {
 985     unsigned char ZPAddr;
 986     unsigned char Val;
 987     Cycles = 5;
 988     ZPAddr = ReadMem (PC+1);
 989     Val    = ReadMem (ZPAddr);
 990     SET_CF (Val & 0x01);
 991     Val >>= 1;
 992     WriteMem (ZPAddr, Val);
 993     TEST_ZF (Val);
 994     TEST_SF (Val);
 995     PC += 2;
 996 }
 997
 998
 999
1000 static void OPC_6502_47 (void)
1001 /* Opcode $47 */
1002 {
1003     Illegal ();
1004 }
1005
1006
1007
1008 static void OPC_6502_48 (void)
1009 /* Opcode $48: PHA */
1010 {
1011     Cycles = 3;
1012     PUSH (AC);
1013     PC += 1;
1014 }
1015
1016
1017
1018 static void OPC_6502_49 (void)
1019 /* Opcode $49: EOR #imm */
1020 {
1021     AC_OP_IMM (^);
1022 }
1023
1024
1025
1026 static void OPC_6502_4A (void)
1027 /* Opcode $4A: LSR a */
1028 {
1029     Cycles = 2;
1030     SET_CF (AC & 0x01);
1031     AC >>= 1;
1032     TEST_ZF (AC);
1033     TEST_SF (AC);
1034     PC += 1;
1035 }
1036
1037
1038
1039 static void OPC_6502_4B (void)
1040 /* Opcode $4B */
1041 {
1042     Illegal ();
1043 }
1044
1045
1046
1047 static void OPC_6502_4C (void)
1048 /* Opcode $4C: JMP abs */
1049 {
1050     Cycles = 3;
1051     PC = ReadMemW (PC+1);
1052 }
1053
1054
1055
1056 static void OPC_6502_4D (void)
1057 /* Opcode $4D: EOR abs */
1058 {
1059     AC_OP_ABS (^);
1060 }
1061
1062
1063
1064 static void OPC_6502_4E (void)
1065 /* Opcode $4E: LSR abs */
1066 {
1067     unsigned Addr;
1068     unsigned char Val;
1069     Cycles = 6;
1070     Addr = ReadMemW (PC+1);
1071     Val  = ReadMem (Addr);
1072     SET_CF (Val & 0x01);
1073     Val >>= 1;
1074     WriteMem (Addr, Val);
1075     TEST_ZF (Val);
1076     TEST_SF (Val);
1077     PC += 3;
1078 }
1079
1080
1081
1082 static void OPC_6502_4F (void)
1083 /* Opcode $4F */
1084 {
1085     Illegal ();
1086 }
1087
1088
1089
1090 static void OPC_6502_50 (void)
1091 /* Opcode $50: BVC */
1092 {
1093     BRANCH (!GET_OF ());
1094 }
1095
1096
1097
1098 static void OPC_6502_51 (void)
1099 /* Opcode $51: EOR (zp),y */
1100 {
1101     AC_OP_ZPINDY (^);
1102 }
1103
1104
1105
1106 static void OPC_6502_52 (void)
1107 /* Opcode $52 */
1108 {
1109     Illegal ();
1110 }
1111
1112
1113
1114 static void OPC_6502_53 (void)
1115 /* Opcode $53 */
1116 {
1117     Illegal ();
1118 }
1119
1120
1121
1122 static void OPC_6502_54 (void)
1123 /* Opcode $54 */
1124 {
1125     Illegal ();
1126 }
1127
1128
1129
1130 static void OPC_6502_55 (void)
1131 /* Opcode $55: EOR zp,x */
1132 {
1133     AC_OP_ZPX (^);
1134 }
1135
1136
1137
1138 static void OPC_6502_56 (void)
1139 /* Opcode $56: LSR zp,x */
1140 {
1141     unsigned char ZPAddr;
1142     unsigned char Val;
1143     Cycles = 6;
1144     ZPAddr = ReadMem (PC+1) + XR;
1145     Val    = ReadMem (ZPAddr);
1146     SET_CF (Val & 0x01);
1147     Val >>= 1;
1148     WriteMem (ZPAddr, Val);
1149     TEST_ZF (Val);
1150     TEST_SF (Val);
1151     PC += 2;
1152 }
1153
1154
1155
1156 static void OPC_6502_57 (void)
1157 /* Opcode $57 */
1158 {
1159     Illegal ();
1160 }
1161
1162
1163
1164 static void OPC_6502_58 (void)
1165 /* Opcode $58: CLI */
1166 {
1167     Cycles = 2;
1168     SET_IF (0);
1169     PC += 1;
1170 }
1171
1172
1173
1174 static void OPC_6502_59 (void)
1175 /* Opcode $59: EOR abs,y */
1176 {
1177     AC_OP_ABSY (^);
1178 }
1179
1180
1181
1182 static void OPC_6502_5A (void)
1183 /* Opcode $5A */
1184 {
1185     Illegal ();
1186 }
1187
1188
1189
1190 static void OPC_6502_5B (void)
1191 /* Opcode $5B */
1192 {
1193     Illegal ();
1194 }
1195
1196
1197
1198 static void OPC_6502_5C (void)
1199 /* Opcode $5C */
1200 {
1201     Illegal ();
1202 }
1203
1204
1205
1206 static void OPC_6502_5D (void)
1207 /* Opcode $5D: EOR abs,x */
1208 {
1209     AC_OP_ABSX (^);
1210 }
1211
1212
1213
1214 static void OPC_6502_5E (void)
1215 /* Opcode $5E: LSR abs,x */
1216 {
1217     unsigned Addr;
1218     unsigned char Val;
1219     Cycles = 7;
1220     Addr = ReadMemW (PC+1) + XR;
1221     Val  = ReadMem (Addr);
1222     SET_CF (Val & 0x01);
1223     Val >>= 1;
1224     WriteMem (Addr, Val);
1225     TEST_ZF (Val);
1226     TEST_SF (Val);
1227     PC += 3;
1228 }
1229
1230
1231
1232 static void OPC_6502_5F (void)
1233 /* Opcode $5F */
1234 {
1235     Illegal ();
1236 }
1237
1238
1239
1240 static void OPC_6502_60 (void)
1241 /* Opcode $60: RTS */
1242 {
1243     Cycles = 6;
1244     PC = POP ();                /* PCL */
1245     PC |= (POP () << 8);        /* PCH */
1246     PC += 1;
1247 }
1248
1249
1250
1251 static void OPC_6502_61 (void)
1252 /* Opcode $61: ADC (zp,x) */
1253 {
1254     NotImplemented ();
1255 }
1256
1257
1258
1259 static void OPC_6502_62 (void)
1260 /* Opcode $62 */
1261 {
1262     Illegal ();
1263 }
1264
1265
1266
1267 static void OPC_6502_63 (void)
1268 /* Opcode $63 */
1269 {
1270     Illegal ();
1271 }
1272
1273
1274
1275 static void OPC_6502_64 (void)
1276 /* Opcode $64 */
1277 {
1278     Illegal ();
1279 }
1280
1281
1282
1283 static void OPC_6502_65 (void)
1284 /* Opcode $65: ADC zp */
1285 {
1286     NotImplemented ();
1287 }
1288
1289
1290
1291 static void OPC_6502_66 (void)
1292 /* Opcode $66: ROR zp */
1293 {
1294     NotImplemented ();
1295 }
1296
1297
1298
1299 static void OPC_6502_67 (void)
1300 /* Opcode $67 */
1301 {
1302     Illegal ();
1303 }
1304
1305
1306
1307 static void OPC_6502_68 (void)
1308 /* Opcode $68: PLA */
1309 {
1310     Cycles = 4;
1311     AC = POP ();
1312     TEST_ZF (AC);
1313     TEST_SF (AC);
1314     PC += 1;
1315 }
1316
1317
1318
1319 static void OPC_6502_69 (void)
1320 /* Opcode $69: ADC #imm */
1321 {
1322     NotImplemented ();
1323 }
1324
1325
1326
1327 static void OPC_6502_6A (void)
1328 /* Opcode $6A: ROR a */
1329 {
1330     NotImplemented ();
1331 }
1332
1333
1334
1335 static void OPC_6502_6B (void)
1336 /* Opcode $6B */
1337 {
1338     Illegal ();
1339 }
1340
1341
1342
1343 static void OPC_6502_6C (void)
1344 /* Opcode $6C: JMP (ind) */
1345 {
1346     unsigned Addr;
1347     Cycles = 5;
1348     Addr = ReadMemW (PC+1);
1349     if (CPU == CPU_6502) {
1350         /* Emulate the 6502 bug */
1351         PC = ReadMem (Addr);
1352         Addr = (Addr & 0xFF00) | ((Addr + 1) & 0xFF);
1353         PC |= (ReadMem (Addr) << 8);
1354     } else {
1355         /* 65C02 and above have this bug fixed */
1356         PC = ReadMemW (Addr);
1357     }
1358     PC += 3;
1359 }
1360
1361
1362
1363 static void OPC_6502_6D (void)
1364 /* Opcode $6D: ADC abs */
1365 {
1366     NotImplemented ();
1367 }
1368
1369
1370
1371 static void OPC_6502_6E (void)
1372 /* Opcode $6E: ROR abs */
1373 {
1374     NotImplemented ();
1375 }
1376
1377
1378
1379 static void OPC_6502_6F (void)
1380 /* Opcode $6F */
1381 {
1382     Illegal ();
1383 }
1384
1385
1386
1387 static void OPC_6502_70 (void)
1388 /* Opcode $70: BVS */
1389 {
1390     BRANCH (GET_OF ());
1391 }
1392
1393
1394
1395 static void OPC_6502_71 (void)
1396 /* Opcode $71: ADC (zp),y */
1397 {
1398     NotImplemented ();
1399 }
1400
1401
1402
1403 static void OPC_6502_72 (void)
1404 /* Opcode $72 */
1405 {
1406     Illegal ();
1407 }
1408
1409
1410
1411 static void OPC_6502_73 (void)
1412 /* Opcode $73 */
1413 {
1414     Illegal ();
1415 }
1416
1417
1418
1419 static void OPC_6502_74 (void)
1420 /* Opcode $74 */
1421 {
1422     Illegal ();
1423 }
1424
1425
1426
1427 static void OPC_6502_75 (void)
1428 /* Opcode $75: ADC zp,x */
1429 {
1430     NotImplemented ();
1431 }
1432
1433
1434
1435 static void OPC_6502_76 (void)
1436 /* Opcode $76: ROR zp,x */
1437 {
1438     NotImplemented ();
1439 }
1440
1441
1442
1443 static void OPC_6502_77 (void)
1444 /* Opcode $77 */
1445 {
1446     Illegal ();
1447 }
1448
1449
1450
1451 static void OPC_6502_78 (void)
1452 /* Opcode $78: SEI */
1453 {
1454     Cycles = 2;
1455     SET_IF (1);
1456     PC += 1;
1457 }
1458
1459
1460
1461 static void OPC_6502_79 (void)
1462 /* Opcode $79: ADC abs,y */
1463 {
1464     NotImplemented ();
1465 }
1466
1467
1468
1469 static void OPC_6502_7A (void)
1470 /* Opcode $7A */
1471 {
1472     Illegal ();
1473 }
1474
1475
1476
1477 static void OPC_6502_7B (void)
1478 /* Opcode $7B */
1479 {
1480     Illegal ();
1481 }
1482
1483
1484
1485 static void OPC_6502_7C (void)
1486 /* Opcode $7C */
1487 {
1488     Illegal ();
1489 }
1490
1491
1492
1493 static void OPC_6502_7D (void)
1494 /* Opcode $7D: ADC abs,x */
1495 {
1496     NotImplemented ();
1497 }
1498
1499
1500
1501 static void OPC_6502_7E (void)
1502 /* Opcode $7E: ROR abs,x */
1503 {
1504     NotImplemented ();
1505 }
1506
1507
1508
1509 static void OPC_6502_7F (void)
1510 /* Opcode $7F */
1511 {
1512     Illegal ();
1513 }
1514
1515
1516
1517 static void OPC_6502_80 (void)
1518 /* Opcode $80 */
1519 {
1520     Illegal ();
1521 }
1522
1523
1524
1525 static void OPC_6502_81 (void)
1526 /* Opcode $81: STA (zp,x) */
1527 {
1528     NotImplemented ();
1529 }
1530
1531
1532
1533 static void OPC_6502_82 (void)
1534 /* Opcode $82 */
1535 {
1536     Illegal ();
1537 }
1538
1539
1540
1541 static void OPC_6502_83 (void)
1542 /* Opcode $83 */
1543 {
1544     Illegal ();
1545 }
1546
1547
1548
1549 static void OPC_6502_84 (void)
1550 /* Opcode $84: STY zp */
1551 {
1552     unsigned char ZPAddr;
1553     Cycles = 3;
1554     ZPAddr = ReadMem (PC+1);
1555     WriteMem (ZPAddr, YR);
1556     PC += 2;
1557 }
1558
1559
1560
1561 static void OPC_6502_85 (void)
1562 /* Opcode $85: STA zp */
1563 {
1564     unsigned char ZPAddr;
1565     Cycles = 3;
1566     ZPAddr = ReadMem (PC+1);
1567     WriteMem (ZPAddr, AC);
1568     PC += 2;
1569 }
1570
1571
1572
1573 static void OPC_6502_86 (void)
1574 /* Opcode $86: STX zp */
1575 {
1576     unsigned char ZPAddr;
1577     Cycles = 3;
1578     ZPAddr = ReadMem (PC+1);
1579     WriteMem (ZPAddr, XR);
1580     PC += 2;
1581 }
1582
1583
1584
1585 static void OPC_6502_87 (void)
1586 /* Opcode $87 */
1587 {
1588     Illegal ();
1589 }
1590
1591
1592
1593 static void OPC_6502_88 (void)
1594 /* Opcode $88: DEY */
1595 {
1596     Cycles = 2;
1597     --YR;
1598     TEST_ZF (YR);
1599     TEST_SF (YR);
1600     PC += 1;
1601 }
1602
1603
1604
1605 static void OPC_6502_89 (void)
1606 /* Opcode $89 */
1607 {
1608     Illegal ();
1609 }
1610
1611
1612
1613 static void OPC_6502_8A (void)
1614 /* Opcode $8A: TXA */
1615 {
1616     Cycles = 2;
1617     AC = XR;
1618     TEST_ZF (AC);
1619     TEST_SF (AC);
1620     PC += 1;
1621 }
1622
1623
1624
1625 static void OPC_6502_8B (void)
1626 /* Opcode $8B */
1627 {
1628     Illegal ();
1629 }
1630
1631
1632
1633 static void OPC_6502_8C (void)
1634 /* Opcode $8C: STY abs */
1635 {
1636     unsigned Addr;
1637     Cycles = 4;
1638     Addr = ReadMemW (PC+1);
1639     WriteMem (Addr, YR);
1640     PC += 3;
1641 }
1642
1643
1644
1645 static void OPC_6502_8D (void)
1646 /* Opcode $8D: STA abs */
1647 {
1648     unsigned Addr;
1649     Cycles = 4;
1650     Addr = ReadMemW (PC+1);
1651     WriteMem (Addr, AC);
1652     PC += 3;
1653 }
1654
1655
1656
1657 static void OPC_6502_8E (void)
1658 /* Opcode $8E: STX abs */
1659 {
1660     unsigned Addr;
1661     Cycles = 4;
1662     Addr = ReadMemW (PC+1);
1663     WriteMem (Addr, XR);
1664     PC += 3;
1665 }
1666
1667
1668
1669 static void OPC_6502_8F (void)
1670 /* Opcode $8F */
1671 {
1672     Illegal ();
1673 }
1674
1675
1676
1677 static void OPC_6502_90 (void)
1678 /* Opcode $90: BCC */
1679 {
1680     BRANCH (!GET_CF ());
1681 }
1682
1683
1684
1685 static void OPC_6502_91 (void)
1686 /* Opcode $91: sta (zp),y */
1687 {
1688     unsigned char ZPAddr;
1689     unsigned Addr;
1690     Cycles = 6;
1691     ZPAddr = ReadMem (PC+1);
1692     Addr   = ReadZeroPageW (ZPAddr) + YR;
1693     WriteMem (Addr, AC);
1694     PC += 2;
1695 }
1696
1697
1698
1699 static void OPC_6502_92 (void)
1700 /* Opcode $92 */
1701 {
1702     Illegal ();
1703 }
1704
1705
1706
1707 static void OPC_6502_93 (void)
1708 /* Opcode $93 */
1709 {
1710     Illegal ();
1711 }
1712
1713
1714
1715 static void OPC_6502_94 (void)
1716 /* Opcode $94: STY zp,x */
1717 {
1718     unsigned char ZPAddr;
1719     Cycles = 4;
1720     ZPAddr = ReadMem (PC+1) + XR;
1721     WriteMem (ZPAddr, YR);
1722     PC += 2;
1723 }
1724
1725
1726
1727 static void OPC_6502_95 (void)
1728 /* Opcode $95: STA zp,x */
1729 {
1730     unsigned char ZPAddr;
1731     Cycles = 4;
1732     ZPAddr = ReadMem (PC+1) + XR;
1733     WriteMem (ZPAddr, AC);
1734     PC += 2;
1735 }
1736
1737
1738
1739 static void OPC_6502_96 (void)
1740 /* Opcode $96: stx zp,y */
1741 {
1742     unsigned char ZPAddr;
1743     Cycles = 4;
1744     ZPAddr = ReadMem (PC+1) + YR;
1745     WriteMem (ZPAddr, XR);
1746     PC += 2;
1747 }
1748
1749
1750
1751 static void OPC_6502_97 (void)
1752 /* Opcode $97 */
1753 {
1754     Illegal ();
1755 }
1756
1757
1758
1759 static void OPC_6502_98 (void)
1760 /* Opcode $98: TYA */
1761 {
1762     Cycles = 2;
1763     AC = YR;
1764     TEST_ZF (AC);
1765     TEST_SF (AC);
1766     PC += 1;
1767 }
1768
1769
1770
1771 static void OPC_6502_99 (void)
1772 /* Opcode $99: STA abs,y */
1773 {
1774     unsigned Addr;
1775     Cycles = 5;
1776     Addr   = ReadMemW (PC+1) + YR;
1777     WriteMem (Addr, AC);
1778     PC += 3;
1779 }
1780
1781
1782
1783 static void OPC_6502_9A (void)
1784 /* Opcode $9A: TXS */
1785 {
1786     Cycles = 2;
1787     SP = XR;
1788     PC += 1;
1789 }
1790
1791
1792
1793 static void OPC_6502_9B (void)
1794 /* Opcode $9B */
1795 {
1796     Illegal ();
1797 }
1798
1799
1800
1801 static void OPC_6502_9C (void)
1802 /* Opcode $9C */
1803 {
1804     Illegal ();
1805 }
1806
1807
1808
1809 static void OPC_6502_9D (void)
1810 /* Opcode $9D: STA abs,x */
1811 {
1812     unsigned Addr;
1813     Cycles = 5;
1814     Addr   = ReadMemW (PC+1) + XR;
1815     WriteMem (Addr, AC);
1816     PC += 3;
1817 }
1818
1819
1820
1821 static void OPC_6502_9E (void)
1822 /* Opcode $9E */
1823 {
1824     Illegal ();
1825 }
1826
1827
1828
1829 static void OPC_6502_9F (void)
1830 /* Opcode $9F */
1831 {
1832     Illegal ();
1833 }
1834
1835
1836
1837 static void OPC_6502_A0 (void)
1838 /* Opcode $A0: LDY #imm */
1839 {
1840     Cycles = 2;
1841     YR = ReadMem (PC+1);
1842     TEST_ZF (YR);
1843     TEST_SF (YR);
1844     PC += 2;
1845 }
1846
1847
1848
1849 static void OPC_6502_A1 (void)
1850 /* Opcode $A1: LDA (zp,x) */
1851 {
1852     unsigned char ZPAddr;
1853     unsigned Addr;
1854     Cycles = 6;
1855     ZPAddr = ReadMem (PC+1) + XR;
1856     Addr = ReadZeroPageW (ZPAddr);
1857     AC = ReadMem (Addr);
1858     TEST_ZF (AC);
1859     TEST_SF (AC);
1860     PC += 2;
1861 }
1862
1863
1864
1865 static void OPC_6502_A2 (void)
1866 /* Opcode $A2: LDX #imm */
1867 {
1868     Cycles = 2;
1869     XR = ReadMem (PC+1);
1870     TEST_ZF (XR);
1871     TEST_SF (XR);
1872     PC += 2;
1873 }
1874
1875
1876
1877 static void OPC_6502_A3 (void)
1878 /* Opcode $A3 */
1879 {
1880     Illegal ();
1881 }
1882
1883
1884
1885 static void OPC_6502_A4 (void)
1886 /* Opcode $A4: LDY zp */
1887 {
1888     unsigned char ZPAddr;
1889     Cycles = 3;
1890     ZPAddr = ReadMem (PC+1);
1891     YR = ReadMem (ZPAddr);
1892     TEST_ZF (YR);
1893     TEST_SF (YR);
1894     PC += 2;
1895 }
1896
1897
1898
1899 static void OPC_6502_A5 (void)
1900 /* Opcode $A5: LDA zp */
1901 {
1902     unsigned char ZPAddr;
1903     Cycles = 3;
1904     ZPAddr = ReadMem (PC+1);
1905     AC = ReadMem (ZPAddr);
1906     TEST_ZF (AC);
1907     TEST_SF (AC);
1908     PC += 2;
1909 }
1910
1911
1912
1913 static void OPC_6502_A6 (void)
1914 /* Opcode $A6: LDX zp */
1915 {
1916     unsigned char ZPAddr;
1917     Cycles = 3;
1918     ZPAddr = ReadMem (PC+1);
1919     XR = ReadMem (ZPAddr);
1920     TEST_ZF (XR);
1921     TEST_SF (XR);
1922     PC += 2;
1923 }
1924
1925
1926
1927 static void OPC_6502_A7 (void)
1928 /* Opcode $A7 */
1929 {
1930     Illegal ();
1931 }
1932
1933
1934
1935 static void OPC_6502_A8 (void)
1936 /* Opcode $A8: TAY */
1937 {
1938     Cycles = 2;
1939     YR = AC;
1940     TEST_ZF (YR);
1941     TEST_SF (YR);
1942     PC += 1;
1943 }
1944
1945
1946
1947 static void OPC_6502_A9 (void)
1948 /* Opcode $A9: LDA #imm */
1949 {
1950     Cycles = 2;
1951     AC = ReadMem (PC+1);
1952     TEST_ZF (AC);
1953     TEST_SF (AC);
1954     PC += 2;
1955 }
1956
1957
1958
1959 static void OPC_6502_AA (void)
1960 /* Opcode $AA: TAX */
1961 {
1962     Cycles = 2;
1963     XR = AC;
1964     TEST_ZF (XR);
1965     TEST_SF (XR);
1966     PC += 1;
1967 }
1968
1969
1970
1971 static void OPC_6502_AB (void)
1972 /* Opcode $AB */
1973 {
1974     Illegal ();
1975 }
1976
1977
1978
1979 static void OPC_6502_AC (void)
1980 /* Opcode $AC: LDY abs */
1981 {
1982     unsigned Addr;
1983     Cycles = 4;
1984     Addr   = ReadMemW (PC+1);
1985     YR     = ReadMem (Addr);
1986     TEST_ZF (YR);
1987     TEST_SF (YR);
1988     PC += 3;
1989 }
1990
1991
1992
1993 static void OPC_6502_AD (void)
1994 /* Opcode $AD: LDA abs */
1995 {
1996     unsigned Addr;
1997     Cycles = 4;
1998     Addr   = ReadMemW (PC+1);
1999     AC     = ReadMem (Addr);
2000     TEST_ZF (AC);
2001     TEST_SF (AC);
2002     PC += 3;
2003 }
2004
2005
2006
2007 static void OPC_6502_AE (void)
2008 /* Opcode $AE: LDX abs */
2009 {
2010     unsigned Addr;
2011     Cycles = 4;
2012     Addr   = ReadMemW (PC+1);
2013     XR     = ReadMem (Addr);
2014     TEST_ZF (XR);
2015     TEST_SF (XR);
2016     PC += 3;
2017 }
2018
2019
2020
2021 static void OPC_6502_AF (void)
2022 /* Opcode $AF */
2023 {
2024     Illegal ();
2025 }
2026
2027
2028
2029 static void OPC_6502_B0 (void)
2030 /* Opcode $B0: BCS */
2031 {
2032     BRANCH (GET_CF ());
2033 }
2034
2035
2036
2037 static void OPC_6502_B1 (void)
2038 /* Opcode $B1: LDA (zp),y */
2039 {
2040     unsigned char ZPAddr;
2041     unsigned Addr;
2042     Cycles = 5;
2043     ZPAddr = ReadMem (PC+1);
2044     Addr   = ReadZeroPageW (ZPAddr);
2045     if (PAGE_CROSS (Addr, YR)) {
2046         ++Cycles;
2047     }
2048     AC = ReadMem (Addr + YR);
2049     TEST_ZF (AC);
2050     TEST_SF (AC);
2051     PC += 2;
2052 }
2053
2054
2055
2056 static void OPC_6502_B2 (void)
2057 /* Opcode $B2 */
2058 {
2059     Illegal ();
2060 }
2061
2062
2063
2064 static void OPC_6502_B3 (void)
2065 /* Opcode $B3 */
2066 {
2067     Illegal ();
2068 }
2069
2070
2071
2072 static void OPC_6502_B4 (void)
2073 /* Opcode $B4: LDY zp,x */
2074 {
2075     unsigned char ZPAddr;
2076     Cycles = 4;
2077     ZPAddr = ReadMem (PC+1) + XR;
2078     YR     = ReadMem (ZPAddr);
2079     TEST_ZF (YR);
2080     TEST_SF (YR);
2081     PC += 2;
2082 }
2083
2084
2085
2086 static void OPC_6502_B5 (void)
2087 /* Opcode $B5: LDA zp,x */
2088 {
2089     unsigned char ZPAddr;
2090     Cycles = 4;
2091     ZPAddr = ReadMem (PC+1) + XR;
2092     AC     = ReadMem (ZPAddr);
2093     TEST_ZF (AC);
2094     TEST_SF (AC);
2095     PC += 2;
2096 }
2097
2098
2099
2100 static void OPC_6502_B6 (void)
2101 /* Opcode $B6: LDX zp,y */
2102 {
2103     unsigned char ZPAddr;
2104     Cycles = 4;
2105     ZPAddr = ReadMem (PC+1) + YR;
2106     XR     = ReadMem (ZPAddr);
2107     TEST_ZF (XR);
2108     TEST_SF (XR);
2109     PC += 2;
2110 }
2111
2112
2113
2114 static void OPC_6502_B7 (void)
2115 /* Opcode $B7 */
2116 {
2117     Illegal ();
2118 }
2119
2120
2121
2122 static void OPC_6502_B8 (void)
2123 /* Opcode $B8: CLV */
2124 {
2125     Cycles = 2;
2126     SET_OF (0);
2127     PC += 1;
2128 }
2129
2130
2131
2132 static void OPC_6502_B9 (void)
2133 /* Opcode $B9: LDA abs,y */
2134 {
2135     unsigned Addr;
2136     Cycles = 4;
2137     Addr = ReadMemW (PC+1);
2138     if (PAGE_CROSS (Addr, YR)) {
2139         ++Cycles;
2140     }
2141     AC = ReadMem (Addr + YR);
2142     TEST_ZF (AC);
2143     TEST_SF (AC);
2144     PC += 3;
2145 }
2146
2147
2148
2149 static void OPC_6502_BA (void)
2150 /* Opcode $BA: TSX */
2151 {
2152     Cycles = 2;
2153     XR = SP;
2154     TEST_ZF (XR);
2155     TEST_SF (XR);
2156     PC += 1;
2157 }
2158
2159
2160
2161 static void OPC_6502_BB (void)
2162 /* Opcode $BB */
2163 {
2164     Illegal ();
2165 }
2166
2167
2168
2169 static void OPC_6502_BC (void)
2170 /* Opcode $BC: LDY abs,x */
2171 {
2172     unsigned Addr;
2173     Cycles = 4;
2174     Addr = ReadMemW (PC+1);
2175     if (PAGE_CROSS (Addr, XR)) {
2176         ++Cycles;
2177     }
2178     YR = ReadMem (Addr + XR);
2179     TEST_ZF (YR);
2180     TEST_SF (YR);
2181     PC += 3;
2182 }
2183
2184
2185
2186 static void OPC_6502_BD (void)
2187 /* Opcode $BD: LDA abs,x */
2188 {
2189     unsigned Addr;
2190     Cycles = 4;
2191     Addr = ReadMemW (PC+1);
2192     if (PAGE_CROSS (Addr, XR)) {
2193         ++Cycles;
2194     }
2195     AC = ReadMem (Addr + XR);
2196     TEST_ZF (AC);
2197     TEST_SF (AC);
2198     PC += 3;
2199 }
2200
2201
2202
2203 static void OPC_6502_BE (void)
2204 /* Opcode $BE: LDX abs,y */
2205 {
2206     unsigned Addr;
2207     Cycles = 4;
2208     Addr = ReadMemW (PC+1);
2209     if (PAGE_CROSS (Addr, YR)) {
2210         ++Cycles;
2211     }
2212     XR = ReadMem (Addr + YR);
2213     TEST_ZF (XR);
2214     TEST_SF (XR);
2215     PC += 3;
2216 }
2217
2218
2219
2220 static void OPC_6502_BF (void)
2221 /* Opcode $BF */
2222 {
2223     Illegal ();
2224 }
2225
2226
2227
2228 static void OPC_6502_C0 (void)
2229 /* Opcode $C0: CPY #imm */
2230 {
2231     Cycles = 2;
2232     CMP (YR, ReadMem (PC+1));
2233     PC += 2;
2234 }
2235
2236
2237
2238 static void OPC_6502_C1 (void)
2239 /* Opcode $C1: CMP (zp,x) */
2240 {
2241     unsigned char ZPAddr;
2242     unsigned Addr;
2243     Cycles = 6;
2244     ZPAddr = ReadMem (PC+1) + XR;
2245     Addr   = ReadZeroPageW (ZPAddr);
2246     CMP (AC, ReadMem (Addr));
2247     PC += 2;
2248 }
2249
2250
2251
2252 static void OPC_6502_C2 (void)
2253 /* Opcode $C2 */
2254 {
2255     Illegal ();
2256 }
2257
2258
2259
2260 static void OPC_6502_C3 (void)
2261 /* Opcode $C3 */
2262 {
2263     Illegal ();
2264 }
2265
2266
2267
2268 static void OPC_6502_C4 (void)
2269 /* Opcode $C4: CPY zp */
2270 {
2271     unsigned char ZPAddr;
2272     Cycles = 3;
2273     ZPAddr = ReadMem (PC+1);
2274     CMP (YR, ReadMem (ZPAddr));
2275     PC += 2;
2276 }
2277
2278
2279
2280 static void OPC_6502_C5 (void)
2281 /* Opcode $C5: CMP zp */
2282 {
2283     unsigned char ZPAddr;
2284     Cycles = 3;
2285     ZPAddr = ReadMem (PC+1);
2286     CMP (AC, ReadMem (ZPAddr));
2287     PC += 2;
2288 }
2289
2290
2291
2292 static void OPC_6502_C6 (void)
2293 /* Opcode $C6: DEC zp */
2294 {
2295     unsigned char ZPAddr;
2296     unsigned char Val;
2297     Cycles = 5;
2298     ZPAddr = ReadMem (PC+1);
2299     Val    = ReadMem (ZPAddr) - 1;
2300     WriteMem (ZPAddr, Val);
2301     TEST_ZF (Val);
2302     TEST_SF (Val);
2303     PC += 2;
2304 }
2305
2306
2307
2308 static void OPC_6502_C7 (void)
2309 /* Opcode $C7 */
2310 {
2311     Illegal ();
2312 }
2313
2314
2315
2316 static void OPC_6502_C8 (void)
2317 /* Opcode $C8: INY */
2318 {
2319     Cycles = 2;
2320     ++YR;
2321     TEST_ZF (YR);
2322     TEST_SF (YR);
2323     PC += 1;
2324 }
2325
2326
2327
2328 static void OPC_6502_C9 (void)
2329 /* Opcode $C9: CMP #imm */
2330 {
2331     Cycles = 2;
2332     CMP (AC, ReadMem (PC+1));
2333     PC += 2;
2334 }
2335
2336
2337
2338 static void OPC_6502_CA (void)
2339 /* Opcode $CA: DEX */
2340 {
2341     Cycles = 2;
2342     --XR;
2343     TEST_ZF (XR);
2344     TEST_SF (XR);
2345     PC += 1;
2346 }
2347
2348
2349
2350 static void OPC_6502_CB (void)
2351 /* Opcode $CB */
2352 {
2353     Illegal ();
2354 }
2355
2356
2357
2358 static void OPC_6502_CC (void)
2359 /* Opcode $CC: CPY abs */
2360 {
2361     unsigned Addr;
2362     Cycles = 4;
2363     Addr   = ReadMemW (PC+1);
2364     CMP (YR, ReadMem (Addr));
2365     PC += 3;
2366 }
2367
2368
2369
2370 static void OPC_6502_CD (void)
2371 /* Opcode $CD: CMP abs */
2372 {
2373     unsigned Addr;
2374     Cycles = 4;
2375     Addr   = ReadMemW (PC+1);
2376     CMP (AC, ReadMem (Addr));
2377     PC += 3;
2378 }
2379
2380
2381
2382 static void OPC_6502_CE (void)
2383 /* Opcode $CE: DEC abs */
2384 {
2385     unsigned Addr;
2386     unsigned char Val;
2387     Cycles = 6;
2388     Addr = ReadMemW (PC+1);
2389     Val  = ReadMem (Addr) - 1;
2390     WriteMem (Addr, Val);
2391     TEST_ZF (Val);
2392     TEST_SF (Val);
2393     PC += 3;
2394 }
2395
2396
2397
2398 static void OPC_6502_CF (void)
2399 /* Opcode $CF */
2400 {
2401     Illegal ();
2402 }
2403
2404
2405
2406 static void OPC_6502_D0 (void)
2407 /* Opcode $D0: BNE */
2408 {
2409     BRANCH (!GET_ZF ());
2410 }
2411
2412
2413
2414 static void OPC_6502_D1 (void)
2415 /* Opcode $D1: CMP (zp),y */
2416 {
2417     unsigned ZPAddr;
2418     unsigned Addr;
2419     Cycles = 5;
2420     ZPAddr = ReadMem (PC+1);
2421     Addr   = ReadMemW (ZPAddr);
2422     if (PAGE_CROSS (Addr, YR)) {
2423         ++Cycles;
2424     }
2425     CMP (AC, ReadMem (Addr + YR));
2426     PC += 2;
2427 }
2428
2429
2430
2431 static void OPC_6502_D2 (void)
2432 /* Opcode $D2 */
2433 {
2434     Illegal ();
2435 }
2436
2437
2438
2439 static void OPC_6502_D3 (void)
2440 /* Opcode $D3 */
2441 {
2442     Illegal ();
2443 }
2444
2445
2446
2447 static void OPC_6502_D4 (void)
2448 /* Opcode $D4 */
2449 {
2450     Illegal ();
2451 }
2452
2453
2454
2455 static void OPC_6502_D5 (void)
2456 /* Opcode $D5: CMP zp,x */
2457 {
2458     unsigned char ZPAddr;
2459     Cycles = 4;
2460     ZPAddr = ReadMem (PC+1) + XR;
2461     CMP (AC, ReadMem (ZPAddr));
2462     PC += 2;
2463 }
2464
2465
2466
2467 static void OPC_6502_D6 (void)
2468 /* Opcode $D6: DEC zp,x */
2469 {
2470     unsigned char ZPAddr;
2471     unsigned char Val;
2472     Cycles = 6;
2473     ZPAddr = ReadMem (PC+1) + XR;
2474     Val  = ReadMem (ZPAddr) - 1;
2475     WriteMem (ZPAddr, Val);
2476     TEST_ZF (Val);
2477     TEST_SF (Val);
2478     PC += 2;
2479 }
2480
2481
2482
2483 static void OPC_6502_D7 (void)
2484 /* Opcode $D7 */
2485 {
2486     Illegal ();
2487 }
2488
2489
2490
2491 static void OPC_6502_D8 (void)
2492 /* Opcode $D8: CLD */
2493 {
2494     Cycles = 2;
2495     SET_DF (0);
2496     PC += 1;
2497 }
2498
2499
2500
2501 static void OPC_6502_D9 (void)
2502 /* Opcode $D9: CMP abs,y */
2503 {
2504     unsigned Addr;
2505     Cycles = 4;
2506     Addr = ReadMemW (PC+1);
2507     if (PAGE_CROSS (Addr, YR)) {
2508         ++Cycles;
2509     }
2510     CMP (AC, ReadMem (Addr + YR));
2511     PC += 3;
2512 }
2513
2514
2515
2516 static void OPC_6502_DA (void)
2517 /* Opcode $DA */
2518 {
2519     Illegal ();
2520 }
2521
2522
2523
2524 static void OPC_6502_DB (void)
2525 /* Opcode $DB */
2526 {
2527     Illegal ();
2528 }
2529
2530
2531
2532 static void OPC_6502_DC (void)
2533 /* Opcode $DC */
2534 {
2535     Illegal ();
2536 }
2537
2538
2539
2540 static void OPC_6502_DD (void)
2541 /* Opcode $DD: CMP abs,x */
2542 {
2543     unsigned Addr;
2544     Cycles = 4;
2545     Addr = ReadMemW (PC+1);
2546     if (PAGE_CROSS (Addr, XR)) {
2547         ++Cycles;
2548     }
2549     CMP (AC, ReadMem (Addr + XR));
2550     PC += 3;
2551 }
2552
2553
2554
2555 static void OPC_6502_DE (void)
2556 /* Opcode $DE: DEC abs,x */
2557 {
2558     unsigned Addr;
2559     unsigned char Val;
2560     Cycles = 7;
2561     Addr = ReadMemW (PC+1) + XR;
2562     Val  = ReadMem (Addr) - 1;
2563     WriteMem (Addr, Val);
2564     TEST_ZF (Val);
2565     TEST_SF (Val);
2566     PC += 3;
2567 }
2568
2569
2570
2571 static void OPC_6502_DF (void)
2572 /* Opcode $DF */
2573 {
2574     Illegal ();
2575 }
2576
2577
2578
2579 static void OPC_6502_E0 (void)
2580 /* Opcode $E0: CPX #imm */
2581 {
2582     Cycles = 2;
2583     CMP (XR, ReadMem (PC+1));
2584     PC += 2;
2585 }
2586
2587
2588
2589 static void OPC_6502_E1 (void)
2590 /* Opcode $E1: SBC (zp,x) */
2591 {
2592     NotImplemented ();
2593 }
2594
2595
2596
2597 static void OPC_6502_E2 (void)
2598 /* Opcode $E2 */
2599 {
2600     Illegal ();
2601 }
2602
2603
2604
2605 static void OPC_6502_E3 (void)
2606 /* Opcode $E3 */
2607 {
2608     Illegal ();
2609 }
2610
2611
2612
2613 static void OPC_6502_E4 (void)
2614 /* Opcode $E4: CPX zp */
2615 {
2616     unsigned char ZPAddr;
2617     Cycles = 3;
2618     ZPAddr = ReadMem (PC+1);
2619     CMP (XR, ReadMem (ZPAddr));
2620     PC += 2;
2621 }
2622
2623
2624
2625 static void OPC_6502_E5 (void)
2626 /* Opcode $E5: SBC zp */
2627 {
2628     NotImplemented ();
2629 }
2630
2631
2632
2633 static void OPC_6502_E6 (void)
2634 /* Opcode $E6: INC zp */
2635 {
2636     unsigned char ZPAddr;
2637     unsigned char Val;
2638     Cycles = 5;
2639     ZPAddr = ReadMem (PC+1);
2640     Val    = ReadMem (ZPAddr) + 1;
2641     WriteMem (ZPAddr, Val);
2642     TEST_ZF (Val);
2643     TEST_SF (Val);
2644     PC += 2;
2645 }
2646
2647
2648
2649 static void OPC_6502_E7 (void)
2650 /* Opcode $E7 */
2651 {
2652     Illegal ();
2653 }
2654
2655
2656
2657 static void OPC_6502_E8 (void)
2658 /* Opcode $E8: INX */
2659 {
2660     Cycles = 2;
2661     ++XR;
2662     TEST_ZF (XR);
2663     TEST_SF (XR);
2664     PC += 1;
2665 }
2666
2667
2668
2669 static void OPC_6502_E9 (void)
2670 /* Opcode $E9: SBC #imm */
2671 {
2672     NotImplemented ();
2673 }
2674
2675
2676
2677 static void OPC_6502_EA (void)
2678 /* Opcode $EA: NOP */
2679 {
2680     /* This one is easy... */
2681     Cycles = 2;
2682     PC += 1;
2683 }
2684
2685
2686
2687 static void OPC_6502_EB (void)
2688 /* Opcode $EB */
2689 {
2690     Illegal ();
2691 }
2692
2693
2694
2695 static void OPC_6502_EC (void)
2696 /* Opcode $EC: CPX abs */
2697 {
2698     unsigned Addr;
2699     Cycles = 4;
2700     Addr   = ReadMemW (PC+1);
2701     CMP (XR, ReadMem (Addr));
2702     PC += 3;
2703 }
2704
2705
2706
2707 static void OPC_6502_ED (void)
2708 /* Opcode $ED: SBC abs */
2709 {
2710     NotImplemented ();
2711 }
2712
2713
2714
2715 static void OPC_6502_EE (void)
2716 /* Opcode $EE: INC abs */
2717 {
2718     unsigned Addr;
2719     unsigned char Val;
2720     Cycles = 6;
2721     Addr = ReadMemW (PC+1);
2722     Val  = ReadMem (Addr) + 1;
2723     WriteMem (Addr, Val);
2724     TEST_ZF (Val);
2725     TEST_SF (Val);
2726     PC += 3;
2727 }
2728
2729
2730
2731 static void OPC_6502_EF (void)
2732 /* Opcode $EF */
2733 {
2734     Illegal ();
2735 }
2736
2737
2738
2739 static void OPC_6502_F0 (void)
2740 /* Opcode $F0: BEQ */
2741 {
2742     BRANCH (GET_ZF ());
2743 }
2744
2745
2746
2747 static void OPC_6502_F1 (void)
2748 /* Opcode $F1: SBC (zp),y */
2749 {
2750     NotImplemented ();
2751 }
2752
2753
2754
2755 static void OPC_6502_F2 (void)
2756 /* Opcode $F2 */
2757 {
2758     Illegal ();
2759 }
2760
2761
2762
2763 static void OPC_6502_F3 (void)
2764 /* Opcode $F3 */
2765 {
2766     Illegal ();
2767 }
2768
2769
2770
2771 static void OPC_6502_F4 (void)
2772 /* Opcode $F4 */
2773 {
2774     Illegal ();
2775 }
2776
2777
2778
2779 static void OPC_6502_F5 (void)
2780 /* Opcode $F5: SBC zp,x */
2781 {
2782     NotImplemented ();
2783 }
2784
2785
2786
2787 static void OPC_6502_F6 (void)
2788 /* Opcode $F6: INC zp,x */
2789 {
2790     unsigned char ZPAddr;
2791     unsigned char Val;
2792     Cycles = 6;
2793     ZPAddr = ReadMem (PC+1) + XR;
2794     Val  = ReadMem (ZPAddr) + 1;
2795     WriteMem (ZPAddr, Val);
2796     TEST_ZF (Val);
2797     TEST_SF (Val);
2798     PC += 2;
2799 }
2800
2801
2802
2803 static void OPC_6502_F7 (void)
2804 /* Opcode $F7 */
2805 {
2806     Illegal ();
2807 }
2808
2809
2810
2811 static void OPC_6502_F8 (void)
2812 /* Opcode $F8: SED */
2813 {
2814     SET_DF (1);
2815 }
2816
2817
2818
2819 static void OPC_6502_F9 (void)
2820 /* Opcode $F9: SBC abs,y */
2821 {
2822     NotImplemented ();
2823 }
2824
2825
2826
2827 static void OPC_6502_FA (void)
2828 /* Opcode $FA */
2829 {
2830     Illegal ();
2831 }
2832
2833
2834
2835 static void OPC_6502_FB (void)
2836 /* Opcode $FB */
2837 {
2838     Illegal ();
2839 }
2840
2841
2842
2843 static void OPC_6502_FC (void)
2844 /* Opcode $FC */
2845 {
2846     Illegal ();
2847 }
2848
2849
2850
2851 static void OPC_6502_FD (void)
2852 /* Opcode $FD: SBC abs,x */
2853 {
2854     NotImplemented ();
2855 }
2856
2857
2858
2859 static void OPC_6502_FE (void)
2860 /* Opcode $FE: INC abs,x */
2861 {
2862     unsigned Addr;
2863     unsigned char Val;
2864     Cycles = 7;
2865     Addr = ReadMemW (PC+1) + XR;
2866     Val  = ReadMem (Addr) + 1;
2867     WriteMem (Addr, Val);
2868     TEST_ZF (Val);
2869     TEST_SF (Val);
2870     PC += 3;
2871 }
2872
2873
2874
2875 static void OPC_6502_FF (void)
2876 /* Opcode $FF */
2877 {
2878     Illegal ();
2879 }
2880
2881
2882
2883 /*****************************************************************************/
2884 /*                                   Data                                    */
2885 /*****************************************************************************/
2886
2887
2888
2889 /* Opcode handler table */
2890 typedef void (*OPCFunc) (void);
2891 static OPCFunc OPCTable[256] = {
2892     OPC_6502_00,
2893     OPC_6502_01,
2894     OPC_6502_02,
2895     OPC_6502_03,
2896     OPC_6502_04,
2897     OPC_6502_05,
2898     OPC_6502_06,
2899     OPC_6502_07,
2900     OPC_6502_08,
2901     OPC_6502_09,
2902     OPC_6502_0A,
2903     OPC_6502_0B,
2904     OPC_6502_0C,
2905     OPC_6502_0D,
2906     OPC_6502_0E,
2907     OPC_6502_0F,
2908     OPC_6502_10,
2909     OPC_6502_11,
2910     OPC_6502_12,
2911     OPC_6502_13,
2912     OPC_6502_14,
2913     OPC_6502_15,
2914     OPC_6502_16,
2915     OPC_6502_17,
2916     OPC_6502_18,
2917     OPC_6502_19,
2918     OPC_6502_1A,
2919     OPC_6502_1B,
2920     OPC_6502_1C,
2921     OPC_6502_1D,
2922     OPC_6502_1E,
2923     OPC_6502_1F,
2924     OPC_6502_20,
2925     OPC_6502_21,
2926     OPC_6502_22,
2927     OPC_6502_23,
2928     OPC_6502_24,
2929     OPC_6502_25,
2930     OPC_6502_26,
2931     OPC_6502_27,
2932     OPC_6502_28,
2933     OPC_6502_29,
2934     OPC_6502_2A,
2935     OPC_6502_2B,
2936     OPC_6502_2C,
2937     OPC_6502_2D,
2938     OPC_6502_2E,
2939     OPC_6502_2F,
2940     OPC_6502_30,
2941     OPC_6502_31,
2942     OPC_6502_32,
2943     OPC_6502_33,
2944     OPC_6502_34,
2945     OPC_6502_35,
2946     OPC_6502_36,
2947     OPC_6502_37,
2948     OPC_6502_38,
2949     OPC_6502_39,
2950     OPC_6502_3A,
2951     OPC_6502_3B,
2952     OPC_6502_3C,
2953     OPC_6502_3D,
2954     OPC_6502_3E,
2955     OPC_6502_3F,
2956     OPC_6502_40,
2957     OPC_6502_41,
2958     OPC_6502_42,
2959     OPC_6502_43,
2960     OPC_6502_44,
2961     OPC_6502_45,
2962     OPC_6502_46,
2963     OPC_6502_47,
2964     OPC_6502_48,
2965     OPC_6502_49,
2966     OPC_6502_4A,
2967     OPC_6502_4B,
2968     OPC_6502_4C,
2969     OPC_6502_4D,
2970     OPC_6502_4E,
2971     OPC_6502_4F,
2972     OPC_6502_50,
2973     OPC_6502_51,
2974     OPC_6502_52,
2975     OPC_6502_53,
2976     OPC_6502_54,
2977     OPC_6502_55,
2978     OPC_6502_56,
2979     OPC_6502_57,
2980     OPC_6502_58,
2981     OPC_6502_59,
2982     OPC_6502_5A,
2983     OPC_6502_5B,
2984     OPC_6502_5C,
2985     OPC_6502_5D,
2986     OPC_6502_5E,
2987     OPC_6502_5F,
2988     OPC_6502_60,
2989     OPC_6502_61,
2990     OPC_6502_62,
2991     OPC_6502_63,
2992     OPC_6502_64,
2993     OPC_6502_65,
2994     OPC_6502_66,
2995     OPC_6502_67,
2996     OPC_6502_68,
2997     OPC_6502_69,
2998     OPC_6502_6A,
2999     OPC_6502_6B,
3000     OPC_6502_6C,
3001     OPC_6502_6D,
3002     OPC_6502_6E,
3003     OPC_6502_6F,
3004     OPC_6502_70,
3005     OPC_6502_71,
3006     OPC_6502_72,
3007     OPC_6502_73,
3008     OPC_6502_74,
3009     OPC_6502_75,
3010     OPC_6502_76,
3011     OPC_6502_77,
3012     OPC_6502_78,
3013     OPC_6502_79,
3014     OPC_6502_7A,
3015     OPC_6502_7B,
3016     OPC_6502_7C,
3017     OPC_6502_7D,
3018     OPC_6502_7E,
3019     OPC_6502_7F,
3020     OPC_6502_80,
3021     OPC_6502_81,
3022     OPC_6502_82,
3023     OPC_6502_83,
3024     OPC_6502_84,
3025     OPC_6502_85,
3026     OPC_6502_86,
3027     OPC_6502_87,
3028     OPC_6502_88,
3029     OPC_6502_89,
3030     OPC_6502_8A,
3031     OPC_6502_8B,
3032     OPC_6502_8C,
3033     OPC_6502_8D,
3034     OPC_6502_8E,
3035     OPC_6502_8F,
3036     OPC_6502_90,
3037     OPC_6502_91,
3038     OPC_6502_92,
3039     OPC_6502_93,
3040     OPC_6502_94,
3041     OPC_6502_95,
3042     OPC_6502_96,
3043     OPC_6502_97,
3044     OPC_6502_98,
3045     OPC_6502_99,
3046     OPC_6502_9A,
3047     OPC_6502_9B,
3048     OPC_6502_9C,
3049     OPC_6502_9D,
3050     OPC_6502_9E,
3051     OPC_6502_9F,
3052     OPC_6502_A0,
3053     OPC_6502_A1,
3054     OPC_6502_A2,
3055     OPC_6502_A3,
3056     OPC_6502_A4,
3057     OPC_6502_A5,
3058     OPC_6502_A6,
3059     OPC_6502_A7,
3060     OPC_6502_A8,
3061     OPC_6502_A9,
3062     OPC_6502_AA,
3063     OPC_6502_AB,
3064     OPC_6502_AC,
3065     OPC_6502_AD,
3066     OPC_6502_AE,
3067     OPC_6502_AF,
3068     OPC_6502_B0,
3069     OPC_6502_B1,
3070     OPC_6502_B2,
3071     OPC_6502_B3,
3072     OPC_6502_B4,
3073     OPC_6502_B5,
3074     OPC_6502_B6,
3075     OPC_6502_B7,
3076     OPC_6502_B8,
3077     OPC_6502_B9,
3078     OPC_6502_BA,
3079     OPC_6502_BB,
3080     OPC_6502_BC,
3081     OPC_6502_BD,
3082     OPC_6502_BE,
3083     OPC_6502_BF,
3084     OPC_6502_C0,
3085     OPC_6502_C1,
3086     OPC_6502_C2,
3087     OPC_6502_C3,
3088     OPC_6502_C4,
3089     OPC_6502_C5,
3090     OPC_6502_C6,
3091     OPC_6502_C7,
3092     OPC_6502_C8,
3093     OPC_6502_C9,
3094     OPC_6502_CA,
3095     OPC_6502_CB,
3096     OPC_6502_CC,
3097     OPC_6502_CD,
3098     OPC_6502_CE,
3099     OPC_6502_CF,
3100     OPC_6502_D0,
3101     OPC_6502_D1,
3102     OPC_6502_D2,
3103     OPC_6502_D3,
3104     OPC_6502_D4,
3105     OPC_6502_D5,
3106     OPC_6502_D6,
3107     OPC_6502_D7,
3108     OPC_6502_D8,
3109     OPC_6502_D9,
3110     OPC_6502_DA,
3111     OPC_6502_DB,
3112     OPC_6502_DC,
3113     OPC_6502_DD,
3114     OPC_6502_DE,
3115     OPC_6502_DF,
3116     OPC_6502_E0,
3117     OPC_6502_E1,
3118     OPC_6502_E2,
3119     OPC_6502_E3,
3120     OPC_6502_E4,
3121     OPC_6502_E5,
3122     OPC_6502_E6,
3123     OPC_6502_E7,
3124     OPC_6502_E8,
3125     OPC_6502_E9,
3126     OPC_6502_EA,
3127     OPC_6502_EB,
3128     OPC_6502_EC,
3129     OPC_6502_ED,
3130     OPC_6502_EE,
3131     OPC_6502_EF,
3132     OPC_6502_F0,
3133     OPC_6502_F1,
3134     OPC_6502_F2,
3135     OPC_6502_F3,
3136     OPC_6502_F4,
3137     OPC_6502_F5,
3138     OPC_6502_F6,
3139     OPC_6502_F7,
3140     OPC_6502_F8,
3141     OPC_6502_F9,
3142     OPC_6502_FA,
3143     OPC_6502_FB,
3144     OPC_6502_FC,
3145     OPC_6502_FD,
3146     OPC_6502_FE,
3147     OPC_6502_FF,
3148 };
3149
3150
3151
3152 /*****************************************************************************/
3153 /*                                   Code                                    */
3154 /*****************************************************************************/
3155
3156
3157
3158 void RunCPU (void)
3159 /* Run the CPU */
3160 {
3161     while (!CPUHalted) {
3162
3163         /* Get the next opcode */
3164         unsigned char B = 0x00;
3165
3166         /* Execute it */
3167         OPCTable[B] ();
3168
3169         /* Count cycles */
3170         TotalCycles += Cycles;
3171     }
3172 }
3173
3174
3175