/*
** Nofrendo (c) 1998-2000 Matthew Conte (matt@conte.com)
**
**
** This program is free software; you can redistribute it and/or
** modify it under the terms of version 2 of the GNU Library General 
** Public License as published by the Free Software Foundation.
**
** This program is distributed in the hope that it will be useful, 
** but WITHOUT ANY WARRANTY; without even the implied warranty of
** MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU 
** Library General Public License for more details.  To obtain a 
** copy of the GNU Library General Public License, write to the Free 
** Software Foundation, Inc., 675 Mass Ave, Cambridge, MA 02139, USA.
**
** Any permitted reproduction of these routines, in whole or in part,
** must bear this legend.
**
**
** nes6502.c
**
** NES custom 6502 (2A03) CPU implementation
** $Id$
*/


#include "types.h"
#include "nes6502.h"
#include "dis6502.h"
#include <stdio.h>


#define  ADD_CYCLES(x)     instruction_cycles += (x)
#define  INC_CYCLES()      instruction_cycles++
/* #define  ADD_CYCLES(x)  remaining_cycles -= (x) */
/* #define  INC_CYCLES()   remaining_cycles-- */

/*
** Check to see if an index reg addition overflowed to next page
*/
#define CHECK_INDEX_OVERFLOW(addr, reg) \
{ \
   if ((uint8) (addr) < (reg)) \
      INC_CYCLES(); \
}

/*
** Addressing mode macros
*/

#define NO_READ(value)          /* empty */

#define IMMEDIATE_BYTE(value) \
{ \
   value = bank_readbyte(PC++); \
}


#define ABSOLUTE_ADDR(address) \
{ \
   address = bank_readaddress(PC); \
   PC += 2; \
}

#define ABSOLUTE(address, value) \
{ \
   ABSOLUTE_ADDR(address); \
   value = mem_read(address); \
}

#define ABSOLUTE_BYTE(value) \
{ \
   ABSOLUTE(temp, value); \
}

#define ABS_IND_X_ADDR(address) \
{ \
   address = (bank_readaddress(PC) + X) & 0xFFFF; \
   PC += 2; \
   CHECK_INDEX_OVERFLOW(address, X); \
}

#define ABS_IND_X(address, value) \
{ \
   ABS_IND_X_ADDR(address); \
   value = mem_read(address); \
}

#define ABS_IND_X_BYTE(value) \
{ \
   ABS_IND_X(temp, value); \
}

#define ABS_IND_Y_ADDR(address) \
{ \
   address = (bank_readaddress(PC) + Y) & 0xFFFF; \
   PC += 2; \
   CHECK_INDEX_OVERFLOW(address, Y); \
}

#define ABS_IND_Y(address, value) \
{ \
   ABS_IND_Y_ADDR(address); \
   value = mem_read(address); \
}

#define ABS_IND_Y_BYTE(value) \
{ \
   ABS_IND_Y(temp, value); \
}

#define ZERO_PAGE_ADDR(address) \
{ \
   IMMEDIATE_BYTE(address); \
}

#define ZERO_PAGE(address, value) \
{ \
   ZERO_PAGE_ADDR(address); \
   value = ZP_READ(address); \
}

#define ZERO_PAGE_BYTE(value) \
{ \
   ZERO_PAGE(btemp, value); \
}

/* Zero-page indexed Y doesn't really exist, just for LDX / STX */
#define ZP_IND_X_ADDR(address) \
{ \
   address = bank_readbyte(PC++) + X; \
}

#define ZP_IND_X(bAddr, value) \
{ \
   ZP_IND_X_ADDR(bAddr); \
   value = ZP_READ(bAddr); \
}

#define ZP_IND_X_BYTE(value) \
{ \
   ZP_IND_X(btemp, value); \
}

#define ZP_IND_Y_ADDR(address) \
{ \
   address = bank_readbyte(PC++) + Y; \
}

#define ZP_IND_Y(address, value) \
{ \
   ZP_IND_Y_ADDR(address); \
   value = ZP_READ(address); \
}

#define ZP_IND_Y_BYTE(value) \
{ \
   ZP_IND_Y(btemp, value); \
}

/*
** For conditional jump relative instructions
** (BCC, BCS, BEQ, BMI, BNE, BPL, BVC, BVS)
*/
#define RELATIVE_JUMP(cond) \
{ \
   if (cond) \
   { \
      IMMEDIATE_BYTE(btemp); \
      if (((int8) btemp + (uint8) PC) & 0xFF00) \
         ADD_CYCLES(4); \
      else \
         ADD_CYCLES(3); \
      PC += ((int8) btemp); \
   } \
   else \
   { \
      PC++; \
      ADD_CYCLES(2); \
   } \
}

/*
** This is actually indexed indirect, but I call it
** indirect X to avoid confusion
*/
#define INDIR_X_ADDR(address) \
{ \
   btemp = bank_readbyte(PC++) + X; \
   address = zp_address(btemp); \
}

#define INDIR_X(address, value) \
{ \
   INDIR_X_ADDR(address); \
   value = mem_read(address); \
}

#define INDIR_X_BYTE(value) \
{ \
   INDIR_X(temp, value); \
}

/*
** This is actually indirect indexed, but I call it
** indirect y to avoid confusion
*/
#define INDIR_Y_ADDR(address) \
{ \
   IMMEDIATE_BYTE(btemp); \
   address = (zp_address(btemp) + Y) & 0xFFFF; \
   /* ???? */ \
   CHECK_INDEX_OVERFLOW(address, Y); \
}

#define INDIR_Y(address, value) \
{ \
   INDIR_Y_ADDR(address); \
   value = mem_read(address); \
}

#define INDIR_Y_BYTE(value) \
{ \
   /*IMMEDIATE_BYTE(btemp); \
   temp = zp_address(btemp) + Y; \
   CHECK_INDEX_OVERFLOW(temp, Y); \
   value = mem_read(temp);*/ \
   INDIR_Y(temp, value); \
}


#define  JUMP(address)  PC = bank_readaddress((address))

/*
** Interrupt macros
*/
#define NMI() \
{ \
   PUSH(PC >> 8); \
   PUSH(PC & 0xFF); \
   CLEAR_FLAG(B_FLAG); \
   PUSH(P); \
   SET_FLAG(I_FLAG); \
   JUMP(NMI_VECTOR); \
   int_pending &= ~NMI_MASK; \
   ADD_CYCLES(INT_CYCLES); \
}

#define IRQ() \
{ \
   PUSH(PC >> 8); \
   PUSH(PC & 0xFF); \
   CLEAR_FLAG(B_FLAG); \
   PUSH(P); \
   SET_FLAG(I_FLAG); \
   JUMP(IRQ_VECTOR); \
   int_pending &= ~IRQ_MASK; \
   ADD_CYCLES(INT_CYCLES); \
}

/*
** Instruction macros
*/

/* Warning! NES CPU has no decimal mode, so by default this does no BCD! */
#ifdef NES6502_DECIMAL
#define ADC(cycles, read_func) \
{ \
   read_func(data); \
   if (P & D_FLAG) \
   { \
      temp = (A & 0x0F) + (data & 0x0F) + (P & C_FLAG); \
      if (temp >= 10) \
         temp = (temp - 10) | 0x10; \
      temp += (A & 0xF0) + (data & 0xF0); \
      TEST_AND_FLAG(0 == ((A + data + (P & C_FLAG)) & 0xFF), Z_FLAG); \
      TEST_AND_FLAG(temp & 0x80, N_FLAG); \
      TEST_AND_FLAG(((~(A ^ data)) & (A ^ temp) & 0x80), V_FLAG); \
      if (temp > 0x9F) \
         temp += 0x60; \
      TEST_AND_FLAG(temp > 0xFF, C_FLAG); \
      A = (uint8) temp; \
   } \
   else \
   { \
      temp = A + data + (P & C_FLAG); \
      /* Set C on carry */ \
      TEST_AND_FLAG(temp > 0xFF, C_FLAG); \
      /* Set V on overflow */ \
      TEST_AND_FLAG(((~(A ^ data)) & (A ^ temp) & 0x80), V_FLAG); \
      A = (uint8) temp; \
      SET_NZ_FLAGS(A); \
   }\
   ADD_CYCLES(cycles); \
}
#else
#define ADC(cycles, read_func) \
{ \
   read_func(data); \
   temp = A + data + (P & C_FLAG); \
   /* Set C on carry */ \
   TEST_AND_FLAG(temp > 0xFF, C_FLAG); \
   /* Set V on overflow */ \
   TEST_AND_FLAG(((~(A ^ data)) & (A ^ temp) & 0x80), V_FLAG); \
   A = (uint8) temp; \
   SET_NZ_FLAGS(A); \
   ADD_CYCLES(cycles); \
}
#endif /* NES6502_DECIMAL */

/* undocumented */
#define ANC(cycles, read_func) \
{ \
   read_func(data); \
   A &= data; \
   SET_NZ_FLAGS(A); \
   TEST_AND_FLAG(P & N_FLAG, C_FLAG); \
   ADD_CYCLES(cycles); \
}

#define AND(cycles, read_func) \
{ \
   read_func(data); \
   A &= data; \
   SET_NZ_FLAGS(A); \
   ADD_CYCLES(cycles); \
}

/* undocumented */
#define ANE(cycles, read_func) \
{ \
   read_func(data); \
   A = (A | 0xEE) & X & data; \
   SET_NZ_FLAGS(A); \
   ADD_CYCLES(cycles); \
}

