[fceu.git] / ops.h

/* FCE Ultra - NES/Famicom Emulator
 *
 * Copyright notice for this file:
 *  Copyright (C) 2002 Ben Parnell
 *
 * This program is free software; you can redistribute it and/or modify
 * it under the terms of the GNU General Public License as published by
 * the Free Software Foundation; either version 2 of the License, or
 * (at your option) any later version.
 *
 * 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 General Public License for more details.
 *
 * You should have received a copy of the GNU General Public License
 * along with this program; if not, write to the Free Software
 * Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA  02111-1307  USA
 */

case 0x00:  /* BRK */
            _PC++;
            PUSH(_PC>>8);
            PUSH(_PC);
	    _P|=B_FLAG;
            PUSH(_P|U_FLAG);
	    _P|=I_FLAG;
            _PC=RdMem(0xFFFE);
            _PC|=RdMem(0xFFFF)<<8;
            break;

case 0x40:  /* RTI */
            _P=POP();
	    _PI=_P;
            _PC=POP();
            _PC|=POP()<<8;
            break;

case 0x60:  /* RTS */
            _PC=POP();
            _PC|=POP()<<8;
            _PC++;
            break;

case 0x48: /* PHA */
           PUSH(_A);
           break;
case 0x08: /* PHP */
           PUSH(_P|U_FLAG|B_FLAG);
           break;
case 0x68: /* PLA */
           _A=POP();
           X_ZN(_A);
           break;
case 0x28: /* PLP */
           _P=POP();
           break;
case 0x4C:
	  {
	   unsigned int npc;
/*
	   uint16 ptmp=_PC;
	   npc=RdMem(ptmp);
	   ptmp++;
	   npc|=RdMem(ptmp)<<8;
*/
	   npc=RdMem(_PC++);
	   npc|=RdMem(_PC++)<<8;
	   _PC=npc;
	  }
	  break; /* JMP ABSOLUTE */
case 0x6C:
	   {
	    uint32 tmp;
	    GetAB(tmp);
	    _PC=RdMem(tmp);
	    _PC|=RdMem( ((tmp+1)&0x00FF) | (tmp&0xFF00))<<8;
	   }
	   break;
case 0x20: /* JSR */
	   {
	    uint32 npc;
	    npc=RdMem(_PC++);
            PUSH(_PC>>8);
            PUSH(_PC);
            npc|=RdMem(_PC++)<<8;
	    _PC=npc;
	   }
           break;

case 0xAA: /* TAX */
           _X=_A;
           X_ZN(_A);
           break;

case 0x8A: /* TXA */
           _A=_X;
           X_ZN(_A);
           break;

case 0xA8: /* TAY */
           _Y=_A;
           X_ZN(_A);
           break;
case 0x98: /* TYA */
           _A=_Y;
           X_ZN(_A);
           break;

case 0xBA: /* TSX */
           _X=_S;
           X_ZN(_X);
           break;
case 0x9A: /* TXS */
           _S=_X;
           break;

case 0xCA: /* DEX */
           _X--;
           X_ZN(_X);
           break;
case 0x88: /* DEY */
           _Y--;
           X_ZN(_Y);
           break;

case 0xE8: /* INX */
           _X++;
           X_ZN(_X);
           break;
case 0xC8: /* INY */
           _Y++;
           X_ZN(_Y);
           break;

case 0x18: /* CLC */
           _P&=~C_FLAG;
           break;
case 0xD8: /* CLD */
           _P&=~D_FLAG;
           break;
case 0x58: /* CLI */
           _P&=~I_FLAG;
           break;
case 0xB8: /* CLV */
           _P&=~V_FLAG;
           break;

case 0x38: /* SEC */
           _P|=C_FLAG;
           break;
case 0xF8: /* SED */
           _P|=D_FLAG;
           break;
case 0x78: /* SEI */
           _P|=I_FLAG;
           break;

case 0xEA: /* NOP */
           break;

case 0x0A: RMW_A(ASL);
case 0x06: RMW_ZP(ASL);
case 0x16: RMW_ZPX(ASL);
case 0x0E: RMW_AB(ASL);
case 0x1E: RMW_ABX(ASL);

case 0xC6: RMW_ZP(DEC);
case 0xD6: RMW_ZPX(DEC);
case 0xCE: RMW_AB(DEC);
case 0xDE: RMW_ABX(DEC);

