summaryrefslogtreecommitdiffstatshomepage
path: root/src/emu/cpu/lr35902/opc_main.h
diff options
context:
space:
mode:
Diffstat (limited to 'src/emu/cpu/lr35902/opc_main.h')
-rw-r--r--src/emu/cpu/lr35902/opc_main.h1106
1 files changed, 553 insertions, 553 deletions
diff --git a/src/emu/cpu/lr35902/opc_main.h b/src/emu/cpu/lr35902/opc_main.h
index 82a00dd8643..2edab7cbb0e 100644
--- a/src/emu/cpu/lr35902/opc_main.h
+++ b/src/emu/cpu/lr35902/opc_main.h
@@ -1,65 +1,65 @@
-#define INC_8BIT(x) \
+#define INC_8BIT(x) \
{ \
- register UINT8 r,f; \
- x++; \
- r=(x); \
- f=(UINT8)(m_F&FLAG_C); \
- if( r==0 ) f|=FLAG_Z; \
- if( (r&0xF)==0 ) f|=FLAG_H; \
- m_F=f; \
+ register UINT8 r,f; \
+ x++; \
+ r=(x); \
+ f=(UINT8)(m_F&FLAG_C); \
+ if( r==0 ) f|=FLAG_Z; \
+ if( (r&0xF)==0 ) f|=FLAG_H; \
+ m_F=f; \
}
-#define DEC_8BIT(x) \
+#define DEC_8BIT(x) \
{ \
- register UINT8 r,f; \
- x--; \
- r=(x); \
- f=(UINT8)((m_F&FLAG_C)|FLAG_N); \
- if( r==0 ) f|=FLAG_Z; \
- if( (r&0xF)==0xF ) f|=FLAG_H; \
- m_F=f; \
+ register UINT8 r,f; \
+ x--; \
+ r=(x); \
+ f=(UINT8)((m_F&FLAG_C)|FLAG_N); \
+ if( r==0 ) f|=FLAG_Z; \
+ if( (r&0xF)==0xF ) f|=FLAG_H; \
+ m_F=f; \
}
-#define ADD_HL_RR(x) \
+#define ADD_HL_RR(x) \
{ \
- register UINT32 r1,r2; \
- register UINT8 f; \
- r1=((m_H<<8)|m_L)+(x); \
- r2=(((m_H<<8)|m_L)&0xFFF)+((x)&0xFFF); \
- f=(UINT8)(m_F&FLAG_Z); \
- if( r1>0xFFFF ) f|=FLAG_C; \
- if( r2>0x0FFF ) f|=FLAG_H; \
- m_L = r1; \
- m_H = r1 >> 8; \
- m_F=f; \
+ register UINT32 r1,r2; \
+ register UINT8 f; \
+ r1=((m_H<<8)|m_L)+(x); \
+ r2=(((m_H<<8)|m_L)&0xFFF)+((x)&0xFFF); \
+ f=(UINT8)(m_F&FLAG_Z); \
+ if( r1>0xFFFF ) f|=FLAG_C; \
+ if( r2>0x0FFF ) f|=FLAG_H; \
+ m_L = r1; \
+ m_H = r1 >> 8; \
+ m_F=f; \
}
-#define ADD_A_X(x) \
+#define ADD_A_X(x) \
{ \
- register UINT16 r1,r2; \
- register UINT8 f; \
- r1=(UINT16)((m_A&0xF)+((x)&0xF)); \
- r2=(UINT16)(m_A+(x)); \
- m_A=(UINT8)r2; \
- if( ((UINT8)r2)==0 ) f=FLAG_Z; \
- else f=0; \
- if( r2>0xFF ) f|=FLAG_C; \
- if( r1>0xF ) f|=FLAG_H; \
- m_F=f; \
+ register UINT16 r1,r2; \
+ register UINT8 f; \
+ r1=(UINT16)((m_A&0xF)+((x)&0xF)); \
+ r2=(UINT16)(m_A+(x)); \
+ m_A=(UINT8)r2; \
+ if( ((UINT8)r2)==0 ) f=FLAG_Z; \
+ else f=0; \
+ if( r2>0xFF ) f|=FLAG_C; \
+ if( r1>0xF ) f|=FLAG_H; \
+ m_F=f; \
}
-#define SUB_A_X(x) \
+#define SUB_A_X(x) \
{ \
- register UINT16 r1,r2; \
- register UINT8 f; \
- r1=(UINT16)((m_A&0xF)-((x)&0xF)); \
- r2=(UINT16)(m_A-(x)); \
- m_A=(UINT8)r2; \
- if( ((UINT8)r2)==0 ) f=FLAG_N|FLAG_Z; \
- else f=FLAG_N; \
- if( r2>0xFF ) f|=FLAG_C; \
- if( r1>0xF ) f|=FLAG_H; \
- m_F=f; \
+ register UINT16 r1,r2; \
+ register UINT8 f; \
+ r1=(UINT16)((m_A&0xF)-((x)&0xF)); \
+ r2=(UINT16)(m_A-(x)); \
+ m_A=(UINT8)r2; \
+ if( ((UINT8)r2)==0 ) f=FLAG_N|FLAG_Z; \
+ else f=FLAG_N; \
+ if( r2>0xFF ) f|=FLAG_C; \
+ if( r1>0xF ) f|=FLAG_H; \
+ m_F=f; \
}
/*
@@ -79,63 +79,63 @@
}
*/
-#define CP_A_X(x) \
+#define CP_A_X(x) \
{ \
- register UINT16 r1,r2; \
- register UINT8 f; \
- r1=(UINT16)((m_A&0xF)-((x)&0xF)); \
- r2=(UINT16)(m_A-(x)); \
- if( ((UINT8)r2)==0 ) f=FLAG_N|FLAG_Z; \
- else f=FLAG_N; \
- if( r2>0xFF ) f|=FLAG_C; \
- if( r1>0xF ) f|=FLAG_H; \
- m_F=f; \
+ register UINT16 r1,r2; \
+ register UINT8 f; \
+ r1=(UINT16)((m_A&0xF)-((x)&0xF)); \
+ r2=(UINT16)(m_A-(x)); \
+ if( ((UINT8)r2)==0 ) f=FLAG_N|FLAG_Z; \
+ else f=FLAG_N; \
+ if( r2>0xFF ) f|=FLAG_C; \
+ if( r1>0xF ) f|=FLAG_H; \
+ m_F=f; \
}
-#define SBC_A_X(x) \
+#define SBC_A_X(x) \
{ \
- register UINT16 r1,r2; \
- register UINT8 f; \
- r1=(UINT16)((m_A&0xF)-((x)&0xF)-((m_F&FLAG_C)?1:0)); \
- r2=(UINT16)(m_A-(x)-((m_F&FLAG_C)?1:0)); \
- m_A=(UINT8)r2; \
- if( ((UINT8)r2)==0 ) f=FLAG_N|FLAG_Z; \
- else f=FLAG_N; \
- if( r2>0xFF ) f|=FLAG_C; \
- if( r1>0xF ) f|=FLAG_H; \
- m_F=f; \
+ register UINT16 r1,r2; \
+ register UINT8 f; \
+ r1=(UINT16)((m_A&0xF)-((x)&0xF)-((m_F&FLAG_C)?1:0)); \
+ r2=(UINT16)(m_A-(x)-((m_F&FLAG_C)?1:0)); \
+ m_A=(UINT8)r2; \
+ if( ((UINT8)r2)==0 ) f=FLAG_N|FLAG_Z; \
+ else f=FLAG_N; \
+ if( r2>0xFF ) f|=FLAG_C; \
+ if( r1>0xF ) f|=FLAG_H; \
+ m_F=f; \
}
-#define ADC_A_X(x) \
+#define ADC_A_X(x) \
{ \
- register UINT16 r1,r2; \
- register UINT8 f; \
- r1=(UINT16)((m_A&0xF)+((x)&0xF)+((m_F&FLAG_C)?1:0)); \
- r2=(UINT16)(m_A+(x)+((m_F&FLAG_C)?1:0)); \
- if( (m_A=(UINT8)r2)==0 ) f=FLAG_Z; \
- else f=0; \
- if( r2>0xFF ) f|=FLAG_C; \
- if( r1>0xF ) f|=FLAG_H; \
- m_F=f; \
+ register UINT16 r1,r2; \
+ register UINT8 f; \
+ r1=(UINT16)((m_A&0xF)+((x)&0xF)+((m_F&FLAG_C)?1:0)); \
+ r2=(UINT16)(m_A+(x)+((m_F&FLAG_C)?1:0)); \
+ if( (m_A=(UINT8)r2)==0 ) f=FLAG_Z; \
+ else f=0; \
+ if( r2>0xFF ) f|=FLAG_C; \
+ if( r1>0xF ) f|=FLAG_H; \
+ m_F=f; \
}
-#define AND_A_X(x) \
- if( (m_A&=(x))==0 ) \
- m_F=FLAG_H|FLAG_Z; \
- else \
- m_F=FLAG_H;
+#define AND_A_X(x) \
+ if( (m_A&=(x))==0 ) \
+ m_F=FLAG_H|FLAG_Z; \
+ else \
+ m_F=FLAG_H;
#define XOR_A_X(x) \
- if( (m_A^=(x))==0 ) \
- m_F=FLAG_Z; \
- else \
- m_F=0;
+ if( (m_A^=(x))==0 ) \
+ m_F=FLAG_Z; \
+ else \
+ m_F=0;
-#define OR_A_X(x) \
- if( (m_A|=(x))==0 ) \
- m_F=FLAG_Z; \
- else \
- m_F=0;
+#define OR_A_X(x) \
+ if( (m_A|=(x))==0 ) \
+ m_F=FLAG_Z; \
+ else \
+ m_F=0;
#define POP(x,y) \
y = mem_read_byte( m_SP++ ); \
@@ -160,11 +160,11 @@ case 0x02: /* LD (BC),A */
break;
case 0x03: /* INC BC */
-#if 0 /* FIXME ?? do we want to support this? (bug emulation) */
- if (m_B == 0xFE)
- {
- trash_sprites (state);
- }
+#if 0 /* FIXME ?? do we want to support this? (bug emulation) */
+ if (m_B == 0xFE)
+ {
+ trash_sprites (state);
+ }
#endif
m_C++;
if ( m_C == 0 )
@@ -178,8 +178,8 @@ case 0x04: /* INC B */
break;
case 0x05: /* DEC B */
- DEC_8BIT (m_B)
- break;
+ DEC_8BIT (m_B)
+ break;
case 0x06: /* LD B,n8 */
m_B = mem_read_byte( m_PC++ );
@@ -187,16 +187,16 @@ case 0x06: /* LD B,n8 */
case 0x07: /* RLCA */
- m_A = (UINT8) ((m_A << 1) | (m_A >> 7));
- if (m_A & 1)
- {
- m_F = FLAG_C;
- }
- else
- {
- m_F = 0;
- }
- break;
+ m_A = (UINT8) ((m_A << 1) | (m_A >> 7));
+ if (m_A & 1)
+ {
+ m_F = FLAG_C;
+ }
+ else
+ {
+ m_F = 0;
+ }
+ break;
case 0x08: /* LD (n16),SP */
mem_write_word (mem_read_word (m_PC), m_SP);
@@ -209,15 +209,15 @@ case 0x09: /* ADD HL,BC */
break;
case 0x0A: /* LD A,(BC) */
- m_A = mem_read_byte ( (m_B<<8)|m_C );
- break;
+ m_A = mem_read_byte ( (m_B<<8)|m_C );
+ break;
case 0x0B: /* DEC BC */
-#if 0 /* FIXME ?? do we want to support this? (bug emulation) */
- if (m_B == 0xFE)
- {
- trash_sprites (state);
- }
+#if 0 /* FIXME ?? do we want to support this? (bug emulation) */
+ if (m_B == 0xFE)
+ {
+ trash_sprites (state);
+ }
#endif
m_C--;
if ( m_C == 0xFF )
@@ -228,45 +228,45 @@ case 0x0B: /* DEC BC */
break;
case 0x0C: /* INC C */
- INC_8BIT (m_C)
- break;
+ INC_8BIT (m_C)
+ break;
case 0x0D: /* DEC C */
- DEC_8BIT (m_C)
- break;
+ DEC_8BIT (m_C)
+ break;
case 0x0E: /* LD C,n8 */
- m_C = mem_read_byte ( m_PC++ );
- break;
+ m_C = mem_read_byte ( m_PC++ );
+ break;
case 0x0F: /* RRCA */
- m_A = (UINT8) ((m_A >> 1) | (m_A << 7));
- m_F = 0;
- if (m_A & 0x80)
- {
- m_F |= FLAG_C;
- }
- break;
+ m_A = (UINT8) ((m_A >> 1) | (m_A << 7));
+ m_F = 0;
+ if (m_A & 0x80)
+ {
+ m_F |= FLAG_C;
+ }
+ break;
case 0x10: /* STOP */
- if ( m_gb_speed_change_pending ) {
- m_gb_speed = ( m_gb_speed == 1 ) ? 2 : 1;
- }
- m_gb_speed_change_pending = 0;
- break;
+ if ( m_gb_speed_change_pending ) {
+ m_gb_speed = ( m_gb_speed == 1 ) ? 2 : 1;
+ }
+ m_gb_speed_change_pending = 0;
+ break;
case 0x11: /* LD DE,n16 */
m_E = mem_read_byte( m_PC++ );
m_D = mem_read_byte( m_PC++ );
break;
case 0x12: /* LD (DE),A */
- mem_write_byte( ( m_D << 8 ) | m_E, m_A );
- break;
+ mem_write_byte( ( m_D << 8 ) | m_E, m_A );
+ break;
case 0x13: /* INC DE */
-#if 0 /* FIXME ?? do we want to support this? (bug emulation) */
- if (m_D == 0xFE)
- {
- trash_sprites (state);
- }
+#if 0 /* FIXME ?? do we want to support this? (bug emulation) */
+ if (m_D == 0xFE)
+ {
+ trash_sprites (state);
+ }
#endif
m_E++;
if ( m_E == 0 )
@@ -277,47 +277,47 @@ case 0x13: /* INC DE */
break;
case 0x14: /* INC D */
- INC_8BIT (m_D)
- break;
+ INC_8BIT (m_D)
+ break;
case 0x15: /* DEC D */
- DEC_8BIT (m_D)
- break;
+ DEC_8BIT (m_D)
+ break;
case 0x16: /* LD D,n8 */
- m_D = mem_read_byte ( m_PC++ );
- break;
+ m_D = mem_read_byte ( m_PC++ );
+ break;
case 0x17: /* RLA */
- x = (m_A & 0x80) ? FLAG_C : 0;
+ x = (m_A & 0x80) ? FLAG_C : 0;
- m_A = (UINT8) ((m_A << 1) | ((m_F & FLAG_C) ? 1 : 0));
- m_F = x;
- break;
+ m_A = (UINT8) ((m_A << 1) | ((m_F & FLAG_C) ? 1 : 0));
+ m_F = x;
+ break;
case 0x18: /* JR n8 */
- {
+ {
INT8 offset;
- offset = mem_read_byte( m_PC++ );
- m_PC += offset;
+ offset = mem_read_byte( m_PC++ );
+ m_PC += offset;
cycles_passed( 4 );
- }
- break;
+ }
+ break;
case 0x19: /* ADD HL,DE */
ADD_HL_RR (( m_D << 8 ) | m_E)
cycles_passed( 4 );
break;
case 0x1A: /* LD A,(DE) */
- m_A = mem_read_byte( ( m_D << 8 ) | m_E );
- break;
+ m_A = mem_read_byte( ( m_D << 8 ) | m_E );
+ break;
case 0x1B: /* DEC DE */
-#if 0 /* FIXME ?? do we want to support this? (bug emulation) */
- if (m_D == 0xFE)
- {
- trash_sprites (state);
- }
+#if 0 /* FIXME ?? do we want to support this? (bug emulation) */
+ if (m_D == 0xFE)
+ {
+ trash_sprites (state);
+ }
#endif
m_E--;
if ( m_E == 0xFF )
@@ -328,23 +328,23 @@ case 0x1B: /* DEC DE */
break;
case 0x1C: /* INC E */
- INC_8BIT (m_E)
- break;
+ INC_8BIT (m_E)
+ break;
case 0x1D: /* DEC E */
- DEC_8BIT (m_E)
- break;
+ DEC_8BIT (m_E)
+ break;
case 0x1E: /* LD E,n8 */
- m_E = mem_read_byte( m_PC++ );
- break;
+ m_E = mem_read_byte( m_PC++ );
+ break;
case 0x1F: /* RRA */
- x = (m_A & 1) ? FLAG_C : 0;
+ x = (m_A & 1) ? FLAG_C : 0;
- m_A = (UINT8) ((m_A >> 1) | ((m_F & FLAG_C) ? 0x80 : 0));
- m_F = x;
- break;
+ m_A = (UINT8) ((m_A >> 1) | ((m_F & FLAG_C) ? 0x80 : 0));
+ m_F = x;
+ break;
case 0x20: /* JR NZ,n8 */
{
INT8 offset = mem_read_byte( m_PC++ );
@@ -361,11 +361,11 @@ case 0x21: /* LD HL,n16 */
break;
case 0x22: /* LD (HL+),A */
-#if 0 /* FIXME ?? do we want to support this? (bug emulation) */
- if (m_H == 0xFE)
- {
- trash_sprites (state);
- }
+#if 0 /* FIXME ?? do we want to support this? (bug emulation) */
+ if (m_H == 0xFE)
+ {
+ trash_sprites (state);
+ }
#endif
mem_write_byte( (m_H << 8 ) | m_L, m_A );
m_L++;
@@ -376,11 +376,11 @@ case 0x22: /* LD (HL+),A */
break;
case 0x23: /* INC HL */
-#if 0 /* FIXME ?? do we want to support this? (bug emulation) */
- if (m_H == 0xFE)
- {
- trash_sprites (state);
- }
+#if 0 /* FIXME ?? do we want to support this? (bug emulation) */
+ if (m_H == 0xFE)
+ {
+ trash_sprites (state);
+ }
#endif
m_L++;
if ( m_L == 0 )
@@ -391,16 +391,16 @@ case 0x23: /* INC HL */
break;
case 0x24: /* INC H */
- INC_8BIT (m_H);
- break;
+ INC_8BIT (m_H);
+ break;
case 0x25: /* DEC H */
- DEC_8BIT (m_H);
- break;
+ DEC_8BIT (m_H);
+ break;
case 0x26: /* LD H,n8 */
- m_H = mem_read_byte( m_PC++ );
- break;
+ m_H = mem_read_byte( m_PC++ );
+ break;
case 0x27: /* DAA */
{
int tmp = m_A;
@@ -426,7 +426,7 @@ case 0x27: /* DAA */
if ( ! m_A )
m_F |= FLAG_Z;
}
- break;
+ break;
case 0x28: /* JR Z,n8 */
{
INT8 offset = mem_read_byte( m_PC++ );
@@ -443,11 +443,11 @@ case 0x29: /* ADD HL,HL */
cycles_passed( 4 );
break;
case 0x2A: /* LD A,(HL+) */
-#if 0 /* FIXME ?? do we want to support this? (bug emulation) */
- if (m_H == 0xFE)
- {
- trash_sprites (state);
- }
+#if 0 /* FIXME ?? do we want to support this? (bug emulation) */
+ if (m_H == 0xFE)
+ {
+ trash_sprites (state);
+ }
#endif
m_A = mem_read_byte( ( m_H << 8 ) | m_L );
m_L++;
@@ -458,11 +458,11 @@ case 0x2A: /* LD A,(HL+) */
break;
case 0x2B: /* DEC HL */
-#if 0 /* FIXME ?? do we want to support this? (bug emulation) */
- if (m_H == 0xFE)
- {
- trash_sprites (state);
- }
+#if 0 /* FIXME ?? do we want to support this? (bug emulation) */
+ if (m_H == 0xFE)
+ {
+ trash_sprites (state);
+ }
#endif
m_L--;
if ( m_L == 0xFF )
@@ -473,21 +473,21 @@ case 0x2B: /* DEC HL */
break;
case 0x2C: /* INC L */
- INC_8BIT (m_L);
- break;
+ INC_8BIT (m_L);
+ break;
case 0x2D: /* DEC L */
- DEC_8BIT (m_L);
- break;
+ DEC_8BIT (m_L);
+ break;
case 0x2E: /* LD L,n8 */
- m_L = mem_read_byte( m_PC++ );
- break;
+ m_L = mem_read_byte( m_PC++ );
+ break;
case 0x2F: /* CPL */
- m_A = ~m_A;
- m_F |= FLAG_N | FLAG_H;
- break;
+ m_A = ~m_A;
+ m_F |= FLAG_N | FLAG_H;
+ break;
case 0x30: /* JR NC,n8 */
{
INT8 offset = mem_read_byte( m_PC++ );
@@ -501,16 +501,16 @@ case 0x30: /* JR NC,n8 */
break;
case 0x31: /* LD SP,n16 */
- m_SP = mem_read_word( m_PC );
- m_PC += 2;
- break;
+ m_SP = mem_read_word( m_PC );
+ m_PC += 2;
+ break;
case 0x32: /* LD (HL-),A */
-#if 0 /* FIXME ?? do we want to support this? (bug emulation) */
- if (m_H == 0xFE)
- {
- trash_sprites (state);
- }
+#if 0 /* FIXME ?? do we want to support this? (bug emulation) */
+ if (m_H == 0xFE)
+ {
+ trash_sprites (state);
+ }
#endif
mem_write_byte( ( m_H << 8 ) | m_L, m_A );
m_L--;
@@ -569,8 +569,8 @@ case 0x36: /* LD (HL),n8 */
break;
case 0x37: /* SCF */
- m_F = (UINT8) ((m_F & FLAG_Z) | FLAG_C);
- break;
+ m_F = (UINT8) ((m_F & FLAG_Z) | FLAG_C);
+ break;
case 0x38: /* JR C,n8 */
{
INT8 offset = mem_read_byte( m_PC++ );
@@ -587,11 +587,11 @@ case 0x39: /* ADD HL,SP */
cycles_passed( 4 );
break;
case 0x3A: /* LD A,(HL-) */
-#if 0 /* FIXME ?? do we want to support this? (bug emulation) */
- if (m_H == 0xFE)
- {
- trash_sprites (state);
- }
+#if 0 /* FIXME ?? do we want to support this? (bug emulation) */
+ if (m_H == 0xFE)
+ {
+ trash_sprites (state);
+ }
#endif
m_A = mem_read_byte( ( m_H << 8 ) | m_L );
m_L--;
@@ -606,72 +606,72 @@ case 0x3B: /* DEC SP */
break;
case 0x3C: /* INC A */
- INC_8BIT (m_A);
- break;
+ INC_8BIT (m_A);
+ break;
case 0x3D: /* DEC A */
- DEC_8BIT (m_A);
- break;
+ DEC_8BIT (m_A);
+ break;
case 0x3E: /* LD A,n8 */
- m_A = mem_read_byte( m_PC++ );
- break;
+ m_A = mem_read_byte( m_PC++ );
+ break;
case 0x3F: /* CCF */
- m_F = (UINT8) ((m_F & FLAG_Z) | ((m_F & FLAG_C) ? 0 : FLAG_C));
- break;
+ m_F = (UINT8) ((m_F & FLAG_Z) | ((m_F & FLAG_C) ? 0 : FLAG_C));
+ break;
case 0x40: /* LD B,B */
- break;
+ break;
case 0x41: /* LD B,C */
- m_B = m_C;
- break;
+ m_B = m_C;
+ break;
case 0x42: /* LD B,D */
- m_B = m_D;
- break;
+ m_B = m_D;
+ break;
case 0x43: /* LD B,E */
- m_B = m_E;
- break;
+ m_B = m_E;
+ break;
case 0x44: /* LD B,H */
- m_B = m_H;
- break;
+ m_B = m_H;
+ break;
case 0x45: /* LD B,L */
- m_B = m_L;
- break;
+ m_B = m_L;
+ break;
case 0x46: /* LD B,(HL) */
m_B = mem_read_byte( ( m_H << 8 ) | m_L) ;
break;
case 0x47: /* LD B,A */
- m_B = m_A;
- break;
+ m_B = m_A;
+ break;
case 0x48: /* LD C,B */
- m_C = m_B;
- break;
+ m_C = m_B;
+ break;
case 0x49: /* LD C,C */
- break;
+ break;
case 0x4A: /* LD C,D */
- m_C = m_D;
- break;
+ m_C = m_D;
+ break;
case 0x4B: /* LD C,E */
- m_C = m_E;
- break;
+ m_C = m_E;
+ break;
case 0x4C: /* LD C,H */
- m_C = m_H;
- break;
+ m_C = m_H;
+ break;
case 0x4D: /* LD C,L */
- m_C = m_L;
- break;
+ m_C = m_L;
+ break;
case 0x4E: /* LD C,(HL) */
m_C = mem_read_byte( ( m_H << 8 ) | m_L );
@@ -679,127 +679,127 @@ case 0x4E: /* LD C,(HL) */
case 0x4F: /* LD C,A */
- m_C = m_A;
- break;
+ m_C = m_A;
+ break;
case 0x50: /* LD D,B */
- m_D = m_B;
- break;
+ m_D = m_B;
+ break;
case 0x51: /* LD D,C */
- m_D = m_C;
- break;
+ m_D = m_C;
+ break;
case 0x52: /* LD D,D */
- break;
+ break;
case 0x53: /* LD D,E */
- m_D = m_E;
- break;
+ m_D = m_E;
+ break;
case 0x54: /* LD D,H */
- m_D = m_H;
- break;
+ m_D = m_H;
+ break;
case 0x55: /* LD D,L */
- m_D = m_L;
- break;
+ m_D = m_L;
+ break;
case 0x56: /* LD D,(HL) */
- m_D = mem_read_byte( ( m_H << 8 ) | m_L );
- break;
+ m_D = mem_read_byte( ( m_H << 8 ) | m_L );
+ break;
case 0x57: /* LD D,A */
- m_D = m_A;
- break;
+ m_D = m_A;
+ break;
case 0x58: /* LD E,B */
- m_E = m_B;
- break;
+ m_E = m_B;
+ break;
case 0x59: /* LD E,C */
- m_E = m_C;
- break;
+ m_E = m_C;
+ break;
case 0x5A: /* LD E,D */
- m_E = m_D;
- break;
+ m_E = m_D;
+ break;
case 0x5B: /* LD E,E */
- break;
+ break;
case 0x5C: /* LD E,H */
- m_E = m_H;
- break;
+ m_E = m_H;
+ break;
case 0x5D: /* LD E,L */
- m_E = m_L;
- break;
+ m_E = m_L;
+ break;
case 0x5E: /* LD E,(HL) */
- m_E = mem_read_byte( ( m_H << 8 ) | m_L );
- break;
+ m_E = mem_read_byte( ( m_H << 8 ) | m_L );
+ break;
case 0x5F: /* LD E,A */
- m_E = m_A;
- break;
+ m_E = m_A;
+ break;
case 0x60: /* LD H,B */
- m_H = m_B;
- break;
+ m_H = m_B;
+ break;
case 0x61: /* LD H,C */
- m_H = m_C;
- break;
+ m_H = m_C;
+ break;
case 0x62: /* LD H,D */
- m_H = m_D;
- break;
+ m_H = m_D;
+ break;
case 0x63: /* LD H,E */
- m_H = m_E;
- break;
+ m_H = m_E;
+ break;
case 0x64: /* LD H,H */
- break;
+ break;
case 0x65: /* LD H,L */
- m_H = m_L;
- break;
+ m_H = m_L;
+ break;
case 0x66: /* LD H,(HL) */
- m_H = mem_read_byte( ( m_H << 8 ) | m_L );
- break;
+ m_H = mem_read_byte( ( m_H << 8 ) | m_L );
+ break;
case 0x67: /* LD H,A */
- m_H = m_A;
- break;
+ m_H = m_A;
+ break;
case 0x68: /* LD L,B */
- m_L = m_B;
- break;
+ m_L = m_B;
+ break;
case 0x69: /* LD L,C */
- m_L = m_C;
- break;
+ m_L = m_C;
+ break;
case 0x6A: /* LD L,D */
- m_L = m_D;
- break;
+ m_L = m_D;
+ break;
case 0x6B: /* LD L,E */
- m_L = m_E;
- break;
+ m_L = m_E;
+ break;
case 0x6C: /* LD L,H */
- m_L = m_H;
- break;
+ m_L = m_H;
+ break;
case 0x6D: /* LD L,L */
- break;
+ break;
case 0x6E: /* LD L,(HL) */
- m_L = mem_read_byte( ( m_H << 8 ) | m_L );
- break;
+ m_L = mem_read_byte( ( m_H << 8 ) | m_L );
+ break;
case 0x6F: /* LD L,A */
- m_L = m_A;
- break;
+ m_L = m_A;
+ break;
case 0x70: /* LD (HL),B */
mem_write_byte( ( m_H << 8 ) | m_L, m_B );
@@ -829,307 +829,307 @@ case 0x77: /* LD (HL),A */
break;
case 0x78: /* LD A,B */
- m_A = m_B;
- break;
+ m_A = m_B;
+ break;
case 0x79: /* LD A,C */
- m_A = m_C;
- break;
+ m_A = m_C;
+ break;
case 0x7A: /* LD A,D */
- m_A = m_D;
- break;
+ m_A = m_D;
+ break;
case 0x7B: /* LD A,E */
- m_A = m_E;
- break;
+ m_A = m_E;
+ break;
case 0x7C: /* LD A,H */
- m_A = m_H;
- break;
+ m_A = m_H;
+ break;
case 0x7D: /* LD A,L */
- m_A = m_L;
- break;
+ m_A = m_L;
+ break;
case 0x7E: /* LD A,(HL) */
- m_A = mem_read_byte( ( m_H << 8 ) | m_L );
- break;
+ m_A = mem_read_byte( ( m_H << 8 ) | m_L );
+ break;
case 0x7F: /* LD A,A */
- break;
+ break;
case 0x80: /* ADD A,B */
- ADD_A_X (m_B)
- break;
+ ADD_A_X (m_B)
+ break;
case 0x81: /* ADD A,C */
- ADD_A_X (m_C)
- break;
+ ADD_A_X (m_C)
+ break;
case 0x82: /* ADD A,D */
- ADD_A_X (m_D)
- break;
+ ADD_A_X (m_D)
+ break;
case 0x83: /* ADD A,E */
- ADD_A_X (m_E)
- break;
+ ADD_A_X (m_E)
+ break;
case 0x84: /* ADD A,H */
- ADD_A_X (m_H)
- break;
+ ADD_A_X (m_H)
+ break;
case 0x85: /* ADD A,L */
- ADD_A_X (m_L)
- break;
+ ADD_A_X (m_L)
+ break;
case 0x86: /* ADD A,(HL) */
- x = mem_read_byte( ( m_H << 8 ) | m_L );
+ x = mem_read_byte( ( m_H << 8 ) | m_L );
- ADD_A_X (x)
- break;
+ ADD_A_X (x)
+ break;
case 0x87: /* ADD A,A */
- ADD_A_X (m_A)
- break;
+ ADD_A_X (m_A)
+ break;
case 0x88: /* ADC A,B */
- ADC_A_X (m_B)
- break;
+ ADC_A_X (m_B)
+ break;
case 0x89: /* ADC A,C */
- ADC_A_X (m_C)
- break;
+ ADC_A_X (m_C)
+ break;
case 0x8A: /* ADC A,D */
- ADC_A_X (m_D)
- break;
+ ADC_A_X (m_D)
+ break;
case 0x8B: /* ADC A,E */
- ADC_A_X (m_E)
- break;
+ ADC_A_X (m_E)
+ break;
case 0x8C: /* ADC A,H */
- ADC_A_X (m_H)
- break;
+ ADC_A_X (m_H)
+ break;
case 0x8D: /* ADC A,L */
- ADC_A_X (m_L)
- break;
+ ADC_A_X (m_L)
+ break;
case 0x8E: /* ADC A,(HL) */
- x = mem_read_byte( ( m_H << 8 ) | m_L );
+ x = mem_read_byte( ( m_H << 8 ) | m_L );
- ADC_A_X (x)
- break;
+ ADC_A_X (x)
+ break;
case 0x8F: /* ADC A,A */
- ADC_A_X (m_A)
- break;
+ ADC_A_X (m_A)
+ break;
case 0x90: /* SUB A,B */
- SUB_A_X (m_B)
- break;
+ SUB_A_X (m_B)
+ break;
case 0x91: /* SUB A,C */
- SUB_A_X (m_C)
- break;
+ SUB_A_X (m_C)
+ break;
case 0x92: /* SUB A,D */
- SUB_A_X (m_D)
- break;
+ SUB_A_X (m_D)
+ break;
case 0x93: /* SUB A,E */
- SUB_A_X (m_E)
- break;
+ SUB_A_X (m_E)
+ break;
case 0x94: /* SUB A,H */
- SUB_A_X (m_H)
- break;
+ SUB_A_X (m_H)
+ break;
case 0x95: /* SUB A,L */
- SUB_A_X (m_L)
- break;
+ SUB_A_X (m_L)
+ break;
case 0x96: /* SUB A,(HL) */
- x = mem_read_byte( ( m_H << 8 ) | m_L );
+ x = mem_read_byte( ( m_H << 8 ) | m_L );
- SUB_A_X (x)
- break;
+ SUB_A_X (x)
+ break;
case 0x97: /* SUB A,A */
- SUB_A_X (m_A)
- break;
+ SUB_A_X (m_A)
+ break;
case 0x98: /* SBC A,B */
- SBC_A_X (m_B)
- break;
+ SBC_A_X (m_B)
+ break;
case 0x99: /* SBC A,C */
- SBC_A_X (m_C)
- break;
+ SBC_A_X (m_C)
+ break;
case 0x9A: /* SBC A,D */
- SBC_A_X (m_D)
- break;
+ SBC_A_X (m_D)
+ break;
case 0x9B: /* SBC A,E */
- SBC_A_X (m_E)
- break;
+ SBC_A_X (m_E)
+ break;
case 0x9C: /* SBC A,H */
- SBC_A_X (m_H)
- break;
+ SBC_A_X (m_H)
+ break;
case 0x9D: /* SBC A,L */
- SBC_A_X (m_L)
- break;
+ SBC_A_X (m_L)
+ break;
case 0x9E: /* SBC A,(HL) */
- x = mem_read_byte( ( m_H << 8 ) | m_L );
+ x = mem_read_byte( ( m_H << 8 ) | m_L );
- SBC_A_X (x)
- break;
+ SBC_A_X (x)
+ break;
case 0x9F: /* SBC A,A */
- SBC_A_X (m_A)
- break;
+ SBC_A_X (m_A)
+ break;
case 0xA0: /* AND A,B */
- AND_A_X (m_B)
- break;
+ AND_A_X (m_B)
+ break;
case 0xA1: /* AND A,C */
- AND_A_X (m_C)
- break;
+ AND_A_X (m_C)
+ break;
case 0xA2: /* AND A,D */
- AND_A_X (m_D)
- break;
+ AND_A_X (m_D)
+ break;
case 0xA3: /* AND A,E */
- AND_A_X (m_E)
- break;
+ AND_A_X (m_E)
+ break;
case 0xA4: /* AND A,H */
- AND_A_X (m_H)
- break;
+ AND_A_X (m_H)
+ break;
case 0xA5: /* AND A,L */
- AND_A_X (m_L)
- break;
+ AND_A_X (m_L)
+ break;
case 0xA6: /* AND A,(HL) */
- x = mem_read_byte( ( m_H << 8 ) | m_L );
+ x = mem_read_byte( ( m_H << 8 ) | m_L );
- AND_A_X (x)
- break;
+ AND_A_X (x)
+ break;
case 0xA7: /* AND A,A */
- m_F = (m_A == 0) ? (FLAG_H | FLAG_Z) : FLAG_H;
- break;
+ m_F = (m_A == 0) ? (FLAG_H | FLAG_Z) : FLAG_H;
+ break;
case 0xA8: /* XOR A,B */
- XOR_A_X (m_B)
- break;
+ XOR_A_X (m_B)
+ break;
case 0xA9: /* XOR A,C */
- XOR_A_X (m_C)
- break;
+ XOR_A_X (m_C)
+ break;
case 0xAA: /* XOR A,D */
- XOR_A_X (m_D)
- break;
+ XOR_A_X (m_D)
+ break;
case 0xAB: /* XOR A,E */
- XOR_A_X (m_E)
- break;
+ XOR_A_X (m_E)
+ break;
case 0xAC: /* XOR A,H */
- XOR_A_X (m_H)
- break;
+ XOR_A_X (m_H)
+ break;
case 0xAD: /* XOR A,L */
- XOR_A_X (m_L)
- break;
+ XOR_A_X (m_L)
+ break;
case 0xAE: /* XOR A,(HL) */
- x = mem_read_byte( ( m_H << 8 ) | m_L );
+ x = mem_read_byte( ( m_H << 8 ) | m_L );
- XOR_A_X (x)
- break;
+ XOR_A_X (x)
+ break;
case 0xAF: /* XOR A,A */
- XOR_A_X (m_A)
- break;
+ XOR_A_X (m_A)
+ break;
case 0xB0: /* OR A,B */
- OR_A_X (m_B)
- break;
+ OR_A_X (m_B)
+ break;
case 0xB1: /* OR A,C */
- OR_A_X (m_C)
- break;
+ OR_A_X (m_C)
+ break;
case 0xB2: /* OR A,D */
- OR_A_X (m_D)
- break;
+ OR_A_X (m_D)
+ break;
case 0xB3: /* OR A,E */
- OR_A_X (m_E)
- break;
+ OR_A_X (m_E)
+ break;
case 0xB4: /* OR A,H */
- OR_A_X (m_H)
- break;
+ OR_A_X (m_H)
+ break;
case 0xB5: /* OR A,L */
- OR_A_X (m_L)
- break;
+ OR_A_X (m_L)
+ break;
case 0xB6: /* OR A,(HL) */
- x = mem_read_byte( ( m_H << 8 ) | m_L );
+ x = mem_read_byte( ( m_H << 8 ) | m_L );
- OR_A_X (x)
- break;
+ OR_A_X (x)
+ break;
case 0xB7: /* OR A,A */
- OR_A_X (m_A)
- break;
+ OR_A_X (m_A)
+ break;
case 0xB8: /* CP A,B */
- CP_A_X (m_B)
- break;
+ CP_A_X (m_B)
+ break;
case 0xB9: /* CP A,C */
- CP_A_X (m_C)
- break;
+ CP_A_X (m_C)
+ break;
case 0xBA: /* CP A,D */
- CP_A_X (m_D)
- break;
+ CP_A_X (m_D)
+ break;
case 0xBB: /* CP A,E */
- CP_A_X (m_E)
- break;
+ CP_A_X (m_E)
+ break;
case 0xBC: /* CP A,H */
- CP_A_X (m_H)
- break;
+ CP_A_X (m_H)
+ break;
case 0xBD: /* CP A,L */
- CP_A_X (m_L)
- break;
+ CP_A_X (m_L)
+ break;
case 0xBE: /* CP A,(HL) */
- x = mem_read_byte( ( m_H << 8 ) | m_L );
+ x = mem_read_byte( ( m_H << 8 ) | m_L );
- CP_A_X (x)
- break;
+ CP_A_X (x)
+ break;
case 0xBF: /* CP A,A */
- CP_A_X (m_A)
- break;
+ CP_A_X (m_A)
+ break;
case 0xC0: /* RET NZ */
cycles_passed( 4 );
if (!(m_F & FLAG_Z))
@@ -1178,9 +1178,9 @@ case 0xC5: /* PUSH BC */
break;
case 0xC6: /* ADD A,n8 */
- x = mem_read_byte( m_PC++ );
- ADD_A_X (x)
- break;
+ x = mem_read_byte( m_PC++ );
+ ADD_A_X (x)
+ break;
case 0xC7: /* RST 0 */
m_SP -= 2;
mem_write_word( m_SP, m_PC );
@@ -1214,12 +1214,12 @@ case 0xCA: /* JP Z,n16 */
}
break;
case 0xCB: /* PREFIX! */
- x = mem_read_byte( m_PC++ );
- switch (x)
- {
- #include "opc_cb.h"
- }
- break;
+ x = mem_read_byte( m_PC++ );
+ switch (x)
+ {
+ #include "opc_cb.h"
+ }
+ break;
case 0xCC: /* CALL Z,n16 */
{
UINT16 addr = mem_read_word( m_PC );
@@ -1247,9 +1247,9 @@ case 0xCD: /* CALL n16 */
break;
case 0xCE: /* ADC A,n8 */
- x = mem_read_byte( m_PC++ );
- ADC_A_X (x)
- break;
+ x = mem_read_byte( m_PC++ );
+ ADC_A_X (x)
+ break;
case 0xCF: /* RST 8 */
m_SP -= 2;
mem_write_word( m_SP, m_PC );
@@ -1281,7 +1281,7 @@ case 0xD2: /* JP NC,n16 */
}
break;
case 0xD3: /* EH? */
- break;
+ break;
case 0xD4: /* CALL NC,n16 */
{
UINT16 addr = mem_read_word( m_PC );
@@ -1302,9 +1302,9 @@ case 0xD5: /* PUSH DE */
break;
case 0xD6: /* SUB A,n8 */
- x = mem_read_byte( m_PC++ );
- SUB_A_X (x)
- break;
+ x = mem_read_byte( m_PC++ );
+ SUB_A_X (x)
+ break;
case 0xD7: /* RST $10 */
m_SP -= 2;
mem_write_word( m_SP, m_PC );
@@ -1339,7 +1339,7 @@ case 0xDA: /* JP C,n16 */
}
break;
case 0xDB: /* EH? */
- break;
+ break;
case 0xDC: /* CALL C,n16 */
{
UINT16 addr = mem_read_word( m_PC );
@@ -1355,12 +1355,12 @@ case 0xDC: /* CALL C,n16 */
}
break;
case 0xDD: /* EH? */
- break;
+ break;
case 0xDE: /* SBC A,n8 */
- x = mem_read_byte( m_PC++ );
- SBC_A_X (x)
- break;
+ x = mem_read_byte( m_PC++ );
+ SBC_A_X (x)
+ break;
case 0xDF: /* RST $18 */
m_SP -= 2;
mem_write_word( m_SP, m_PC );
@@ -1368,31 +1368,31 @@ case 0xDF: /* RST $18 */
cycles_passed( 4 );
break;
case 0xE0: /* LD ($FF00+n8),A */
- {
+ {
UINT8 v = mem_read_byte( m_PC++ );
mem_write_byte( 0xFF00 + v, m_A );
- }
- break;
+ }
+ break;
case 0xE1: /* POP HL */
POP( m_H, m_L );
break;
case 0xE2: /* LD ($FF00+C),A */
- mem_write_byte( 0xFF00 + m_C, m_A );
- break;
+ mem_write_byte( 0xFF00 + m_C, m_A );
+ break;
case 0xE3: /* EH? */
- break;
+ break;
case 0xE4: /* EH? */
- break;
+ break;
case 0xE5: /* PUSH HL */
PUSH( m_H, m_L );
cycles_passed( 4 );
break;
case 0xE6: /* AND A,n8 */
- x = mem_read_byte( m_PC++ );
- AND_A_X (x)
- break;
+ x = mem_read_byte( m_PC++ );
+ AND_A_X (x)
+ break;
case 0xE7: /* RST $20 */
m_SP -= 2;
mem_write_word( m_SP, m_PC );
@@ -1407,48 +1407,48 @@ case 0xE8: /* ADD SP,n8 */
* C - Set or reset according to operation.
*/
- {
+ {
register INT32 n;
n = (INT8) mem_read_byte( m_PC++ );
if ( ( m_SP & 0xFF ) + (UINT8)(n & 0xFF) > 0xFF )
- {
- m_F = FLAG_C;
- }
- else
- {
- m_F = 0;
- }
-
- if ( ( m_SP & 0x0F ) + ( n & 0x0F ) > 0x0F )
- {
- m_F |= FLAG_H;
- }
+ {
+ m_F = FLAG_C;
+ }
+ else
+ {
+ m_F = 0;
+ }
+
+ if ( ( m_SP & 0x0F ) + ( n & 0x0F ) > 0x0F )
+ {
+ m_F |= FLAG_H;
+ }
m_SP = (UINT16) ( m_SP + n );
- }
- cycles_passed( 8 );
- break;
+ }
+ cycles_passed( 8 );
+ break;
case 0xE9: /* JP (HL) */
m_PC = ( m_H << 8 ) | m_L;
break;
case 0xEA: /* LD (n16),A */
- mem_write_byte( mem_read_word( m_PC ), m_A );
- m_PC += 2;
- break;
+ mem_write_byte( mem_read_word( m_PC ), m_A );
+ m_PC += 2;
+ break;
case 0xEB: /* EH? */
- break;
+ break;
case 0xEC: /* EH? */
- break;
+ break;
case 0xED: /* EH? */
- break;
+ break;
case 0xEE: /* XOR A,n8 */
- x = mem_read_byte( m_PC++ );
- XOR_A_X (x)
- break;
+ x = mem_read_byte( m_PC++ );
+ XOR_A_X (x)
+ break;
case 0xEF: /* RST $28 */
m_SP -= 2;
mem_write_word( m_SP, m_PC );
@@ -1456,25 +1456,25 @@ case 0xEF: /* RST $28 */
cycles_passed( 4 );
break;
case 0xF0: /* LD A,($FF00+n8) */
- {
+ {
UINT8 v = mem_read_byte( m_PC++ );
m_A = mem_read_byte( 0xFF00 + v );
- }
- break;
+ }
+ break;
case 0xF1: /* POP AF */
POP( m_A, m_F );
m_F &= 0xF0;
break;
case 0xF2: /* LD A,($FF00+C) */
- m_A = mem_read_byte( 0xFF00 + m_C );
- break;
+ m_A = mem_read_byte( 0xFF00 + m_C );
+ break;
case 0xF3: /* DI */
- m_ei_delay = 0;
- m_enable &= ~IME;
- break;
+ m_ei_delay = 0;
+ m_enable &= ~IME;
+ break;
case 0xF4: /* EH? */
- break;
+ break;
case 0xF5: /* PUSH AF */
m_F &= 0xF0;
PUSH( m_A, m_F );
@@ -1482,9 +1482,9 @@ case 0xF5: /* PUSH AF */
break;
case 0xF6: /* OR A,n8 */
- x = mem_read_byte( m_PC++ );
- OR_A_X (x)
- break;
+ x = mem_read_byte( m_PC++ );
+ OR_A_X (x)
+ break;
case 0xF7: /* RST $30 */
m_SP -= 2;
mem_write_word( m_SP, m_PC );
@@ -1502,32 +1502,32 @@ case 0xF8: /* LD HL,SP+n8 */
*
*/
- {
+ {
register INT32 n;
n = (INT8) mem_read_byte( m_PC++ );
if ( ( m_SP & 0xFF ) + (UINT8)(n & 0xFF) > 0xFF )
- {
- m_F = FLAG_C;
- }
- else
- {
- m_F = 0;
- }
+ {
+ m_F = FLAG_C;
+ }
+ else
+ {
+ m_F = 0;
+ }
if ( ( m_SP & 0x0F ) + ( n & 0x0F ) > 0x0F )
- {
- m_F |= FLAG_H;
- }
+ {
+ m_F |= FLAG_H;
+ }
UINT16 res = m_SP + n;
m_L = res & 0xFF;
m_H = res >> 8;
- }
- cycles_passed( 4 );
- break;
+ }
+ cycles_passed( 4 );
+ break;
case 0xF9: /* LD SP,HL */
m_SP = ( m_H << 8 ) | m_L;
cycles_passed( 4 );