/* undocumented */
#ifdef NES6502_DECIMAL
#define ARR(cycles, read_func) \
{ \
   read_func(data); \
   data &= A; \
   if (P & D_FLAG) \
   { \
      temp = (data >> 1) | ((P & C_FLAG) << 7); \
      SET_NZ_FLAGS(temp); \
      TEST_AND_FLAG((temp ^ data) & 0x40, V_FLAG); \
      if (((data & 0x0F) + (data & 0x01)) > 5) \
         temp = (temp & 0xF0) | ((temp + 0x6) & 0x0F); \
      if (((data & 0xF0) + (data & 0x10)) > 0x50) \
      { \
         temp = (temp & 0x0F) | ((temp + 0x60) & 0xF0); \
         SET_FLAG(C_FLAG); \
      } \
      else \
         CLEAR_FLAG(C_FLAG); \
      A = (uint8) temp; \
   } \
   else \
   { \
      A = (data >> 1) | ((P & C_FLAG) << 7); \
      SET_NZ_FLAGS(A); \
      TEST_AND_FLAG(A & 0x40, C_FLAG); \
      TEST_AND_FLAG(((A >> 6) ^ (A >> 5)) & 1, V_FLAG); \
   }\
   ADD_CYCLES(cycles); \
}
#else
#define ARR(cycles, read_func) \
{ \
   read_func(data); \
   data &= A; \
   A = (data >> 1) | ((P & C_FLAG) << 7); \
   SET_NZ_FLAGS(A); \
   TEST_AND_FLAG(A & 0x40, C_FLAG); \
   TEST_AND_FLAG((A >> 6) ^ (A >> 5), V_FLAG); \
   ADD_CYCLES(cycles); \
}
#endif /* NES6502_DECIMAL */

#define ASL(cycles, read_func, write_func, addr) \
{ \
   read_func(addr, data); \
   TEST_AND_FLAG(data & 0x80, C_FLAG); \
   data <<= 1; \
   write_func(addr, data); \
   SET_NZ_FLAGS(data); \
   ADD_CYCLES(cycles); \
}

#define ASL_A() \
{ \
   TEST_AND_FLAG(A & 0x80, C_FLAG); \
   A <<= 1; \
   SET_NZ_FLAGS(A); \
   ADD_CYCLES(2); \
}

/* undocumented */
#define ASR(cycles, read_func) \
{ \
   read_func(data); \
   data &= A; \
   TEST_AND_FLAG(data & 0x01, C_FLAG); \
   A = data >> 1; \
   SET_NZ_FLAGS(A); \
   ADD_CYCLES(cycles); \
}

#define BCC() \
{ \
   RELATIVE_JUMP((IS_FLAG_CLEAR(C_FLAG))); \
}

#define BCS() \
{ \
   RELATIVE_JUMP((IS_FLAG_SET(C_FLAG))); \
}

#define BEQ() \
{ \
   RELATIVE_JUMP((IS_FLAG_SET(Z_FLAG))); \
}

#define BIT(cycles, read_func) \
{ \
   read_func(data); \
   TEST_AND_FLAG(0 == (data & A), Z_FLAG);\
   CLEAR_FLAG(N_FLAG | V_FLAG); \
   /* move bit 7/6 of data into N/V flags */ \
   SET_FLAG(data & (N_FLAG | V_FLAG)); \
   ADD_CYCLES(cycles); \
}

#define BMI() \
{ \
   RELATIVE_JUMP((IS_FLAG_SET(N_FLAG))); \
}

#define BNE() \
{ \
   RELATIVE_JUMP((IS_FLAG_CLEAR(Z_FLAG))); \
}

#define BPL() \
{ \
   RELATIVE_JUMP((IS_FLAG_CLEAR(N_FLAG))); \
}

/* Software interrupt type thang */
#define BRK() \
{ \
   PC++; \
   PUSH(PC >> 8); \
   PUSH(PC & 0xFF); \
   SET_FLAG(B_FLAG); \
   PUSH(P); \
   SET_FLAG(I_FLAG); \
   JUMP(IRQ_VECTOR); \
   ADD_CYCLES(7); \
}

#define BVC() \
{ \
   RELATIVE_JUMP((IS_FLAG_CLEAR(V_FLAG))); \
}

#define BVS() \
{ \
   RELATIVE_JUMP((IS_FLAG_SET(V_FLAG))); \
}

#define CLC() \
{ \
   CLEAR_FLAG(C_FLAG); \
   ADD_CYCLES(2); \
}

#define CLD() \
{ \
   CLEAR_FLAG(D_FLAG); \
   ADD_CYCLES(2); \
}

#define CLI() \
{ \
   CLEAR_FLAG(I_FLAG); \
   ADD_CYCLES(2); \
}

#define CLV() \
{ \
   CLEAR_FLAG(V_FLAG); \
   ADD_CYCLES(2); \
}

/* TODO: ick! */
#define _COMPARE(reg, value) \
{ \
   temp = (reg) - (value); \
   /* C is clear when data > A */ \
   TEST_AND_FLAG(0 == (temp & 0x8000), C_FLAG); \
   SET_NZ_FLAGS((uint8) temp); /* handles Z flag */ \
}

#define CMP(cycles, read_func) \
{ \
   read_func(data); \
   _COMPARE(A, data); \
   ADD_CYCLES(cycles); \
}

#define CPX(cycles, read_func) \
{ \
   read_func(data); \
   _COMPARE(X, data); \
   ADD_CYCLES(cycles); \
}

#define CPY(cycles, read_func) \
{ \
   read_func(data); \
   _COMPARE(Y, data); \
   ADD_CYCLES(cycles); \
}

/* undocumented */
#define DCP(cycles, read_func, write_func, addr) \
{ \
   read_func(addr, data); \
   data--; \
   write_func(addr, data); \
   CMP(cycles, NO_READ); \
}

#define DEC(cycles, read_func, write_func, addr) \
{ \
   read_func(addr, data); \
   data--; \
   write_func(addr, data); \
   SET_NZ_FLAGS(data); \
   ADD_CYCLES(cycles); \
}

#define DEX() \
{ \
   X--; \
   SET_NZ_FLAGS(X); \
   ADD_CYCLES(2); \
}

#define DEY() \
{ \
   Y--; \
   SET_NZ_FLAGS(Y); \
   ADD_CYCLES(2); \
}

/* undocumented (double-NOP) */
#define DOP(cycles) \
{ \
   PC++; \
   ADD_CYCLES(cycles); \
}

#define EOR(cycles, read_func) \
{ \
   read_func(data); \
   A ^= data; \
   SET_NZ_FLAGS(A); \
   ADD_CYCLES(cycles); \
}

#define INC(cycles, read_func, write_func, addr) \
{ \
   read_func(addr, data); \
   data++; \
   write_func(addr, data); \
   SET_NZ_FLAGS(data); \
   ADD_CYCLES(cycles); \
}

#define INX() \
{ \
   X++; \
   SET_NZ_FLAGS(X); \
   ADD_CYCLES(2); \
}

#define INY() \
{ \
   Y++; \
   SET_NZ_FLAGS(Y); \
   ADD_CYCLES(2); \
}

/* undocumented */
#define ISB(cycles, read_func, write_func, addr) \
{ \
   read_func(addr, data); \
   data++; \
   write_func(addr, data); \
   SBC(cycles, NO_READ); \
}

#ifdef NES6502_TESTOPS
#define JAM() \
{ \
   cpu_Jam(); \
}
#elif defined(NSF_PLAYER)
#define JAM() \
{ \
}
#else
#define JAM() \
{ \
   char jambuf[20]; \
   sprintf(jambuf, "JAM: PC=$%04X", PC); \
   ASSERT_MSG(jambuf); \
   ADD_CYCLES(2); \
}
#endif /* NES6502_TESTOPS */

#define JMP_INDIRECT() \
{ \
   temp = bank_readaddress(PC); \
   /* bug in crossing page boundaries */ \
   if (0xFF == (uint8) temp) \
      PC = (bank_readbyte(temp & ~0xFF) << 8) | bank_readbyte(temp); \
   else \
      JUMP(temp); \
   ADD_CYCLES(5); \
}

#define JMP_ABSOLUTE() \
{ \
   JUMP(PC); \
   ADD_CYCLES(3); \
}

#define JSR() \
{ \
   PC++; \
   PUSH(PC >> 8); \
   PUSH(PC & 0xFF); \
   JUMP(PC - 1); \
   ADD_CYCLES(6); \
}

/* undocumented */
#define LAS(cycles, read_func) \
{ \
   read_func(data); \
   A = X = S = (S & data); \
   SET_NZ_FLAGS(A); \
   ADD_CYCLES(cycles); \
}

/* undocumented */
#define LAX(cycles, read_func) \
{ \
   read_func(A); \
   X = A; \
   SET_NZ_FLAGS(A); \
   ADD_CYCLES(cycles); \
}

#define LDA(cycles, read_func) \
{ \
   read_func(A); \
   SET_NZ_FLAGS(A); \
   ADD_CYCLES(cycles); \
}

#define LDX(cycles, read_func) \
{ \
   read_func(X); \
   SET_NZ_FLAGS(X);\
   ADD_CYCLES(cycles); \
}

#define LDY(cycles, read_func) \
{ \
   read_func(Y); \
   SET_NZ_FLAGS(Y);\
   ADD_CYCLES(cycles); \
}