case 0xE6: RMW_ZP(INC);
case 0xF6: RMW_ZPX(INC);
case 0xEE: RMW_AB(INC);
case 0xFE: RMW_ABX(INC);

case 0x4A: RMW_A(LSR);
case 0x46: RMW_ZP(LSR);
case 0x56: RMW_ZPX(LSR);
case 0x4E: RMW_AB(LSR);
case 0x5E: RMW_ABX(LSR);

case 0x2A: RMW_A(ROL);
case 0x26: RMW_ZP(ROL);
case 0x36: RMW_ZPX(ROL);
case 0x2E: RMW_AB(ROL);
case 0x3E: RMW_ABX(ROL);

case 0x6A: RMW_A(ROR);
case 0x66: RMW_ZP(ROR);
case 0x76: RMW_ZPX(ROR);
case 0x6E: RMW_AB(ROR);
case 0x7E: RMW_ABX(ROR);

case 0x69: LD_IM(ADC);
case 0x65: LD_ZP(ADC);
case 0x75: LD_ZPX(ADC);
case 0x6D: LD_AB(ADC);
case 0x7D: LD_ABX(ADC);
case 0x79: LD_ABY(ADC);
case 0x61: LD_IX(ADC);
case 0x71: LD_IY(ADC);

case 0x29: LD_IM(AND);
case 0x25: LD_ZP(AND);
case 0x35: LD_ZPX(AND);
case 0x2D: LD_AB(AND);
case 0x3D: LD_ABX(AND);
case 0x39: LD_ABY(AND);
case 0x21: LD_IX(AND);
case 0x31: LD_IY(AND);

case 0x24: LD_ZP(BIT);
case 0x2C: LD_AB(BIT);

case 0xC9: LD_IM(CMP);
case 0xC5: LD_ZP(CMP);
case 0xD5: LD_ZPX(CMP);
case 0xCD: LD_AB(CMP);
case 0xDD: LD_ABX(CMP);
case 0xD9: LD_ABY(CMP);
case 0xC1: LD_IX(CMP);
case 0xD1: LD_IY(CMP);

case 0xE0: LD_IM(CPX);
case 0xE4: LD_ZP(CPX);
case 0xEC: LD_AB(CPX);

case 0xC0: LD_IM(CPY);
case 0xC4: LD_ZP(CPY);
case 0xCC: LD_AB(CPY);

case 0x49: LD_IM(EOR);
case 0x45: LD_ZP(EOR);
case 0x55: LD_ZPX(EOR);
case 0x4D: LD_AB(EOR);
case 0x5D: LD_ABX(EOR);
case 0x59: LD_ABY(EOR);
case 0x41: LD_IX(EOR);
case 0x51: LD_IY(EOR);

case 0xA9: LD_IM(LDA);
case 0xA5: LD_ZP(LDA);
case 0xB5: LD_ZPX(LDA);
case 0xAD: LD_AB(LDA);
case 0xBD: LD_ABX(LDA);
case 0xB9: LD_ABY(LDA);
case 0xA1: LD_IX(LDA);
case 0xB1: LD_IY(LDA);

case 0xA2: LD_IM(LDX);
case 0xA6: LD_ZP(LDX);
case 0xB6: LD_ZPY(LDX);
case 0xAE: LD_AB(LDX);
case 0xBE: LD_ABY(LDX);

case 0xA0: LD_IM(LDY);
case 0xA4: LD_ZP(LDY);
case 0xB4: LD_ZPX(LDY);
case 0xAC: LD_AB(LDY);
case 0xBC: LD_ABX(LDY);

case 0x09: LD_IM(ORA);
case 0x05: LD_ZP(ORA);
case 0x15: LD_ZPX(ORA);
case 0x0D: LD_AB(ORA);
case 0x1D: LD_ABX(ORA);
case 0x19: LD_ABY(ORA);
case 0x01: LD_IX(ORA);
case 0x11: LD_IY(ORA);

case 0xEB:	/* (undocumented) */
case 0xE9: LD_IM(SBC);
case 0xE5: LD_ZP(SBC);
case 0xF5: LD_ZPX(SBC);
case 0xED: LD_AB(SBC);
case 0xFD: LD_ABX(SBC);
case 0xF9: LD_ABY(SBC);
case 0xE1: LD_IX(SBC);
case 0xF1: LD_IY(SBC);