#define LSR(cycles, read_func, write_func, addr) \
{ \
   read_func(addr, data); \
   TEST_AND_FLAG(data & 0x01, C_FLAG); \
   data >>= 1; \
   write_func(addr, data); \
   SET_NZ_FLAGS(data); \
   ADD_CYCLES(cycles); \
}

#define LSR_A() \
{ \
   TEST_AND_FLAG(A & 0x01, C_FLAG); \
   A >>= 1; \
   SET_NZ_FLAGS(A); \
   ADD_CYCLES(2); \
}

/* undocumented */
#define LXA(cycles, read_func) \
{ \
   read_func(data); \
   A = X = ((A | 0xEE) & data); \
   SET_NZ_FLAGS(A); \
   ADD_CYCLES(cycles); \
}

#define NOP() \
{ \
   ADD_CYCLES(2); \
}

#define ORA(cycles, read_func) \
{ \
   read_func(data); \
   A |= data; \
   SET_NZ_FLAGS(A);\
   ADD_CYCLES(cycles); \
}

#define PHA() \
{ \
   PUSH(A); \
   ADD_CYCLES(3); \
}

#define PHP() \
{ \
   /* B flag is pushed on stack as well */ \
   PUSH((P | B_FLAG)); \
   ADD_CYCLES(3); \
}

#define PLA() \
{ \
   A = PULL(); \
   SET_NZ_FLAGS(A); \
   ADD_CYCLES(4); \
}

#define PLP() \
{ \
   P = PULL(); \
   SET_FLAG(R_FLAG); /* ensure reserved flag is set */ \
   ADD_CYCLES(4); \
}

/* undocumented */
#define RLA(cycles, read_func, write_func, addr) \
{ \
   read_func(addr, data); \
   if (P & C_FLAG) \
   { \
      TEST_AND_FLAG(data & 0x80, C_FLAG); \
      data = (data << 1) | 1; \
   } \
   else \
   { \
      TEST_AND_FLAG(data & 0x80, C_FLAG); \
      data <<= 1; \
   } \
   write_func(addr, data); \
   A &= data; \
   SET_NZ_FLAGS(A); \
   ADD_CYCLES(cycles); \
}

/* 9-bit rotation (carry flag used for rollover) */
#define ROL(cycles, read_func, write_func, addr) \
{ \
   read_func(addr, data); \
   if (P & C_FLAG) \
   { \
      TEST_AND_FLAG(data & 0x80, C_FLAG); \
      data = (data << 1) | 1; \
   } \
   else \
   { \
      TEST_AND_FLAG(data & 0x80, C_FLAG); \
      data <<= 1; \
   } \
   write_func(addr, data); \
   SET_NZ_FLAGS(data); \
   ADD_CYCLES(cycles); \
}

#define ROL_A() \
{ \
   if (P & C_FLAG) \
   { \
      TEST_AND_FLAG(A & 0x80, C_FLAG); \
      A = (A << 1) | 1; \
   } \
   else \
   { \
      TEST_AND_FLAG(A & 0x80, C_FLAG); \
      A <<= 1; \
   } \
   SET_NZ_FLAGS(A); \
   ADD_CYCLES(2); \
}

#define ROR(cycles, read_func, write_func, addr) \
{ \
   read_func(addr, data); \
   if (P & C_FLAG) \
   { \
      TEST_AND_FLAG(data & 1, C_FLAG); \
      data = (data >> 1) | 0x80; \
   } \
   else \
   { \
      TEST_AND_FLAG(data & 1, C_FLAG); \
      data >>= 1; \
   } \
   write_func(addr, data); \
   SET_NZ_FLAGS(data); \
   ADD_CYCLES(cycles); \
}

#define ROR_A() \
{ \
   if (P & C_FLAG) \
   { \
      TEST_AND_FLAG(A & 1, C_FLAG); \
      A = (A >> 1) | 0x80; \
   } \
   else \
   { \
      TEST_AND_FLAG(A & 1, C_FLAG); \
      A >>= 1; \
   } \
   SET_NZ_FLAGS(A); \
   ADD_CYCLES(2); \
}

/* undocumented */
#define RRA(cycles, read_func, write_func, addr) \
{ \
   read_func(addr, data); \
   if (P & C_FLAG) \
   { \
      TEST_AND_FLAG(data & 1, C_FLAG); \
      data = (data >> 1) | 0x80; \
   } \
   else \
   { \
      TEST_AND_FLAG(data & 1, C_FLAG); \
      data >>= 1; \
   } \
   write_func(addr, data); \
   ADC(cycles, NO_READ); \
}

#define RTI() \
{ \
   P = PULL(); \
   SET_FLAG(R_FLAG); /* ensure reserved flag is set */ \
   PC = PULL(); \
   PC |= PULL() << 8; \
   ADD_CYCLES(6); \
}

#define RTS() \
{ \
   PC = PULL(); \
   PC = (PC | (PULL() << 8)) + 1; \
   ADD_CYCLES(6); \
}

/* undocumented */
#define SAX(cycles, read_func, write_func, addr) \
{ \
   read_func(addr); \
   data = A & X; \
   write_func(addr, data); \
   ADD_CYCLES(cycles); \
}

/* Warning! NES CPU has no decimal mode, so by default this does no BCD! */
#ifdef NES6502_DECIMAL
#define SBC(cycles, read_func) \
{ \
   read_func(data); \
   /* NOT(C) is considered borrow */ \
   temp = A - data - ((P & C_FLAG) ^ C_FLAG); \
   if (P & D_FLAG) \
   { \
      uint8 al, ah; \
      al = (A & 0x0F) - (data & 0x0F) - ((P & C_FLAG) ^ C_FLAG); \
      ah = (A >> 4) - (data >> 4); \
      if (al & 0x10) \
      { \
         al -= 6; \
         ah--; \
      } \
      if (ah & 0x10) \
         ah -= 6; \
      TEST_AND_FLAG(temp < 0x100, C_FLAG); \
      TEST_AND_FLAG(((A ^ temp) & 0x80) && ((A ^ data) & 0x80), V_FLAG); \
      SET_NZ_FLAGS(temp & 0xFF); \
      A = (ah << 4) | (al & 0x0F); \
   } \
   else \
   { \
      TEST_AND_FLAG(((A ^ temp) & 0x80) && ((A ^ data) & 0x80), V_FLAG); \
      TEST_AND_FLAG(temp < 0x100, C_FLAG); \
      A = (uint8) temp; \
      SET_NZ_FLAGS(A & 0xFF); \
   } \
   ADD_CYCLES(cycles); \
}
#else
#define SBC(cycles, read_func) \
{ \
   read_func(data); \
   temp = A - data - ((P & C_FLAG) ^ C_FLAG); \
   TEST_AND_FLAG(((A ^ data) & (A ^ temp) & 0x80), V_FLAG); \
   TEST_AND_FLAG(temp < 0x100, C_FLAG); \
   A = (uint8) temp; \
   SET_NZ_FLAGS(A); \
   ADD_CYCLES(cycles); \
}
#endif /* NES6502_DECIMAL */

/* undocumented */
#define SBX(cycles, read_func) \
{ \
   read_func(data); \
   temp = (A & X) - data; \
   TEST_AND_FLAG(temp < 0x100, C_FLAG); \
   X = temp & 0xFF; \
   SET_NZ_FLAGS(X); \
   ADD_CYCLES(cycles); \
}

#define SEC_6502() \
{ \
   SET_FLAG(C_FLAG); \
   ADD_CYCLES(2); \
}

#define SED() \
{ \
   SET_FLAG(D_FLAG); \
   ADD_CYCLES(2); \
}

#define SEI() \
{ \
   SET_FLAG(I_FLAG); \
   ADD_CYCLES(2); \
}

/* undocumented */
#define SHA(cycles, read_func, write_func, addr) \
{ \
   read_func(addr); \
   data = A & X & ((uint8) ((addr >> 8) + 1)); \
   write_func(addr, data); \
   ADD_CYCLES(cycles); \
}

/* undocumented */
#define SHS(cycles, read_func, write_func, addr) \
{ \
   read_func(addr); \
   S = A & X; \
   data = S & ((uint8) ((addr >> 8) + 1)); \
   write_func(addr, data); \
   ADD_CYCLES(cycles); \
}

/* undocumented */
#define SHX(cycles, read_func, write_func, addr) \
{ \
   read_func(addr); \
   data = X & ((uint8) ((addr >> 8) + 1)); \
   write_func(addr, data); \
   ADD_CYCLES(cycles); \
}

/* undocumented */
#define SHY(cycles, read_func, write_func, addr) \
{ \
   read_func(addr); \
   data = Y & ((uint8) ((addr >> 8 ) + 1)); \
   write_func(addr, data); \
   ADD_CYCLES(cycles); \
}

/* undocumented */
#define SLO(cycles, read_func, write_func, addr) \
{ \
   read_func(addr, data); \
   TEST_AND_FLAG(data & 0x80, C_FLAG); \
   data <<= 1; \
   write_func(addr, data); \
   A |= data; \
   SET_NZ_FLAGS(A); \
   ADD_CYCLES(cycles); \
}

/* unoffical */
#define SRE(cycles, read_func, write_func, addr) \
{ \
   read_func(addr, data); \
   TEST_AND_FLAG(data & 1, C_FLAG); \
   data >>= 1; \
   write_func(addr, data); \
   A ^= data; \
   SET_NZ_FLAGS(A); \
   ADD_CYCLES(cycles); \
}

#define STA(cycles, read_func, write_func, addr) \
{ \
   read_func(addr); \
   write_func(addr, A); \
   ADD_CYCLES(cycles); \
}

#define STX(cycles, read_func, write_func, addr) \
{ \
   read_func(addr); \
   write_func(addr, X); \
   ADD_CYCLES(cycles); \
}

#define STY(cycles, read_func, write_func, addr) \
{ \
   read_func(addr); \
   write_func(addr, Y); \
   ADD_CYCLES(cycles); \
}

#define TAX() \
{ \
   X = A; \
   SET_NZ_FLAGS(X);\
   ADD_CYCLES(2); \
}

#define TAY() \
{ \
   Y = A; \
   SET_NZ_FLAGS(Y);\
   ADD_CYCLES(2); \
}

/* undocumented (triple-NOP) */
#define TOP() \
{ \
   PC += 2; \
   ADD_CYCLES(4); \
}

#define TSX() \
{ \
   X = S; \
   SET_NZ_FLAGS(X);\
   ADD_CYCLES(2); \
}

#define TXA() \
{ \
   A = X; \
   SET_NZ_FLAGS(A);\
   ADD_CYCLES(2); \
}

#define TXS() \
{ \
   S = X; \
   ADD_CYCLES(2); \
}

#define TYA() \
{ \
   A = Y; \
   SET_NZ_FLAGS(A); \
   ADD_CYCLES(2); \
}


/*
** Stack and data fetching macros
*/

/* Set/clear/test bits in the flags register */
#define  SET_FLAG(mask)          P |= (mask)
#define  CLEAR_FLAG(mask)        P &= ~(mask)
#define  IS_FLAG_SET(mask)       (P & (mask))
#define  IS_FLAG_CLEAR(mask)     (0 == IS_FLAG_SET((mask)))

#define  TEST_AND_FLAG(test, mask) \
{ \
   if ((test)) \
      SET_FLAG((mask)); \
   else \
      CLEAR_FLAG((mask)); \
}


/*
** flag register helper macros
*/

/* register push/pull */
#ifdef NES6502_MEM_ACCESS_CTRL

# define  PUSH(value)             stack_push((S--),(value))
# define  PULL()                  stack_pull((++S))

#else

# define  PUSH(value)             stack_page[S--] = (uint8) (value)
# define  PULL()                  stack_page[++S]

#endif /* #ifdef NES6502_MEM_ACCESS_CTRL */

/* Sets the Z and N flags based on given data, taken from precomputed table */
#define  SET_NZ_FLAGS(value)     P &= ~(N_FLAG | Z_FLAG); \
                                 P |= flag_table[(value)]

#define  GET_GLOBAL_REGS() \
{ \
   PC = reg_PC; \
   A = reg_A; \
   X = reg_X; \
   Y = reg_Y; \
   P = reg_P; \
   S = reg_S; \
}

#define SET_LOCAL_REGS() \
{ \
   reg_PC = PC; \
   reg_A = A; \
   reg_X = X; \
   reg_Y = Y; \
   reg_P = P; \
   reg_S = S; \
}


/* static data */
static nes6502_memread *pmem_read, *pmr;
static nes6502_memwrite *pmem_write, *pmw;

/* lookup table for N/Z flags */
static uint8 flag_table[256];

/* internal critical CPU vars */
static uint32 reg_PC;
static uint8 reg_A, reg_P, reg_X, reg_Y, reg_S;
static uint8 int_pending;
static int dma_cycles;

/* execution cycle count (can be reset by user) */
static uint32 total_cycles = 0;

/* memory region pointers */
static uint8 *nes6502_banks[NES6502_NUMBANKS];
static uint8 *ram = NULL;
static uint8 *stack_page = NULL;

/* access flag for memory 
 * $$$ ben : I add this for the playing time calculation.
 * Only if compiled with NES6502_MEM_ACCESS.
 */
#ifdef NES6502_MEM_ACCESS_CTRL

uint8 *acc_nes6502_banks[NES6502_NUMBANKS];
static uint8 *acc_ram = NULL;
static uint8 *acc_stack_page = NULL;
uint8 nes6502_mem_access = 0;

/* $$$ ben :
 * Set memory access check flags, and store ORed frame global check
 * for music time calculation.
 */
static void
chk_mem_access (uint8 * access, int flags)
{
  uint8 oldchk = *access;

  if ((oldchk & flags) != flags) {
    nes6502_mem_access |= flags;
    *access = oldchk | flags;
  }
}

INLINE void
stack_push (uint8 s, uint8 v)
{
  chk_mem_access (acc_stack_page + s, NES6502_WRITE_ACCESS);
  stack_page[s] = v;
}

INLINE uint8
stack_pull (uint8 s)
{
  chk_mem_access (acc_stack_page + s, NES6502_READ_ACCESS);
  return stack_page[s];
}

INLINE uint8
zp_read (register uint32 addr)
{
  chk_mem_access (acc_ram + addr, NES6502_READ_ACCESS);
  return ram[addr];
}

INLINE void
zp_write (register uint32 addr, uint8 v)
{
  chk_mem_access (acc_ram + addr, NES6502_WRITE_ACCESS);
  ram[addr] = v;
}

#define  ZP_READ(addr)           zp_read((addr))
#define  ZP_WRITE(addr, value)   zp_write((addr),(value))

#define bank_readbyte(address) _bank_readbyte((address), NES6502_READ_ACCESS)
#define bank_readbyte_pc(address) _bank_readbyte((address), NES6502_EXE_ACCESS)

#else
# define chk_mem_access(access, flags)

/*
** Zero-page helper macros
*/
#define  ZP_READ(addr)           ram[(addr)]
#define  ZP_WRITE(addr, value)   ram[(addr)] = (uint8) (value)

#define bank_readbyte(address)    _bank_readbyte((address))
#define bank_readbyte_pc(address) _bank_readbyte((address))

#endif /* #ifdef NES6502_MEM_ACCESS_CTRL */

#ifdef NES6502_MEM_ACCESS_CTRL
int max_access[NES6502_NUMBANKS] =
    { 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0 };

INLINE uint8
_bank_readbyte (register uint32 address, const uint8 flags)
#else
INLINE uint8
_bank_readbyte (register uint32 address)
#endif
{
  ASSERT (nes6502_banks[address >> NES6502_BANKSHIFT]);

#ifdef NES6502_MEM_ACCESS_CTRL
  /* printf("chk_mem_access(acc_nes6502_banks[%d] + %d, %d)\n", address>>NES6502_BANKSHIFT, address & NES6502_BANKMASK, flags); */

  if ((address & NES6502_BANKMASK) > max_access[address >> NES6502_BANKSHIFT]) {
    max_access[address >> NES6502_BANKSHIFT] = address & NES6502_BANKMASK;
    /* printf("max_access[%d] increased to %d\n", address>>NES6502_BANKSHIFT, max_access[address>>NES6502_BANKSHIFT]); */
  }
#endif
  chk_mem_access (acc_nes6502_banks[address >> NES6502_BANKSHIFT]
      + (address & NES6502_BANKMASK), flags);

  return nes6502_banks[address >> NES6502_BANKSHIFT][address &
      NES6502_BANKMASK];
}


INLINE void
bank_writebyte (register uint32 address, register uint8 value)
{
  ASSERT (nes6502_banks[address >> NES6502_BANKSHIFT]);

#ifdef NES6502_MEM_ACCESS_CTRL
  /* printf("chk_mem_access(acc_nes6502_banks[%d] + %d, %d)\n", address>>NES6502_BANKSHIFT, address & NES6502_BANKMASK, NES6502_WRITE_ACCESS); */

  if ((address & NES6502_BANKMASK) > max_access[address >> NES6502_BANKSHIFT]) {
    max_access[address >> NES6502_BANKSHIFT] = address & NES6502_BANKMASK;
    /* printf("max_access[%d] increased to %d\n", address>>NES6502_BANKSHIFT, max_access[address>>NES6502_BANKSHIFT]); */
  }
#endif

  chk_mem_access (acc_nes6502_banks[address >> NES6502_BANKSHIFT]
      + (address & NES6502_BANKMASK), NES6502_WRITE_ACCESS);

  nes6502_banks[address >> NES6502_BANKSHIFT][address & NES6502_BANKMASK] =
      value;
}

/* Read a 16bit word */
#define READ_SNES_16(bank,offset) \
(\
   (offset) [ (uint8 *) (bank) ] |\
   ((unsigned int)( ((offset)+1) [ (uint8 *) (bank) ] ) << 8)\
)

INLINE uint32
zp_address (register uint8 address)
{
  chk_mem_access (acc_ram + address, NES6502_READ_ACCESS);
  chk_mem_access (acc_ram + address + 1, NES6502_READ_ACCESS);

#if defined (HOST_LITTLE_ENDIAN) && defined(HOST_UNALIGN_WORD)
  /* TODO: this fails if src address is $xFFF */
  /* TODO: this fails if host architecture doesn't support byte alignment */
  /*       $$$ ben : DONE */
  return (uint32) (*(uint16 *) (ram + address));
#elif defined(TARGET_CPU_PPC)
  return __lhbrx (ram, address);
#else
  return READ_SNES_16 (ram, address);
/*    uint32 x = (uint32) *(uint16 *)(ram + address); */
/*    return (x << 8) | (x >> 8); */
  /* #endif *//* TARGET_CPU_PPC */
#endif /* HOST_LITTLE_ENDIAN */
}