case 0x85: ST_ZP(_A);
case 0x95: ST_ZPX(_A);
case 0x8D: ST_AB(_A);
case 0x9D: ST_ABX(_A);
case 0x99: ST_ABY(_A);
case 0x81: ST_IX(_A);
case 0x91: ST_IY(_A);

case 0x86: ST_ZP(_X);
case 0x96: ST_ZPY(_X);
case 0x8E: ST_AB(_X);

case 0x84: ST_ZP(_Y);
case 0x94: ST_ZPX(_Y);
case 0x8C: ST_AB(_Y);

/* BCC */
case 0x90: if(_P&C_FLAG) _PC++; else {JR();} break;

/* BCS */
case 0xB0: if(_P&C_FLAG) {JR();} else _PC++; break;

/* BEQ */
case 0xF0: if(_P&Z_FLAG) {JR();} else _PC++; break;

/* BNE */
case 0xD0: if(_P&Z_FLAG) _PC++; else {JR();} break;

/* BMI */
case 0x30: if(_P&N_FLAG) {JR();} else _PC++; break;

/* BPL */
case 0x10: if(_P&N_FLAG) _PC++; else {JR();} break;

/* BVC */
case 0x50: if(_P&V_FLAG) _PC++; else {JR();} break;

/* BVS */
case 0x70: if(_P&V_FLAG) {JR();} else _PC++; break;

/* Here comes the undocumented instructions.  Note that this implementation
   may be "wrong".  If so, please tell me.
*/

/* AAC */
case 0x2B:
case 0x0B: LD_IM(AND;_P&=~C_FLAG;_P|=_A>>7);

/* AAX */
case 0x87: ST_ZP(_A&_X);
case 0x97: ST_ZPY(_A&_X);
case 0x8F: ST_AB(_A&_X);
case 0x83: ST_IX(_A&_X);

/* ARR - ARGH, MATEY! */
case 0x6B: {
	     uint8 arrtmp;
	     LD_IM(AND;_P&=~V_FLAG;_P|=(_A^(_A>>1))&0x40;arrtmp=_A>>7;_A>>=1;_A|=(_P&C_FLAG)<<7;_P&=~C_FLAG;_P|=arrtmp;X_ZN(_A));
	   }
/* ASR */
case 0x4B: LD_IM(AND;LSRA);

/* ATX(OAL) Is this(OR with $EE) correct? */
case 0xAB: LD_IM(_A|=0xEE;AND;_X=_A);

/* AXS */
case 0xCB: LD_IM(AXS);

/* DCP */
case 0xC7: RMW_ZP(DEC;CMP);
case 0xD7: RMW_ZPX(DEC;CMP);
case 0xCF: RMW_AB(DEC;CMP);
case 0xDF: RMW_ABX(DEC;CMP);
case 0xDB: RMW_ABY(DEC;CMP);
case 0xC3: RMW_IX(DEC;CMP);
case 0xD3: RMW_IY(DEC;CMP);

/* ISC */
case 0xE7: RMW_ZP(INC;SBC);
case 0xF7: RMW_ZPX(INC;SBC);
case 0xEF: RMW_AB(INC;SBC);
case 0xFF: RMW_ABX(INC;SBC);
case 0xFB: RMW_ABY(INC;SBC);
case 0xE3: RMW_IX(INC;SBC);
case 0xF3: RMW_IY(INC;SBC);

/* DOP */

case 0x04: _PC++;break;
case 0x14: _PC++;break;
case 0x34: _PC++;break;
case 0x44: _PC++;break;
case 0x54: _PC++;break;
case 0x64: _PC++;break;
case 0x74: _PC++;break;

case 0x80: _PC++;break;
case 0x82: _PC++;break;
case 0x89: _PC++;break;
case 0xC2: _PC++;break;
case 0xD4: _PC++;break;
case 0xE2: _PC++;break;
case 0xF4: _PC++;break;

/* KIL */

case 0x02:
case 0x12:
case 0x22:
case 0x32:
case 0x42:
case 0x52:
case 0x62:
case 0x72:
case 0x92:
case 0xB2:
case 0xD2:
case 0xF2:ADDCYC(0xFF);
          _jammed=1;
	  _PC--;
	  break;

/* LAR */
case 0xBB: RMW_ABY(_S&=x;_A=_X=_S;X_ZN(_X));

/* LAX */
case 0xA7: LD_ZP(LDA;LDX);
case 0xB7: LD_ZPY(LDA;LDX);
case 0xAF: LD_AB(LDA;LDX);
case 0xBF: LD_ABY(LDA;LDX);
case 0xA3: LD_IX(LDA;LDX);
case 0xB3: LD_IY(LDA;LDX);

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