INLINE uint32
bank_readaddress (register uint32 address)
{

#ifdef NES6502_MEM_ACCESS_CTRL
  {
    const unsigned int offset = address & NES6502_BANKMASK;
    uint8 *addr = acc_nes6502_banks[address >> NES6502_BANKSHIFT];

    chk_mem_access (addr + offset + 0, NES6502_READ_ACCESS);
    chk_mem_access (addr + offset + 1, NES6502_READ_ACCESS);
  }
#endif

#if defined (HOST_LITTLE_ENDIAN) && defined(HOST_UNALIGN_WORD)
  /* TODO: this fails if src address is $xFFF */
  /* TODO: this fails if host architecture doesn't support byte alignment */
  /*       $$$ ben : DONE */
  return (uint32) (*(uint16 *) (nes6502_banks[address >> NES6502_BANKSHIFT] +
          (address & NES6502_BANKMASK)));
#elif defined(TARGET_CPU_PPC)
  return __lhbrx (nes6502_banks[address >> NES6502_BANKSHIFT],
      address & NES6502_BANKMASK);
#else
  {
    const unsigned int offset = address & NES6502_BANKMASK;

    return READ_SNES_16 (nes6502_banks[address >> NES6502_BANKSHIFT], offset);
  }
/*    uint32 x = (uint32) *(uint16 *)(nes6502_banks[address >> NES6502_BANKSHIFT] + (address & NES6502_BANKMASK)); */
/*    return (x << 8) | (x >> 8); */
  /* #endif *//* TARGET_CPU_PPC */
#endif /* HOST_LITTLE_ENDIAN */
}


/* read a byte of 6502 memory */
static uint8
mem_read (uint32 address)
{
  /* TODO: following cases are N2A03-specific */
  /* RAM */
  if (address < 0x800) {
    chk_mem_access (acc_ram + address, NES6502_READ_ACCESS);
    return ram[address];
  }
  /* always paged memory */
/*   else if (address >= 0x6000) */
  else if (address >= 0x8000) {
    return bank_readbyte (address);
  }
  /* check memory range handlers */
  else {
    for (pmr = pmem_read; pmr->min_range != 0xFFFFFFFF; pmr++) {
      if ((address >= pmr->min_range) && (address <= pmr->max_range))
        return pmr->read_func (address);
    }
  }

  /* return paged memory */
  return bank_readbyte (address);
}

/* write a byte of data to 6502 memory */
static void
mem_write (uint32 address, uint8 value)
{
  /* RAM */
  if (address < 0x800) {
    chk_mem_access (acc_ram + address, NES6502_WRITE_ACCESS);
    ram[address] = value;
    return;
  }
  /* check memory range handlers */
  else {
    for (pmw = pmem_write; pmw->min_range != 0xFFFFFFFF; pmw++) {
      if ((address >= pmw->min_range) && (address <= pmw->max_range)) {
        pmw->write_func (address, value);
        return;
      }
    }
  }

  /* write to paged memory */
  bank_writebyte (address, value);
}

/* set the current context */
void
nes6502_setcontext (nes6502_context * cpu)
{
  int loop;

  ASSERT (cpu);

  /* Set the page pointers */
  for (loop = 0; loop < NES6502_NUMBANKS; loop++) {
    nes6502_banks[loop] = cpu->mem_page[loop];
#ifdef NES6502_MEM_ACCESS_CTRL
    acc_nes6502_banks[loop] = cpu->acc_mem_page[loop];
#endif
  }

  ram = nes6502_banks[0];       /* quicker zero-page/RAM references */
  stack_page = ram + STACK_OFFSET;
#ifdef NES6502_MEM_ACCESS_CTRL
  acc_ram = acc_nes6502_banks[0];       /* quicker zero-page/RAM references */
  acc_stack_page = acc_ram + STACK_OFFSET;
#endif

  pmem_read = cpu->read_handler;
  pmem_write = cpu->write_handler;

  reg_PC = cpu->pc_reg;
  reg_A = cpu->a_reg;
  reg_P = cpu->p_reg;
  reg_X = cpu->x_reg;
  reg_Y = cpu->y_reg;
  reg_S = cpu->s_reg;
  int_pending = cpu->int_pending;
  dma_cycles = cpu->dma_cycles;
}

/* get the current context */
void
nes6502_getcontext (nes6502_context * cpu)
{
  int loop;

  /* Set the page pointers */
  for (loop = 0; loop < NES6502_NUMBANKS; loop++) {
    cpu->mem_page[loop] = nes6502_banks[loop];
#ifdef NES6502_MEM_ACCESS_CTRL
    cpu->acc_mem_page[loop] = acc_nes6502_banks[loop];
#endif
  }

  cpu->read_handler = pmem_read;
  cpu->write_handler = pmem_write;

  cpu->pc_reg = reg_PC;
  cpu->a_reg = reg_A;
  cpu->p_reg = reg_P;
  cpu->x_reg = reg_X;
  cpu->y_reg = reg_Y;
  cpu->s_reg = reg_S;
  cpu->int_pending = int_pending;
  cpu->dma_cycles = dma_cycles;
}

/* DMA a byte of data from ROM */
uint8
nes6502_getbyte (uint32 address)
{
  return bank_readbyte (address);
}

/* get number of elapsed cycles */
uint32
nes6502_getcycles (boolean reset_flag)
{
  uint32 cycles = total_cycles;

  if (reset_flag)
    total_cycles = 0;

  return cycles;
}