/* RLA */
case 0x27: RMW_ZP(ROL;AND);
case 0x37: RMW_ZPX(ROL;AND);
case 0x2F: RMW_AB(ROL;AND);
case 0x3F: RMW_ABX(ROL;AND);
case 0x3B: RMW_ABY(ROL;AND);
case 0x23: RMW_IX(ROL;AND);
case 0x33: RMW_IY(ROL;AND);

/* RRA */
case 0x67: RMW_ZP(ROR;ADC);
case 0x77: RMW_ZPX(ROR;ADC);
case 0x6F: RMW_AB(ROR;ADC);
case 0x7F: RMW_ABX(ROR;ADC);
case 0x7B: RMW_ABY(ROR;ADC);
case 0x63: RMW_IX(ROR;ADC);
case 0x73: RMW_IY(ROR;ADC);

/* SLO */
case 0x07: RMW_ZP(ASL;ORA);
case 0x17: RMW_ZPX(ASL;ORA);
case 0x0F: RMW_AB(ASL;ORA);
case 0x1F: RMW_ABX(ASL;ORA);
case 0x1B: RMW_ABY(ASL;ORA);
case 0x03: RMW_IX(ASL;ORA);
case 0x13: RMW_IY(ASL;ORA);

/* SRE */
case 0x47: RMW_ZP(LSR;EOR);
case 0x57: RMW_ZPX(LSR;EOR);
case 0x4F: RMW_AB(LSR;EOR);
case 0x5F: RMW_ABX(LSR;EOR);
case 0x5B: RMW_ABY(LSR;EOR);
case 0x43: RMW_IX(LSR;EOR);
case 0x53: RMW_IY(LSR;EOR);

/* AXA - SHA */
case 0x93: ST_IY(_A&_X&(((A-_Y)>>8)+1));
case 0x9F: ST_ABY(_A&_X&(((A-_Y)>>8)+1));

/* SYA */
case 0x9C: ST_ABX(_Y&(((A-_X)>>8)+1));

/* SXA */
case 0x9E: ST_ABY(_X&(((A-_Y)>>8)+1));

/* XAS */
case 0x9B: _S=_A&_X;ST_ABY(_S& (((A-_Y)>>8)+1) );

/* TOP */
case 0x0C: LD_AB(;);
case 0x1C:
case 0x3C:
case 0x5C:
case 0x7C:
case 0xDC:
case 0xFC: LD_ABX(;);

/* XAA - BIG QUESTION MARK HERE */
case 0x8B: _A|=0xEE; _A&=_X; LD_IM(AND);
Commit	Line	Data
c62d2810	1	/* FCE Ultra - NES/Famicom Emulator
	2	*
	3	* Copyright notice for this file:
	4	* Copyright (C) 2002 Ben Parnell
	5	*
	6	* This program is free software; you can redistribute it and/or modify
	7	* it under the terms of the GNU General Public License as published by
	8	* the Free Software Foundation; either version 2 of the License, or
	9	* (at your option) any later version.
	10	*
	11	* This program is distributed in the hope that it will be useful,
	12	* but WITHOUT ANY WARRANTY; without even the implied warranty of
	13	* MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
	14	* GNU General Public License for more details.
	15	*
	16	* You should have received a copy of the GNU General Public License
	17	* along with this program; if not, write to the Free Software
	18	* Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA 02111-1307 USA
	19	*/
	20
	21	case 0x00: /* BRK */
	22	_PC++;
	23	PUSH(_PC>>8);
	24	PUSH(_PC);
8fa5eb33	25	_P\|=B_FLAG;
8fa5eb33	26	PUSH(_P\|U_FLAG);
c62d2810	27	_P\|=I_FLAG;
	28	_PC=RdMem(0xFFFE);
	29	_PC\|=RdMem(0xFFFF)<<8;
	30	break;
	31
	32	case 0x40: /* RTI */
	33	_P=POP();
	34	_PI=_P;
	35	_PC=POP();
	36	_PC\|=POP()<<8;
	37	break;
c0bf6f9f	38
c62d2810	39	case 0x60: /* RTS */
	40	_PC=POP();
	41	_PC\|=POP()<<8;
	42	_PC++;
	43	break;
	44
	45	case 0x48: /* PHA */
	46	PUSH(_A);
	47	break;
	48	case 0x08: /* PHP */
	49	PUSH(_P\|U_FLAG\|B_FLAG);
	50	break;
	51	case 0x68: /* PLA */
	52	_A=POP();
	53	X_ZN(_A);
	54	break;
	55	case 0x28: /* PLP */
	56	_P=POP();
	57	break;
	58	case 0x4C:
	59	{
c62d2810	60	unsigned int npc;
e5f8a1a9	61	/*
e5f8a1a9	62	uint16 ptmp=_PC;
c62d2810	63	npc=RdMem(ptmp);
	64	ptmp++;
	65	npc\|=RdMem(ptmp)<<8;
e5f8a1a9	66	*/
	67	npc=RdMem(_PC++);
	68	npc\|=RdMem(_PC++)<<8;
c62d2810	69	_PC=npc;
	70	}
	71	break; /* JMP ABSOLUTE */
c0bf6f9f	72	case 0x6C:
c62d2810	73	{
	74	uint32 tmp;
	75	GetAB(tmp);
	76	_PC=RdMem(tmp);
	77	_PC\|=RdMem( ((tmp+1)&0x00FF) \| (tmp&0xFF00))<<8;
	78	}
	79	break;
	80	case 0x20: /* JSR */
	81	{
e5f8a1a9	82	uint32 npc;
c62d2810	83	npc=RdMem(_PC++);
	84	PUSH(_PC>>8);
	85	PUSH(_PC);
e5f8a1a9	86	npc\|=RdMem(_PC++)<<8;
e5f8a1a9	87	_PC=npc;
c62d2810	88	}
	89	break;
	90
	91	case 0xAA: /* TAX */
	92	_X=_A;
	93	X_ZN(_A);
	94	break;
	95
	96	case 0x8A: /* TXA */
	97	_A=_X;
	98	X_ZN(_A);
	99	break;
	100
	101	case 0xA8: /* TAY */
	102	_Y=_A;
	103	X_ZN(_A);
	104	break;
	105	case 0x98: /* TYA */
	106	_A=_Y;
	107	X_ZN(_A);
	108	break;
	109
	110	case 0xBA: /* TSX */
	111	_X=_S;
	112	X_ZN(_X);
	113	break;
	114	case 0x9A: /* TXS */
	115	_S=_X;
	116	break;
	117
	118	case 0xCA: /* DEX */
	119	_X--;
	120	X_ZN(_X);
	121	break;
	122	case 0x88: /* DEY */
	123	_Y--;
	124	X_ZN(_Y);
	125	break;
	126
	127	case 0xE8: /* INX */
	128	_X++;
	129	X_ZN(_X);
	130	break;
	131	case 0xC8: /* INY */
	132	_Y++;
	133	X_ZN(_Y);
	134	break;
	135
	136	case 0x18: /* CLC */
	137	_P&=~C_FLAG;
	138	break;
	139	case 0xD8: /* CLD */
	140	_P&=~D_FLAG;
	141	break;
	142	case 0x58: /* CLI */
	143	_P&=~I_FLAG;
	144	break;
	145	case 0xB8: /* CLV */
	146	_P&=~V_FLAG;
	147	break;
	148
	149	case 0x38: /* SEC */
	150	_P\|=C_FLAG;
	151	break;