/* Execute instructions until count expires
**
** Returns the number of cycles *actually* executed
** (note that this can be from 0-6 cycles more than you wanted)
*/
int
nes6502_execute (int remaining_cycles)
{
  int instruction_cycles, old_cycles = total_cycles;
  uint32 temp, addr;            /* for macros */
  uint32 PC;
  uint8 A, X, Y, P, S;
  uint8 opcode, data;
  uint8 btemp, baddr;           /* for macros */

  GET_GLOBAL_REGS ();

#ifdef NES6502_MEM_ACCESS_CTRL
  /* reset global memory access for this execute loop. */
  nes6502_mem_access = 0;
#endif

  /* Continue until we run out of cycles */


  while (remaining_cycles > 0) {
    instruction_cycles = 0;

    /* check for DMA cycle burning */
    if (dma_cycles) {
      if (remaining_cycles <= dma_cycles) {
        dma_cycles -= remaining_cycles;
        total_cycles += remaining_cycles;
        goto _execute_done;
      } else {
        remaining_cycles -= dma_cycles;
        total_cycles += dma_cycles;
        dma_cycles = 0;
      }
    }

    if (int_pending) {
      /* NMI has highest priority */
      if (int_pending & NMI_MASK) {
        NMI ();
      }
      /* IRQ has lowest priority */
      else {                    /* if (int_pending & IRQ_MASK) */

        if (IS_FLAG_CLEAR (I_FLAG))
          IRQ ();
      }
    }

    /* Fetch instruction */
    /* nes6502_disasm(PC, P, A, X, Y, S); */

    opcode = bank_readbyte_pc (PC++);

    /* Execute instruction */

    switch (opcode) {
      case 0x00:               /* BRK */
        BRK ();
        break;

      case 0x01:               /* ORA ($nn,X) */
        ORA (6, INDIR_X_BYTE);
        break;

        /* JAM */
      case 0x02:               /* JAM */
      case 0x12:               /* JAM */
      case 0x22:               /* JAM */
      case 0x32:               /* JAM */
      case 0x42:               /* JAM */
      case 0x52:               /* JAM */
      case 0x62:               /* JAM */
      case 0x72:               /* JAM */
      case 0x92:               /* JAM */
      case 0xB2:               /* JAM */
      case 0xD2:               /* JAM */
      case 0xF2:               /* JAM */
        JAM ();
        /* kill switch for CPU emulation */
        goto _execute_done;

      case 0x03:               /* SLO ($nn,X) */
        SLO (8, INDIR_X, mem_write, addr);
        break;

      case 0x04:               /* NOP $nn */
      case 0x44:               /* NOP $nn */
      case 0x64:               /* NOP $nn */
        DOP (3);
        break;

      case 0x05:               /* ORA $nn */
        ORA (3, ZERO_PAGE_BYTE);
        break;

      case 0x06:               /* ASL $nn */
        ASL (5, ZERO_PAGE, ZP_WRITE, baddr);
        break;

      case 0x07:               /* SLO $nn */
        SLO (5, ZERO_PAGE, ZP_WRITE, baddr);
        break;

      case 0x08:               /* PHP */
        PHP ();
        break;

      case 0x09:               /* ORA #$nn */
        ORA (2, IMMEDIATE_BYTE);
        break;

      case 0x0A:               /* ASL A */
        ASL_A ();
        break;

      case 0x0B:               /* ANC #$nn */
        ANC (2, IMMEDIATE_BYTE);
        break;

      case 0x0C:               /* NOP $nnnn */
        TOP ();
        break;

      case 0x0D:               /* ORA $nnnn */
        ORA (4, ABSOLUTE_BYTE);
        break;

      case 0x0E:               /* ASL $nnnn */
        ASL (6, ABSOLUTE, mem_write, addr);
        break;

      case 0x0F:               /* SLO $nnnn */
        SLO (6, ABSOLUTE, mem_write, addr);
        break;

      case 0x10:               /* BPL $nnnn */
        BPL ();
        break;

      case 0x11:               /* ORA ($nn),Y */
        ORA (5, INDIR_Y_BYTE);
        break;

      case 0x13:               /* SLO ($nn),Y */
        SLO (8, INDIR_Y, mem_write, addr);
        break;

      case 0x14:               /* NOP $nn,X */
      case 0x34:               /* NOP */
      case 0x54:               /* NOP $nn,X */
      case 0x74:               /* NOP $nn,X */
      case 0xD4:               /* NOP $nn,X */
      case 0xF4:               /* NOP ($nn,X) */
        DOP (4);
        break;

      case 0x15:               /* ORA $nn,X */
        ORA (4, ZP_IND_X_BYTE);
        break;

      case 0x16:               /* ASL $nn,X */
        ASL (6, ZP_IND_X, ZP_WRITE, baddr);
        break;

      case 0x17:               /* SLO $nn,X */
        SLO (6, ZP_IND_X, ZP_WRITE, baddr);
        break;

      case 0x18:               /* CLC */
        CLC ();
        break;

      case 0x19:               /* ORA $nnnn,Y */
        ORA (4, ABS_IND_Y_BYTE);
        break;

      case 0x1A:               /* NOP */
      case 0x3A:               /* NOP */
      case 0x5A:               /* NOP */
      case 0x7A:               /* NOP */
      case 0xDA:               /* NOP */
      case 0xFA:               /* NOP */
        NOP ();
        break;

      case 0x1B:               /* SLO $nnnn,Y */
        SLO (7, ABS_IND_Y, mem_write, addr);
        break;

      case 0x1C:               /* NOP $nnnn,X */
      case 0x3C:               /* NOP $nnnn,X */
      case 0x5C:               /* NOP $nnnn,X */
      case 0x7C:               /* NOP $nnnn,X */
      case 0xDC:               /* NOP $nnnn,X */
      case 0xFC:               /* NOP $nnnn,X */
        TOP ();
        break;

      case 0x1D:               /* ORA $nnnn,X */
        ORA (4, ABS_IND_X_BYTE);
        break;

      case 0x1E:               /* ASL $nnnn,X */
        ASL (7, ABS_IND_X, mem_write, addr);
        break;

      case 0x1F:               /* SLO $nnnn,X */
        SLO (7, ABS_IND_X, mem_write, addr);
        break;

      case 0x20:               /* JSR $nnnn */
        JSR ();
        break;

      case 0x21:               /* AND ($nn,X) */
        AND (6, INDIR_X_BYTE);
        break;

      case 0x23:               /* RLA ($nn,X) */
        RLA (8, INDIR_X, mem_write, addr);
        break;

      case 0x24:               /* BIT $nn */
        BIT (3, ZERO_PAGE_BYTE);
        break;

      case 0x25:               /* AND $nn */
        AND (3, ZERO_PAGE_BYTE);
        break;

      case 0x26:               /* ROL $nn */
        ROL (5, ZERO_PAGE, ZP_WRITE, baddr);
        break;

      case 0x27:               /* RLA $nn */
        RLA (5, ZERO_PAGE, ZP_WRITE, baddr);
        break;

      case 0x28:               /* PLP */
        PLP ();
        break;

      case 0x29:               /* AND #$nn */
        AND (2, IMMEDIATE_BYTE);
        break;

      case 0x2A:               /* ROL A */
        ROL_A ();
        break;

      case 0x2B:               /* ANC #$nn */
        ANC (2, IMMEDIATE_BYTE);
        break;

      case 0x2C:               /* BIT $nnnn */
        BIT (4, ABSOLUTE_BYTE);
        break;

      case 0x2D:               /* AND $nnnn */
        AND (4, ABSOLUTE_BYTE);
        break;

      case 0x2E:               /* ROL $nnnn */
        ROL (6, ABSOLUTE, mem_write, addr);
        break;

      case 0x2F:               /* RLA $nnnn */
        RLA (6, ABSOLUTE, mem_write, addr);
        break;

      case 0x30:               /* BMI $nnnn */
        BMI ();
        break;

      case 0x31:               /* AND ($nn),Y */
        AND (5, INDIR_Y_BYTE);
        break;

      case 0x33:               /* RLA ($nn),Y */
        RLA (8, INDIR_Y, mem_write, addr);
        break;

      case 0x35:               /* AND $nn,X */
        AND (4, ZP_IND_X_BYTE);
        break;

      case 0x36:               /* ROL $nn,X */
        ROL (6, ZP_IND_X, ZP_WRITE, baddr);
        break;

      case 0x37:               /* RLA $nn,X */
        RLA (6, ZP_IND_X, ZP_WRITE, baddr);
        break;

      case 0x38:               /* SEC */
        SEC_6502 ();
        break;

      case 0x39:               /* AND $nnnn,Y */
        AND (4, ABS_IND_Y_BYTE);
        break;

      case 0x3B:               /* RLA $nnnn,Y */
        RLA (7, ABS_IND_Y, mem_write, addr);
        break;

      case 0x3D:               /* AND $nnnn,X */
        AND (4, ABS_IND_X_BYTE);
        break;

      case 0x3E:               /* ROL $nnnn,X */
        ROL (7, ABS_IND_X, mem_write, addr);
        break;

      case 0x3F:               /* RLA $nnnn,X */
        RLA (7, ABS_IND_X, mem_write, addr);
        break;

      case 0x40:               /* RTI */
        RTI ();
        break;

      case 0x41:               /* EOR ($nn,X) */
        EOR (6, INDIR_X_BYTE);
        break;

      case 0x43:               /* SRE ($nn,X) */
        SRE (8, INDIR_X, mem_write, addr);
        break;

      case 0x45:               /* EOR $nn */
        EOR (3, ZERO_PAGE_BYTE);
        break;

      case 0x46:               /* LSR $nn */
        LSR (5, ZERO_PAGE, ZP_WRITE, baddr);
        break;

      case 0x47:               /* SRE $nn */
        SRE (5, ZERO_PAGE, ZP_WRITE, baddr);
        break;

      case 0x48:               /* PHA */
        PHA ();
        break;

      case 0x49:               /* EOR #$nn */
        EOR (2, IMMEDIATE_BYTE);
        break;

      case 0x4A:               /* LSR A */
        LSR_A ();
        break;

      case 0x4B:               /* ASR #$nn */
        ASR (2, IMMEDIATE_BYTE);
        break;

      case 0x4C:               /* JMP $nnnn */
        JMP_ABSOLUTE ();
        break;

      case 0x4D:               /* EOR $nnnn */
        EOR (4, ABSOLUTE_BYTE);
        break;

      case 0x4E:               /* LSR $nnnn */
        LSR (6, ABSOLUTE, mem_write, addr);
        break;

      case 0x4F:               /* SRE $nnnn */
        SRE (6, ABSOLUTE, mem_write, addr);
        break;

      case 0x50:               /* BVC $nnnn */
        BVC ();
        break;

      case 0x51:               /* EOR ($nn),Y */
        EOR (5, INDIR_Y_BYTE);
        break;

      case 0x53:               /* SRE ($nn),Y */
        SRE (8, INDIR_Y, mem_write, addr);
        break;

      case 0x55:               /* EOR $nn,X */
        EOR (4, ZP_IND_X_BYTE);
        break;

      case 0x56:               /* LSR $nn,X */
        LSR (6, ZP_IND_X, ZP_WRITE, baddr);
        break;

      case 0x57:               /* SRE $nn,X */
        SRE (6, ZP_IND_X, ZP_WRITE, baddr);
        break;

      case 0x58:               /* CLI */
        CLI ();
        break;

      case 0x59:               /* EOR $nnnn,Y */
        EOR (4, ABS_IND_Y_BYTE);
        break;

      case 0x5B:               /* SRE $nnnn,Y */
        SRE (7, ABS_IND_Y, mem_write, addr);
        break;

      case 0x5D:               /* EOR $nnnn,X */
        EOR (4, ABS_IND_X_BYTE);
        break;

      case 0x5E:               /* LSR $nnnn,X */
        LSR (7, ABS_IND_X, mem_write, addr);
        break;

      case 0x5F:               /* SRE $nnnn,X */
        SRE (7, ABS_IND_X, mem_write, addr);
        break;

      case 0x60:               /* RTS */
        RTS ();
        break;

      case 0x61:               /* ADC ($nn,X) */
        ADC (6, INDIR_X_BYTE);
        break;

      case 0x63:               /* RRA ($nn,X) */
        RRA (8, INDIR_X, mem_write, addr);
        break;

      case 0x65:               /* ADC $nn */
        ADC (3, ZERO_PAGE_BYTE);
        break;

      case 0x66:               /* ROR $nn */
        ROR (5, ZERO_PAGE, ZP_WRITE, baddr);
        break;

      case 0x67:               /* RRA $nn */
        RRA (5, ZERO_PAGE, ZP_WRITE, baddr);
        break;

      case 0x68:               /* PLA */
        PLA ();
        break;

      case 0x69:               /* ADC #$nn */
        ADC (2, IMMEDIATE_BYTE);
        break;

      case 0x6A:               /* ROR A */
        ROR_A ();
        break;

      case 0x6B:               /* ARR #$nn */
        ARR (2, IMMEDIATE_BYTE);
        break;

      case 0x6C:               /* JMP ($nnnn) */
        JMP_INDIRECT ();
        break;

      case 0x6D:               /* ADC $nnnn */
        ADC (4, ABSOLUTE_BYTE);
        break;

      case 0x6E:               /* ROR $nnnn */
        ROR (6, ABSOLUTE, mem_write, addr);
        break;

      case 0x6F:               /* RRA $nnnn */
        RRA (6, ABSOLUTE, mem_write, addr);
        break;

      case 0x70:               /* BVS $nnnn */
        BVS ();
        break;

      case 0x71:               /* ADC ($nn),Y */
        ADC (5, INDIR_Y_BYTE);
        break;

      case 0x73:               /* RRA ($nn),Y */
        RRA (8, INDIR_Y, mem_write, addr);
        break;

      case 0x75:               /* ADC $nn,X */
        ADC (4, ZP_IND_X_BYTE);
        break;

      case 0x76:               /* ROR $nn,X */
        ROR (6, ZP_IND_X, ZP_WRITE, baddr);
        break;

      case 0x77:               /* RRA $nn,X */
        RRA (6, ZP_IND_X, ZP_WRITE, baddr);
        break;

      case 0x78:               /* SEI */
        SEI ();
        break;

      case 0x79:               /* ADC $nnnn,Y */
        ADC (4, ABS_IND_Y_BYTE);
        break;

      case 0x7B:               /* RRA $nnnn,Y */
        RRA (7, ABS_IND_Y, mem_write, addr);
        break;

      case 0x7D:               /* ADC $nnnn,X */
        ADC (4, ABS_IND_X_BYTE);
        break;

      case 0x7E:               /* ROR $nnnn,X */
        ROR (7, ABS_IND_X, mem_write, addr);
        break;

      case 0x7F:               /* RRA $nnnn,X */
        RRA (7, ABS_IND_X, mem_write, addr);
        break;

      case 0x80:               /* NOP #$nn */
      case 0x82:               /* NOP #$nn */
      case 0x89:               /* NOP #$nn */
      case 0xC2:               /* NOP #$nn */
      case 0xE2:               /* NOP #$nn */
        DOP (2);
        break;

      case 0x81:               /* STA ($nn,X) */
        STA (6, INDIR_X_ADDR, mem_write, addr);
        break;

      case 0x83:               /* SAX ($nn,X) */
        SAX (6, INDIR_X_ADDR, mem_write, addr);
        break;

      case 0x84:               /* STY $nn */
        STY (3, ZERO_PAGE_ADDR, ZP_WRITE, baddr);
        break;

      case 0x85:               /* STA $nn */
        STA (3, ZERO_PAGE_ADDR, ZP_WRITE, baddr);
        break;

      case 0x86:               /* STX $nn */
        STX (3, ZERO_PAGE_ADDR, ZP_WRITE, baddr);
        break;

      case 0x87:               /* SAX $nn */
        SAX (3, ZERO_PAGE_ADDR, ZP_WRITE, baddr);
        break;

      case 0x88:               /* DEY */
        DEY ();
        break;

      case 0x8A:               /* TXA */
        TXA ();
        break;

      case 0x8B:               /* ANE #$nn */
        ANE (2, IMMEDIATE_BYTE);
        break;

      case 0x8C:               /* STY $nnnn */
        STY (4, ABSOLUTE_ADDR, mem_write, addr);
        break;

      case 0x8D:               /* STA $nnnn */
        STA (4, ABSOLUTE_ADDR, mem_write, addr);
        break;

      case 0x8E:               /* STX $nnnn */
        STX (4, ABSOLUTE_ADDR, mem_write, addr);
        break;

      case 0x8F:               /* SAX $nnnn */
        SAX (4, ABSOLUTE_ADDR, mem_write, addr);
        break;

      case 0x90:               /* BCC $nnnn */
        BCC ();
        break;

      case 0x91:               /* STA ($nn),Y */
        STA (6, INDIR_Y_ADDR, mem_write, addr);
        break;

      case 0x93:               /* SHA ($nn),Y */
        SHA (6, INDIR_Y_ADDR, mem_write, addr);
        break;

      case 0x94:               /* STY $nn,X */
        STY (4, ZP_IND_X_ADDR, ZP_WRITE, baddr);
        break;

      case 0x95:               /* STA $nn,X */
        STA (4, ZP_IND_X_ADDR, ZP_WRITE, baddr);
        break;

      case 0x96:               /* STX $nn,Y */
        STX (4, ZP_IND_Y_ADDR, ZP_WRITE, baddr);
        break;

      case 0x97:               /* SAX $nn,Y */
        SAX (4, ZP_IND_Y_ADDR, ZP_WRITE, baddr);
        break;

      case 0x98:               /* TYA */
        TYA ();
        break;

      case 0x99:               /* STA $nnnn,Y */
        STA (5, ABS_IND_Y_ADDR, mem_write, addr);
        break;

      case 0x9A:               /* TXS */
        TXS ();
        break;

      case 0x9B:               /* SHS $nnnn,Y */
        SHS (5, ABS_IND_Y_ADDR, mem_write, addr);
        break;

      case 0x9C:               /* SHY $nnnn,X */
        SHY (5, ABS_IND_X_ADDR, mem_write, addr);
        break;

      case 0x9D:               /* STA $nnnn,X */
        STA (5, ABS_IND_X_ADDR, mem_write, addr);
        break;

      case 0x9E:               /* SHX $nnnn,Y */
        SHX (5, ABS_IND_Y_ADDR, mem_write, addr);
        break;

      case 0x9F:               /* SHA $nnnn,Y */
        SHA (5, ABS_IND_Y_ADDR, mem_write, addr);
        break;

      case 0xA0:               /* LDY #$nn */
        LDY (2, IMMEDIATE_BYTE);
        break;

      case 0xA1:               /* LDA ($nn,X) */
        LDA (6, INDIR_X_BYTE);
        break;

      case 0xA2:               /* LDX #$nn */
        LDX (2, IMMEDIATE_BYTE);
        break;

      case 0xA3:               /* LAX ($nn,X) */
        LAX (6, INDIR_X_BYTE);
        break;

      case 0xA4:               /* LDY $nn */
        LDY (3, ZERO_PAGE_BYTE);
        break;

      case 0xA5:               /* LDA $nn */
        LDA (3, ZERO_PAGE_BYTE);
        break;

      case 0xA6:               /* LDX $nn */
        LDX (3, ZERO_PAGE_BYTE);
        break;

      case 0xA7:               /* LAX $nn */
        LAX (3, ZERO_PAGE_BYTE);
        break;

      case 0xA8:               /* TAY */
        TAY ();
        break;

      case 0xA9:               /* LDA #$nn */
        LDA (2, IMMEDIATE_BYTE);
        break;

      case 0xAA:               /* TAX */
        TAX ();
        break;

      case 0xAB:               /* LXA #$nn */
        LXA (2, IMMEDIATE_BYTE);
        break;

      case 0xAC:               /* LDY $nnnn */
        LDY (4, ABSOLUTE_BYTE);
        break;

      case 0xAD:               /* LDA $nnnn */
        LDA (4, ABSOLUTE_BYTE);
        break;

      case 0xAE:               /* LDX $nnnn */
        LDX (4, ABSOLUTE_BYTE);
        break;

      case 0xAF:               /* LAX $nnnn */
        LAX (4, ABSOLUTE_BYTE);
        break;

      case 0xB0:               /* BCS $nnnn */
        BCS ();
        break;

      case 0xB1:               /* LDA ($nn),Y */
        LDA (5, INDIR_Y_BYTE);
        break;

      case 0xB3:               /* LAX ($nn),Y */
        LAX (5, INDIR_Y_BYTE);
        break;

      case 0xB4:               /* LDY $nn,X */
        LDY (4, ZP_IND_X_BYTE);
        break;

      case 0xB5:               /* LDA $nn,X */
        LDA (4, ZP_IND_X_BYTE);
        break;

      case 0xB6:               /* LDX $nn,Y */
        LDX (4, ZP_IND_Y_BYTE);
        break;

      case 0xB7:               /* LAX $nn,Y */
        LAX (4, ZP_IND_Y_BYTE);
        break;

      case 0xB8:               /* CLV */
        CLV ();
        break;

      case 0xB9:               /* LDA $nnnn,Y */
        LDA (4, ABS_IND_Y_BYTE);
        break;

      case 0xBA:               /* TSX */
        TSX ();
        break;

      case 0xBB:               /* LAS $nnnn,Y */
        LAS (4, ABS_IND_Y_BYTE);
        break;

      case 0xBC:               /* LDY $nnnn,X */
        LDY (4, ABS_IND_X_BYTE);
        break;

      case 0xBD:               /* LDA $nnnn,X */
        LDA (4, ABS_IND_X_BYTE);
        break;

      case 0xBE:               /* LDX $nnnn,Y */
        LDX (4, ABS_IND_Y_BYTE);
        break;

      case 0xBF:               /* LAX $nnnn,Y */
        LAX (4, ABS_IND_Y_BYTE);
        break;

      case 0xC0:               /* CPY #$nn */
        CPY (2, IMMEDIATE_BYTE);
        break;

      case 0xC1:               /* CMP ($nn,X) */
        CMP (6, INDIR_X_BYTE);
        break;

      case 0xC3:               /* DCP ($nn,X) */
        DCP (8, INDIR_X, mem_write, addr);
        break;

      case 0xC4:               /* CPY $nn */
        CPY (3, ZERO_PAGE_BYTE);
        break;

      case 0xC5:               /* CMP $nn */
        CMP (3, ZERO_PAGE_BYTE);
        break;

      case 0xC6:               /* DEC $nn */
        DEC (5, ZERO_PAGE, ZP_WRITE, baddr);
        break;

      case 0xC7:               /* DCP $nn */
        DCP (5, ZERO_PAGE, ZP_WRITE, baddr);
        break;

      case 0xC8:               /* INY */
        INY ();
        break;

      case 0xC9:               /* CMP #$nn */
        CMP (2, IMMEDIATE_BYTE);
        break;

      case 0xCA:               /* DEX */
        DEX ();
        break;

      case 0xCB:               /* SBX #$nn */
        SBX (2, IMMEDIATE_BYTE);
        break;

      case 0xCC:               /* CPY $nnnn */
        CPY (4, ABSOLUTE_BYTE);
        break;

      case 0xCD:               /* CMP $nnnn */
        CMP (4, ABSOLUTE_BYTE);
        break;

      case 0xCE:               /* DEC $nnnn */
        DEC (6, ABSOLUTE, mem_write, addr);
        break;

      case 0xCF:               /* DCP $nnnn */
        DCP (6, ABSOLUTE, mem_write, addr);
        break;

      case 0xD0:               /* BNE $nnnn */
        BNE ();
        break;

      case 0xD1:               /* CMP ($nn),Y */
        CMP (5, INDIR_Y_BYTE);
        break;

      case 0xD3:               /* DCP ($nn),Y */
        DCP (8, INDIR_Y, mem_write, addr);
        break;

      case 0xD5:               /* CMP $nn,X */
        CMP (4, ZP_IND_X_BYTE);
        break;

      case 0xD6:               /* DEC $nn,X */
        DEC (6, ZP_IND_X, ZP_WRITE, baddr);
        break;

      case 0xD7:               /* DCP $nn,X */
        DCP (6, ZP_IND_X, ZP_WRITE, baddr);
        break;

      case 0xD8:               /* CLD */
        CLD ();
        break;

      case 0xD9:               /* CMP $nnnn,Y */
        CMP (4, ABS_IND_Y_BYTE);
        break;

      case 0xDB:               /* DCP $nnnn,Y */
        DCP (7, ABS_IND_Y, mem_write, addr);
        break;

      case 0xDD:               /* CMP $nnnn,X */
        CMP (4, ABS_IND_X_BYTE);
        break;

      case 0xDE:               /* DEC $nnnn,X */
        DEC (7, ABS_IND_X, mem_write, addr);
        break;

      case 0xDF:               /* DCP $nnnn,X */
        DCP (7, ABS_IND_X, mem_write, addr);
        break;

      case 0xE0:               /* CPX #$nn */
        CPX (2, IMMEDIATE_BYTE);
        break;

      case 0xE1:               /* SBC ($nn,X) */
        SBC (6, INDIR_X_BYTE);
        break;

      case 0xE3:               /* ISB ($nn,X) */
        ISB (8, INDIR_X, mem_write, addr);
        break;

      case 0xE4:               /* CPX $nn */
        CPX (3, ZERO_PAGE_BYTE);
        break;

      case 0xE5:               /* SBC $nn */
        SBC (3, ZERO_PAGE_BYTE);
        break;

      case 0xE6:               /* INC $nn */
        INC (5, ZERO_PAGE, ZP_WRITE, baddr);
        break;

      case 0xE7:               /* ISB $nn */
        ISB (5, ZERO_PAGE, ZP_WRITE, baddr);
        break;

      case 0xE8:               /* INX */
        INX ();
        break;

      case 0xE9:               /* SBC #$nn */
      case 0xEB:               /* USBC #$nn */
        SBC (2, IMMEDIATE_BYTE);
        break;

      case 0xEA:               /* NOP */
        NOP ();
        break;

      case 0xEC:               /* CPX $nnnn */
        CPX (4, ABSOLUTE_BYTE);
        break;

      case 0xED:               /* SBC $nnnn */
        SBC (4, ABSOLUTE_BYTE);
        break;

      case 0xEE:               /* INC $nnnn */
        INC (6, ABSOLUTE, mem_write, addr);
        break;

      case 0xEF:               /* ISB $nnnn */
        ISB (6, ABSOLUTE, mem_write, addr);
        break;

      case 0xF0:               /* BEQ $nnnn */
        BEQ ();
        break;

      case 0xF1:               /* SBC ($nn),Y */
        SBC (5, INDIR_Y_BYTE);
        break;

      case 0xF3:               /* ISB ($nn),Y */
        ISB (8, INDIR_Y, mem_write, addr);
        break;

      case 0xF5:               /* SBC $nn,X */
        SBC (4, ZP_IND_X_BYTE);
        break;

      case 0xF6:               /* INC $nn,X */
        INC (6, ZP_IND_X, ZP_WRITE, baddr);
        break;

      case 0xF7:               /* ISB $nn,X */
        ISB (6, ZP_IND_X, ZP_WRITE, baddr);
        break;

      case 0xF8:               /* SED */
        SED ();
        break;

      case 0xF9:               /* SBC $nnnn,Y */
        SBC (4, ABS_IND_Y_BYTE);
        break;

      case 0xFB:               /* ISB $nnnn,Y */
        ISB (7, ABS_IND_Y, mem_write, addr);
        break;

      case 0xFD:               /* SBC $nnnn,X */
        SBC (4, ABS_IND_X_BYTE);
        break;

      case 0xFE:               /* INC $nnnn,X */
        INC (7, ABS_IND_X, mem_write, addr);
        break;

      case 0xFF:               /* ISB $nnnn,X */
        ISB (7, ABS_IND_X, mem_write, addr);
        break;
    }

    /* Calculate remaining/elapsed clock cycles */
    remaining_cycles -= instruction_cycles;
    total_cycles += instruction_cycles;
  }

_execute_done:

  /* restore local copy of regs */
  SET_LOCAL_REGS ();

  /* Return our actual amount of executed cycles */
  return (total_cycles - old_cycles);
}