152	case 0xF8: /* SED */
153	_P\|=D_FLAG;
154	break;
155	case 0x78: /* SEI */
156	_P\|=I_FLAG;
157	break;
158
159	case 0xEA: /* NOP */
160	break;
161
162	case 0x0A: RMW_A(ASL);
163	case 0x06: RMW_ZP(ASL);
164	case 0x16: RMW_ZPX(ASL);
165	case 0x0E: RMW_AB(ASL);
166	case 0x1E: RMW_ABX(ASL);
167
168	case 0xC6: RMW_ZP(DEC);
169	case 0xD6: RMW_ZPX(DEC);
170	case 0xCE: RMW_AB(DEC);
171	case 0xDE: RMW_ABX(DEC);
172
173	case 0xE6: RMW_ZP(INC);
174	case 0xF6: RMW_ZPX(INC);
175	case 0xEE: RMW_AB(INC);
176	case 0xFE: RMW_ABX(INC);
177
178	case 0x4A: RMW_A(LSR);
179	case 0x46: RMW_ZP(LSR);
180	case 0x56: RMW_ZPX(LSR);
181	case 0x4E: RMW_AB(LSR);
182	case 0x5E: RMW_ABX(LSR);
183
184	case 0x2A: RMW_A(ROL);
185	case 0x26: RMW_ZP(ROL);
186	case 0x36: RMW_ZPX(ROL);
187	case 0x2E: RMW_AB(ROL);
188	case 0x3E: RMW_ABX(ROL);
189
190	case 0x6A: RMW_A(ROR);
191	case 0x66: RMW_ZP(ROR);
192	case 0x76: RMW_ZPX(ROR);
193	case 0x6E: RMW_AB(ROR);
194	case 0x7E: RMW_ABX(ROR);
195
196	case 0x69: LD_IM(ADC);
197	case 0x65: LD_ZP(ADC);
198	case 0x75: LD_ZPX(ADC);
199	case 0x6D: LD_AB(ADC);
200	case 0x7D: LD_ABX(ADC);
201	case 0x79: LD_ABY(ADC);
202	case 0x61: LD_IX(ADC);
203	case 0x71: LD_IY(ADC);
204
205	case 0x29: LD_IM(AND);
206	case 0x25: LD_ZP(AND);
207	case 0x35: LD_ZPX(AND);
208	case 0x2D: LD_AB(AND);
209	case 0x3D: LD_ABX(AND);
210	case 0x39: LD_ABY(AND);
211	case 0x21: LD_IX(AND);
212	case 0x31: LD_IY(AND);
213
214	case 0x24: LD_ZP(BIT);
215	case 0x2C: LD_AB(BIT);
216
217	case 0xC9: LD_IM(CMP);
218	case 0xC5: LD_ZP(CMP);
219	case 0xD5: LD_ZPX(CMP);
220	case 0xCD: LD_AB(CMP);
221	case 0xDD: LD_ABX(CMP);
222	case 0xD9: LD_ABY(CMP);
223	case 0xC1: LD_IX(CMP);
224	case 0xD1: LD_IY(CMP);
225
226	case 0xE0: LD_IM(CPX);
227	case 0xE4: LD_ZP(CPX);
228	case 0xEC: LD_AB(CPX);
229
230	case 0xC0: LD_IM(CPY);
231	case 0xC4: LD_ZP(CPY);
232	case 0xCC: LD_AB(CPY);
233
234	case 0x49: LD_IM(EOR);
235	case 0x45: LD_ZP(EOR);
236	case 0x55: LD_ZPX(EOR);
237	case 0x4D: LD_AB(EOR);
238	case 0x5D: LD_ABX(EOR);
239	case 0x59: LD_ABY(EOR);
240	case 0x41: LD_IX(EOR);
241	case 0x51: LD_IY(EOR);
242
243	case 0xA9: LD_IM(LDA);
244	case 0xA5: LD_ZP(LDA);
245	case 0xB5: LD_ZPX(LDA);
246	case 0xAD: LD_AB(LDA);
247	case 0xBD: LD_ABX(LDA);
248	case 0xB9: LD_ABY(LDA);
249	case 0xA1: LD_IX(LDA);
250	case 0xB1: LD_IY(LDA);
251
252	case 0xA2: LD_IM(LDX);
253	case 0xA6: LD_ZP(LDX);
254	case 0xB6: LD_ZPY(LDX);
255	case 0xAE: LD_AB(LDX);
256	case 0xBE: LD_ABY(LDX);
257
258	case 0xA0: LD_IM(LDY);
259	case 0xA4: LD_ZP(LDY);
260	case 0xB4: LD_ZPX(LDY);
261	case 0xAC: LD_AB(LDY);
262	case 0xBC: LD_ABX(LDY);
263
264	case 0x09: LD_IM(ORA);
265	case 0x05: LD_ZP(ORA);
266	case 0x15: LD_ZPX(ORA);
267	case 0x0D: LD_AB(ORA);
268	case 0x1D: LD_ABX(ORA);
269	case 0x19: LD_ABY(ORA);
270	case 0x01: LD_IX(ORA);
271	case 0x11: LD_IY(ORA);
272
273	case 0xEB: /* (undocumented) */
274	case 0xE9: LD_IM(SBC);
275	case 0xE5: LD_ZP(SBC);
276	case 0xF5: LD_ZPX(SBC);
277	case 0xED: LD_AB(SBC);
278	case 0xFD: LD_ABX(SBC);
279	case 0xF9: LD_ABY(SBC);
280	case 0xE1: LD_IX(SBC);
281	case 0xF1: LD_IY(SBC);
282
283	case 0x85: ST_ZP(_A);
284	case 0x95: ST_ZPX(_A);
285	case 0x8D: ST_AB(_A);
286	case 0x9D: ST_ABX(_A);
287	case 0x99: ST_ABY(_A);
288	case 0x81: ST_IX(_A);
289	case 0x91: ST_IY(_A);
290
291	case 0x86: ST_ZP(_X);
292	case 0x96: ST_ZPY(_X);
293	case 0x8E: ST_AB(_X);
294
295	case 0x84: ST_ZP(_Y);
296	case 0x94: ST_ZPX(_Y);
297	case 0x8C: ST_AB(_Y);
298
299	/* BCC */
300	case 0x90: if(_P&C_FLAG) _PC++; else {JR();} break;
301
302	/* BCS */
303	case 0xB0: if(_P&C_FLAG) {JR();} else _PC++; break;
304
305	/* BEQ */
306	case 0xF0: if(_P&Z_FLAG) {JR();} else _PC++; break;
307
308	/* BNE */
309	case 0xD0: if(_P&Z_FLAG) _PC++; else {JR();} break;
310
311	/* BMI */
312	case 0x30: if(_P&N_FLAG) {JR();} else _PC++; break;
313
314	/* BPL */
315	case 0x10: if(_P&N_FLAG) _PC++; else {JR();} break;
316
317	/* BVC */
318	case 0x50: if(_P&V_FLAG) _PC++; else {JR();} break;
319
320	/* BVS */
321	case 0x70: if(_P&V_FLAG) {JR();} else _PC++; break;
322
323	/* Here comes the undocumented instructions. Note that this implementation
324	may be "wrong". If so, please tell me.
325	*/
326
327	/* AAC */
328	case 0x2B:
329	case 0x0B: LD_IM(AND;_P&=~C_FLAG;_P\|=_A>>7);
330
331	/* AAX */
332	case 0x87: ST_ZP(_A&_X);
333	case 0x97: ST_ZPY(_A&_X);
334	case 0x8F: ST_AB(_A&_X);
335	case 0x83: ST_IX(_A&_X);
336
337	/* ARR - ARGH, MATEY! */
c0bf6f9f	338	case 0x6B: {
c0bf6f9f	339	uint8 arrtmp;
c62d2810	340	LD_IM(AND;_P&=~V_FLAG;_P\|=(_A^(_A>>1))&0x40;arrtmp=_A>>7;_A>>=1;_A\|=(_P&C_FLAG)<<7;_P&=~C_FLAG;_P\|=arrtmp;X_ZN(_A));
	341	}
	342	/* ASR */
	343	case 0x4B: LD_IM(AND;LSRA);
	344
	345	/* ATX(OAL) Is this(OR with $EE) correct? */
	346	case 0xAB: LD_IM(_A\|=0xEE;AND;_X=_A);
	347
c0bf6f9f	348	/* AXS */
c62d2810	349	case 0xCB: LD_IM(AXS);
	350
	351	/* DCP */
4fdfab07	352	case 0xC7: RMW_ZP(DEC;CMP);
	353	case 0xD7: RMW_ZPX(DEC;CMP);
	354	case 0xCF: RMW_AB(DEC;CMP);
	355	case 0xDF: RMW_ABX(DEC;CMP);
	356	case 0xDB: RMW_ABY(DEC;CMP);
	357	case 0xC3: RMW_IX(DEC;CMP);
	358	case 0xD3: RMW_IY(DEC;CMP);
c62d2810	359
c62d2810	360	/* ISC */
4fdfab07	361	case 0xE7: RMW_ZP(INC;SBC);
	362	case 0xF7: RMW_ZPX(INC;SBC);
	363	case 0xEF: RMW_AB(INC;SBC);
	364	case 0xFF: RMW_ABX(INC;SBC);
	365	case 0xFB: RMW_ABY(INC;SBC);
	366	case 0xE3: RMW_IX(INC;SBC);
	367	case 0xF3: RMW_IY(INC;SBC);
c62d2810	368
	369	/* DOP */
	370
	371	case 0x04: _PC++;break;
	372	case 0x14: _PC++;break;
	373	case 0x34: _PC++;break;
	374	case 0x44: _PC++;break;
	375	case 0x54: _PC++;break;
	376	case 0x64: _PC++;break;
	377	case 0x74: _PC++;break;
	378
	379	case 0x80: _PC++;break;
	380	case 0x82: _PC++;break;
	381	case 0x89: _PC++;break;
	382	case 0xC2: _PC++;break;
	383	case 0xD4: _PC++;break;
	384	case 0xE2: _PC++;break;
	385	case 0xF4: _PC++;break;
	386
	387	/* KIL */
	388
	389	case 0x02:
	390	case 0x12:
	391	case 0x22:
	392	case 0x32:
	393	case 0x42:
	394	case 0x52:
	395	case 0x62:
	396	case 0x72:
	397	case 0x92:
	398	case 0xB2:
	399	case 0xD2:
	400	case 0xF2:ADDCYC(0xFF);
	401	_jammed=1;
	402	_PC--;
	403	break;
	404
	405	/* LAR */
	406	case 0xBB: RMW_ABY(_S&=x;_A=_X=_S;X_ZN(_X));
	407
	408	/* LAX */
	409	case 0xA7: LD_ZP(LDA;LDX);
	410	case 0xB7: LD_ZPY(LDA;LDX);
	411	case 0xAF: LD_AB(LDA;LDX);
	412	case 0xBF: LD_ABY(LDA;LDX);
	413	case 0xA3: LD_IX(LDA;LDX);
	414	case 0xB3: LD_IY(LDA;LDX);
	415
	416	/* NOP */
	417	case 0x1A:
	418	case 0x3A:
	419	case 0x5A:
	420	case 0x7A:
	421	case 0xDA:
	422	case 0xFA: break;
	423
	424	/* RLA */
	425	case 0x27: RMW_ZP(ROL;AND);
	426	case 0x37: RMW_ZPX(ROL;AND);
	427	case 0x2F: RMW_AB(ROL;AND);
	428	case 0x3F: RMW_ABX(ROL;AND);
	429	case 0x3B: RMW_ABY(ROL;AND);
	430	case 0x23: RMW_IX(ROL;AND);
	431	case 0x33: RMW_IY(ROL;AND);