/* Initialize tables, etc. */
void
nes6502_init (void)
{
  int index;

  /* Build the N / Z flag lookup table */
  flag_table[0] = Z_FLAG;

  for (index = 1; index < 256; index++)
    flag_table[index] = (index & 0x80) ? N_FLAG : 0;

  reg_A = reg_X = reg_Y = 0;
  reg_S = 0xFF;                 /* Stack grows down */
}


/* Issue a CPU Reset */
void
nes6502_reset (void)
{
  reg_P = Z_FLAG | R_FLAG | I_FLAG;     /* Reserved bit always 1 */
  int_pending = dma_cycles = 0; /* No pending interrupts */
  reg_PC = bank_readaddress (RESET_VECTOR);     /* Fetch reset vector */
  /* TODO: 6 cycles for RESET? */
}

/* Non-maskable interrupt */
void
nes6502_nmi (void)
{
  int_pending |= NMI_MASK;
}

/* Interrupt request */
void
nes6502_irq (void)
{
  int_pending |= IRQ_MASK;
}

/* Set dma period (in cycles) */
void
nes6502_setdma (int cycles)
{
  dma_cycles += cycles;
}

#ifdef NES6502_MEM_ACCESS_CTRL
void
nes6502_chk_mem_access (uint8 * access, int flags)
{
  chk_mem_access (access, flags);
}
#endif

/*
** $Log$
** Revision 1.3  2008/03/25 15:56:11  slomo
** Patch by: Andreas Henriksson <andreas at fatal dot set>
** * gst/nsf/Makefile.am:
** * gst/nsf/dis6502.h:
** * gst/nsf/fds_snd.c:
** * gst/nsf/fds_snd.h:
** * gst/nsf/fmopl.c:
** * gst/nsf/fmopl.h:
** * gst/nsf/gstnsf.c:
** * gst/nsf/log.c:
** * gst/nsf/log.h:
** * gst/nsf/memguard.c:
** * gst/nsf/memguard.h:
** * gst/nsf/mmc5_snd.c:
** * gst/nsf/mmc5_snd.h:
** * gst/nsf/nes6502.c:
** * gst/nsf/nes6502.h:
** * gst/nsf/nes_apu.c:
** * gst/nsf/nes_apu.h:
** * gst/nsf/nsf.c:
** * gst/nsf/nsf.h:
** * gst/nsf/osd.h:
** * gst/nsf/types.h:
** * gst/nsf/vrc7_snd.c:
** * gst/nsf/vrc7_snd.h:
** * gst/nsf/vrcvisnd.c:
** * gst/nsf/vrcvisnd.h:
** Update our internal nosefart to nosefart-2.7-mls to fix segfaults
** on some files. Fixes bug #498237.
** Remove some // comments, fix some compiler warnings and use pow()
** instead of a slow, selfmade implementation.
**
** Revision 1.2  2003/05/01 22:34:19  benjihan
** New NSF plugin
**
** Revision 1.1  2003/04/08 20:53:00  ben
** Adding more files...
**
** Revision 1.6  2000/07/04 04:50:07  matt
** minor change to includes
**
** Revision 1.5  2000/07/03 02:18:16  matt
** added a few notes about potential failure cases
**
** Revision 1.4  2000/06/09 15:12:25  matt
** initial revision
**
*/