432
433	/* RRA */
434	case 0x67: RMW_ZP(ROR;ADC);
435	case 0x77: RMW_ZPX(ROR;ADC);
436	case 0x6F: RMW_AB(ROR;ADC);
437	case 0x7F: RMW_ABX(ROR;ADC);
438	case 0x7B: RMW_ABY(ROR;ADC);
439	case 0x63: RMW_IX(ROR;ADC);
440	case 0x73: RMW_IY(ROR;ADC);
441
442	/* SLO */
443	case 0x07: RMW_ZP(ASL;ORA);
444	case 0x17: RMW_ZPX(ASL;ORA);
445	case 0x0F: RMW_AB(ASL;ORA);
446	case 0x1F: RMW_ABX(ASL;ORA);
447	case 0x1B: RMW_ABY(ASL;ORA);
448	case 0x03: RMW_IX(ASL;ORA);
449	case 0x13: RMW_IY(ASL;ORA);
450
451	/* SRE */
452	case 0x47: RMW_ZP(LSR;EOR);
453	case 0x57: RMW_ZPX(LSR;EOR);
454	case 0x4F: RMW_AB(LSR;EOR);
455	case 0x5F: RMW_ABX(LSR;EOR);
456	case 0x5B: RMW_ABY(LSR;EOR);
457	case 0x43: RMW_IX(LSR;EOR);
458	case 0x53: RMW_IY(LSR;EOR);
459
460	/* AXA - SHA */
461	case 0x93: ST_IY(_A&_X&(((A-_Y)>>8)+1));
462	case 0x9F: ST_ABY(_A&_X&(((A-_Y)>>8)+1));
463
464	/* SYA */
465	case 0x9C: ST_ABX(_Y&(((A-_X)>>8)+1));
466
467	/* SXA */
468	case 0x9E: ST_ABY(_X&(((A-_Y)>>8)+1));
469
470	/* XAS */
471	case 0x9B: _S=_A&_X;ST_ABY(_S& (((A-_Y)>>8)+1) );
472
473	/* TOP */
474	case 0x0C: LD_AB(;);
c0bf6f9f	475	case 0x1C:
	476	case 0x3C:
	477	case 0x5C:
	478	case 0x7C:
	479	case 0xDC:
c62d2810	480	case 0xFC: LD_ABX(;);
	481
	482	/* XAA - BIG QUESTION MARK HERE */
	483	case 0x8B: _A\|=0xEE; _A&=_X; LD_IM(AND);