gfaraday/chibi-pc09
1
0
Fork 0
forked from amberisvibin/chibi-pc09
Code Pull Requests Activity
Files
3d512678961616c95e86bb89c3980251d8370a3f
chibi-pc09/emu/z80pack-1.9/z80sim/sim1.c
Amber 783d32a495 copy all local files to repo 
cp/m files, sprites, circuit design
2020-05-15 09:07:45 -04:00

3299 lines
64 KiB
C
Raw Blame History

/*
* Z80SIM - a Z80-CPU simulator
*
* Copyright (C) 1987-2006 by Udo Munk
*
* History:
* 28-SEP-87 Development on TARGON/35 with AT&T Unix System V.3
* 11-JAN-89 Release 1.1
* 08-FEB-89 Release 1.2
* 13-MAR-89 Release 1.3
* 09-FEB-90 Release 1.4 Ported to TARGON/31 M10/30
* 20-DEC-90 Release 1.5 Ported to COHERENT 3.0
* 10-JUN-92 Release 1.6 long casting problem solved with COHERENT 3.2
* and some optimization
* 25-JUN-92 Release 1.7 comments in english
* 04-OCT-06 Release 1.8 modified to compile on modern POSIX OS's
*/
#include <unistd.h>
#include <stdio.h>
#include <time.h>
#include "sim.h"
#include "simglb.h"
static int op_notimpl(void);
static int op_nop(void), op_halt(void), op_scf(void);
static int op_ccf(void), op_cpl(void), op_daa(void);
static int op_ei(void), op_di(void);
static int op_in(void), op_out(void);
static int op_ldan(void), op_ldbn(void), op_ldcn(void);
static int op_lddn(void), op_lden(void);
static int op_ldhn(void), op_ldln(void);
static int op_ldabc(void), op_ldade(void), op_ldann(void);
static int op_ldbca(void), op_lddea(void), op_ldnna(void);
static int op_ldhla(void), op_ldhlb(void), op_ldhlc(void), op_ldhld(void);
static int op_ldhle(void), op_ldhlh(void), op_ldhll(void), op_ldhl1(void);
static int op_ldaa(void), op_ldab(void), op_ldac(void);
static int op_ldad(void), op_ldae(void);
static int op_ldah(void), op_ldal(void), op_ldahl(void);
static int op_ldba(void), op_ldbb(void), op_ldbc(void);
static int op_ldbd(void), op_ldbe(void);
static int op_ldbh(void), op_ldbl(void), op_ldbhl(void);
static int op_ldca(void), op_ldcb(void), op_ldcc(void);
static int op_ldcd(void), op_ldce(void);
static int op_ldch(void), op_ldcl(void), op_ldchl(void);
static int op_ldda(void), op_lddb(void), op_lddc(void);
static int op_lddd(void), op_ldde(void);
static int op_lddh(void), op_lddl(void), op_lddhl(void);
static int op_ldea(void), op_ldeb(void), op_ldec(void);
static int op_lded(void), op_ldee(void);
static int op_ldeh(void), op_ldel(void), op_ldehl(void);
static int op_ldha(void), op_ldhb(void), op_ldhc(void);
static int op_ldhd(void), op_ldhe(void);
static int op_ldhh(void), op_ldhl(void), op_ldhhl(void);
static int op_ldla(void), op_ldlb(void), op_ldlc(void);
static int op_ldld(void), op_ldle(void);
static int op_ldlh(void), op_ldll(void), op_ldlhl(void);
static int op_ldbcnn(void), op_lddenn(void), op_ldhlnn(void);
static int op_ldspnn(void), op_ldsphl(void);
static int op_ldhlin(void), op_ldinhl(void);
static int op_incbc(void), op_incde(void), op_inchl(void), op_incsp(void);
static int op_decbc(void), op_decde(void), op_dechl(void), op_decsp(void);
static int op_adhlbc(void), op_adhlde(void), op_adhlhl(void), op_adhlsp(void);
static int op_anda(void), op_andb(void), op_andc(void), op_andd(void), op_ande(void);
static int op_andh(void), op_andl(void), op_andhl(void), op_andn(void);
static int op_ora(void), op_orb(void), op_orc(void), op_ord(void), op_ore(void);
static int op_orh(void), op_orl(void), op_orhl(void), op_orn(void);
static int op_xora(void), op_xorb(void), op_xorc(void), op_xord(void), op_xore(void);
static int op_xorh(void), op_xorl(void), op_xorhl(void), op_xorn(void);
static int op_adda(void), op_addb(void), op_addc(void), op_addd(void), op_adde(void);
static int op_addh(void), op_addl(void), op_addhl(void), op_addn(void);
static int op_adca(void), op_adcb(void), op_adcc(void), op_adcd(void), op_adce(void);
static int op_adch(void), op_adcl(void), op_adchl(void), op_adcn(void);
static int op_suba(void), op_subb(void), op_subc(void), op_subd(void), op_sube(void);
static int op_subh(void), op_subl(void), op_subhl(void), op_subn(void);
static int op_sbca(void), op_sbcb(void), op_sbcc(void), op_sbcd(void), op_sbce(void);
static int op_sbch(void), op_sbcl(void), op_sbchl(void), op_sbcn(void);
static int op_cpa(void), op_cpb(void), op_cpc(void), op_cpd(void), op_cpe(void);
static int op_cph(void), op_cplr(void), op_cphl(void), op_cpn(void);
static int op_inca(void), op_incb(void), op_incc(void), op_incd(void), op_ince(void);
static int op_inch(void), op_incl(void), op_incihl(void);
static int op_deca(void), op_decb(void), op_decc(void), op_decd(void), op_dece(void);
static int op_dech(void), op_decl(void), op_decihl(void);
static int op_rlca(void), op_rrca(void),op_rla(void),op_rra(void);
static int op_exdehl(void), op_exafaf(void), op_exx(void), op_exsphl(void);
static int op_pushaf(void), op_pushbc(void), op_pushde(void), op_pushhl(void);
static int op_popaf(void), op_popbc(void), op_popde(void), op_pophl(void);
static int op_jp(void), op_jphl(void), op_jr(void), op_djnz(void), op_call(void), op_ret(void);
static int op_jpz(void), op_jpnz(void), op_jpc(void), op_jpnc(void);
static int op_jppe(void), op_jppo(void), op_jpm(void), op_jpp(void);
static int op_calz(void), op_calnz(void), op_calc(void), op_calnc(void);
static int op_calpe(void), op_calpo(void), op_calm(void), op_calp(void);
static int op_retz(void), op_retnz(void), op_retc(void), op_retnc(void);
static int op_retpe(void), op_retpo(void), op_retm(void), op_retp(void);
static int op_jrz(void), op_jrnz(void), op_jrc(void), op_jrnc(void);
static int op_rst00(void), op_rst08(void), op_rst10(void), op_rst18(void);
static int op_rst20(void), op_rst28(void), op_rst30(void), op_rst38(void);
extern int op_cb_handel(void), op_dd_handel(void);
extern int op_ed_handel(void), op_fd_handel(void);
/*
* This function builds the Z80 central processing unit.
* The opcode where PC points to is fetched from the memory
* and PC incremented by one. The opcode is used as an
* index to an array with function pointers, to execute a
* function which emulates this Z80 opcode.
*/
void cpu(void)
{
static int (*op_sim[256]) (void) = {
op_nop, /* 0x00 */
op_ldbcnn, /* 0x01 */
op_ldbca, /* 0x02 */
op_incbc, /* 0x03 */
op_incb, /* 0x04 */
op_decb, /* 0x05 */
op_ldbn, /* 0x06 */
op_rlca, /* 0x07 */
op_exafaf, /* 0x08 */
op_adhlbc, /* 0x09 */
op_ldabc, /* 0x0a */
op_decbc, /* 0x0b */
op_incc, /* 0x0c */
op_decc, /* 0x0d */
op_ldcn, /* 0x0e */
op_rrca, /* 0x0f */
op_djnz, /* 0x10 */
op_lddenn, /* 0x11 */
op_lddea, /* 0x12 */
op_incde, /* 0x13 */
op_incd, /* 0x14 */
op_decd, /* 0x15 */
op_lddn, /* 0x16 */
op_rla, /* 0x17 */
op_jr, /* 0x18 */
op_adhlde, /* 0x19 */
op_ldade, /* 0x1a */
op_decde, /* 0x1b */
op_ince, /* 0x1c */
op_dece, /* 0x1d */
op_lden, /* 0x1e */
op_rra, /* 0x1f */
op_jrnz, /* 0x20 */
op_ldhlnn, /* 0x21 */
op_ldinhl, /* 0x22 */
op_inchl, /* 0x23 */
op_inch, /* 0x24 */
op_dech, /* 0x25 */
op_ldhn, /* 0x26 */
op_daa, /* 0x27 */
op_jrz, /* 0x28 */
op_adhlhl, /* 0x29 */
op_ldhlin, /* 0x2a */
op_dechl, /* 0x2b */
op_incl, /* 0x2c */
op_decl, /* 0x2d */
op_ldln, /* 0x2e */
op_cpl, /* 0x2f */
op_jrnc, /* 0x30 */
op_ldspnn, /* 0x31 */
op_ldnna, /* 0x32 */
op_incsp, /* 0x33 */
op_incihl, /* 0x34 */
op_decihl, /* 0x35 */
op_ldhl1, /* 0x36 */
op_scf, /* 0x37 */
op_jrc, /* 0x38 */
op_adhlsp, /* 0x39 */
op_ldann, /* 0x3a */
op_decsp, /* 0x3b */
op_inca, /* 0x3c */
op_deca, /* 0x3d */
op_ldan, /* 0x3e */
op_ccf, /* 0x3f */
op_ldbb, /* 0x40 */
op_ldbc, /* 0x41 */
op_ldbd, /* 0x42 */
op_ldbe, /* 0x43 */
op_ldbh, /* 0x44 */
op_ldbl, /* 0x45 */
op_ldbhl, /* 0x46 */
op_ldba, /* 0x47 */
op_ldcb, /* 0x48 */
op_ldcc, /* 0x49 */
op_ldcd, /* 0x4a */
op_ldce, /* 0x4b */
op_ldch, /* 0x4c */
op_ldcl, /* 0x4d */
op_ldchl, /* 0x4e */
op_ldca, /* 0x4f */
op_lddb, /* 0x50 */
op_lddc, /* 0x51 */
op_lddd, /* 0x52 */
op_ldde, /* 0x53 */
op_lddh, /* 0x54 */
op_lddl, /* 0x55 */
op_lddhl, /* 0x56 */
op_ldda, /* 0x57 */
op_ldeb, /* 0x58 */
op_ldec, /* 0x59 */
op_lded, /* 0x5a */
op_ldee, /* 0x5b */
op_ldeh, /* 0x5c */
op_ldel, /* 0x5d */
op_ldehl, /* 0x5e */
op_ldea, /* 0x5f */
op_ldhb, /* 0x60 */
op_ldhc, /* 0x61 */
op_ldhd, /* 0x62 */
op_ldhe, /* 0x63 */
op_ldhh, /* 0x64 */
op_ldhl, /* 0x65 */
op_ldhhl, /* 0x66 */
op_ldha, /* 0x67 */
op_ldlb, /* 0x68 */
op_ldlc, /* 0x69 */
op_ldld, /* 0x6a */
op_ldle, /* 0x6b */
op_ldlh, /* 0x6c */
op_ldll, /* 0x6d */
op_ldlhl, /* 0x6e */
op_ldla, /* 0x6f */
op_ldhlb, /* 0x70 */
op_ldhlc, /* 0x71 */
op_ldhld, /* 0x72 */
op_ldhle, /* 0x73 */
op_ldhlh, /* 0x74 */
op_ldhll, /* 0x75 */
op_halt, /* 0x76 */
op_ldhla, /* 0x77 */
op_ldab, /* 0x78 */
op_ldac, /* 0x79 */
op_ldad, /* 0x7a */
op_ldae, /* 0x7b */
op_ldah, /* 0x7c */
op_ldal, /* 0x7d */
op_ldahl, /* 0x7e */
op_ldaa, /* 0x7f */
op_addb, /* 0x80 */
op_addc, /* 0x81 */
op_addd, /* 0x82 */
op_adde, /* 0x83 */
op_addh, /* 0x84 */
op_addl, /* 0x85 */
op_addhl, /* 0x86 */
op_adda, /* 0x87 */
op_adcb, /* 0x88 */
op_adcc, /* 0x89 */
op_adcd, /* 0x8a */
op_adce, /* 0x8b */
op_adch, /* 0x8c */
op_adcl, /* 0x8d */
op_adchl, /* 0x8e */
op_adca, /* 0x8f */
op_subb, /* 0x90 */
op_subc, /* 0x91 */
op_subd, /* 0x92 */
op_sube, /* 0x93 */
op_subh, /* 0x94 */
op_subl, /* 0x95 */
op_subhl, /* 0x96 */
op_suba, /* 0x97 */
op_sbcb, /* 0x98 */
op_sbcc, /* 0x99 */
op_sbcd, /* 0x9a */
op_sbce, /* 0x9b */
op_sbch, /* 0x9c */
op_sbcl, /* 0x9d */
op_sbchl, /* 0x9e */
op_sbca, /* 0x9f */
op_andb, /* 0xa0 */
op_andc, /* 0xa1 */
op_andd, /* 0xa2 */
op_ande, /* 0xa3 */
op_andh, /* 0xa4 */
op_andl, /* 0xa5 */
op_andhl, /* 0xa6 */
op_anda, /* 0xa7 */
op_xorb, /* 0xa8 */
op_xorc, /* 0xa9 */
op_xord, /* 0xaa */
op_xore, /* 0xab */
op_xorh, /* 0xac */
op_xorl, /* 0xad */
op_xorhl, /* 0xae */
op_xora, /* 0xaf */
op_orb, /* 0xb0 */
op_orc, /* 0xb1 */
op_ord, /* 0xb2 */
op_ore, /* 0xb3 */
op_orh, /* 0xb4 */
op_orl, /* 0xb5 */
op_orhl, /* 0xb6 */
op_ora, /* 0xb7 */
op_cpb, /* 0xb8 */
op_cpc, /* 0xb9 */
op_cpd, /* 0xba */
op_cpe, /* 0xbb */
op_cph, /* 0xbc */
op_cplr, /* 0xbd */
op_cphl, /* 0xbe */
op_cpa, /* 0xbf */
op_retnz, /* 0xc0 */
op_popbc, /* 0xc1 */
op_jpnz, /* 0xc2 */
op_jp, /* 0xc3 */
op_calnz, /* 0xc4 */
op_pushbc, /* 0xc5 */
op_addn, /* 0xc6 */
op_rst00, /* 0xc7 */
op_retz, /* 0xc8 */
op_ret, /* 0xc9 */
op_jpz, /* 0xca */
op_cb_handel, /* 0xcb */
op_calz, /* 0xcc */
op_call, /* 0xcd */
op_adcn, /* 0xce */
op_rst08, /* 0xcf */
op_retnc, /* 0xd0 */
op_popde, /* 0xd1 */
op_jpnc, /* 0xd2 */
op_out, /* 0xd3 */
op_calnc, /* 0xd4 */
op_pushde, /* 0xd5 */
op_subn, /* 0xd6 */
op_rst10, /* 0xd7 */
op_retc, /* 0xd8 */
op_exx, /* 0xd9 */
op_jpc, /* 0xda */
op_in, /* 0xdb */
op_calc, /* 0xdc */
op_dd_handel, /* 0xdd */
op_sbcn, /* 0xde */
op_rst18, /* 0xdf */
op_retpo, /* 0xe0 */
op_pophl, /* 0xe1 */
op_jppo, /* 0xe2 */
op_exsphl, /* 0xe3 */
op_calpo, /* 0xe4 */
op_pushhl, /* 0xe5 */
op_andn, /* 0xe6 */
op_rst20, /* 0xe7 */
op_retpe, /* 0xe8 */
op_jphl, /* 0xe9 */
op_jppe, /* 0xea */
op_exdehl, /* 0xeb */
op_calpe, /* 0xec */
op_ed_handel, /* 0xed */
op_xorn, /* 0xee */
op_rst28, /* 0xef */
op_retp, /* 0xf0 */
op_popaf, /* 0xf1 */
op_jpp, /* 0xf2 */
op_di, /* 0xf3 */
op_calp, /* 0xf4 */
op_pushaf, /* 0xf5 */
op_orn, /* 0xf6 */
op_rst30, /* 0xf7 */
op_retm, /* 0xf8 */
op_ldsphl, /* 0xf9 */
op_jpm, /* 0xfa */
op_ei, /* 0xfb */
op_calm, /* 0xfc */
op_fd_handel, /* 0xfd */
op_cpn, /* 0xfe */
op_rst38 /* 0xff */
};
#ifdef WANT_TIM
register int t;
#endif
do {
#ifdef HISIZE /* write history */
his[h_next].h_adr = PC - ram;
his[h_next].h_af = (A << 8) + F;
his[h_next].h_bc = (B << 8) + C;
his[h_next].h_de = (D << 8) + E;
his[h_next].h_hl = (H << 8) + L;
his[h_next].h_ix = IX;
his[h_next].h_iy = IY;
his[h_next].h_sp = STACK - ram;
h_next++;
if (h_next == HISIZE) {
h_flag = 1;
h_next = 0;
}
#endif
#ifdef WANT_TIM /* check for start address of runtime measurement */
if (PC == t_start && !t_flag) {
t_flag = 1; /* switch measurement on */
t_states = 0L; /* initialize counted T-states */
}
#endif
#ifdef WANT_INT /* CPU interrupt handling */
if (int_type)
switch (int_type) {
case INT_NMI: /* non maskable interrupt */
int_type = INT_NONE;
IFF <<= 1;
#ifdef WANT_SPC
if (STACK <= ram)
STACK = ram + 65536L;
#endif
*--STACK = (PC - ram) >> 8;
#ifdef WANT_SPC
if (STACK <= ram)
STACK = ram + 65536L;
#endif
*--STACK = (PC - ram);
PC = ram + 0x66;
break;
case INT_INT: /* maskable interrupt */
if (IFF != 3)
break;
IFF = 0;
switch (int_mode) {
case 0:
break;
case 1:
int_type = INT_NONE;
#ifdef WANT_SPC
if (STACK <= ram)
STACK = ram + 65536L;
#endif
*--STACK = (PC - ram) >> 8;
#ifdef WANT_SPC
if (STACK <= ram)
STACK = ram + 65536L;
#endif
*--STACK = (PC - ram);
PC = ram + 0x38;
break;
case 2:
break;
}
break;
}
#endif
#ifdef WANT_TIM
t = (*op_sim[*PC++]) ();/* execute next opcode */
if (f_flag) { /* adjust CPU speed */
}
#else
(*op_sim[*PC++]) ();
#endif
#ifdef WANT_PCC
if (PC > ram + 65535) /* check for PC overrun */
PC = ram;
#endif
R++; /* increment refresh register */
#ifdef WANT_TIM /* do runtime measurement */
if (t_flag) {
t_states += t; /* add T-states for this opcode */
if (PC == t_end) /* check for end address */
t_flag = 0; /* if reached, switch off */
}
#endif
} while (cpu_state);
}
/*
* Trap not implemented opcodes. This function may be usefull
* later to trap some wanted opcodes.
*/
static int op_notimpl(void)
{
cpu_error = OPTRAP1;
cpu_state = STOPPED;
return(0);
}
static int op_nop(void) /* NOP */
{
return(4);
}
static int op_halt(void) /* HALT */
{
struct timespec timer;
if (break_flag) {
cpu_error = OPHALT;
cpu_state = STOPPED;
} else
while (int_type == 0) {
timer.tv_sec = 0;
timer.tv_nsec = 10000000;
nanosleep(&timer, NULL);
R += 99999;
}
return(0);
}
static int op_scf(void) /* SCF */
{
F |= C_FLAG;
F &= ~(N_FLAG | H_FLAG);
return(4);
}
static int op_ccf(void) /* CCF */
{
if (F & C_FLAG) {
F |= H_FLAG;
F &= ~C_FLAG;
} else {
F &= ~H_FLAG;
F |= C_FLAG;
}
F &= ~N_FLAG;
return(4);
}
static int op_cpl(void) /* CPL */
{
A = ~A;
F |= H_FLAG | N_FLAG;
return(4);
}
static int op_daa(void) /* DAA */
{
register int old_a;
old_a = A;
if (F & N_FLAG) { /* subtractions */
if (((A & 0x0f) > 9) || (F & H_FLAG)) {
(((old_a & 0x0f) - 6) < 0) ? (F |= H_FLAG) : (F &= ~H_FLAG);
A = old_a -= 6;
}
if (((A & 0xf0) > 0x90) || (F & C_FLAG)) {
A -= 0x60;
if (old_a - 0x60 < 0)
F |= C_FLAG;
}
} else { /* additions */
if (((A & 0x0f) > 9) || (F & H_FLAG)) {
(((old_a & 0x0f) + 6) > 0x0f) ? (F |= H_FLAG) : (F &= ~H_FLAG);
A = old_a += 6;
}
if (((A & 0xf0) > 0x90) || (F & C_FLAG)) {
A += 0x60;
if (old_a + 0x60 > 255)
F |= C_FLAG;
}
}
(A) ? (F &= ~Z_FLAG) : (F |= Z_FLAG);
(A & 128) ? (F |= S_FLAG) : (F &= ~S_FLAG);
(parrity[A]) ? (F &= ~P_FLAG) : (F |= P_FLAG);
return(4);
}
static int op_ei(void) /* EI */
{
IFF = 3;
return(4);
}
static int op_di(void) /* DI */
{
IFF = 0;
return(4);
}
static int op_in(void) /* IN A,(n) */
{
BYTE io_in();
A = io_in(*PC++);
return(11);
}
static int op_out(void) /* OUT (n),A */
{
BYTE io_out();
io_out(*PC++, A);
return(11);
}
static int op_ldan(void) /* LD A,n */
{
A = *PC++;
return(7);
}
static int op_ldbn(void) /* LD B,n */
{
B = *PC++;
return(7);
}
static int op_ldcn(void) /* LD C,n */
{
C = *PC++;
return(7);
}
static int op_lddn(void) /* LD D,n */
{
D = *PC++;
return(7);
}
static int op_lden(void) /* LD E,n */
{
E = *PC++;
return(7);
}
static int op_ldhn(void) /* LD H,n */
{
H = *PC++;
return(7);
}
static int op_ldln(void) /* LD L,n */
{
L = *PC++;
return(7);
}
static int op_ldabc(void) /* LD A,(BC) */
{
A = *(ram + (B << 8) + C);
return(7);
}
static int op_ldade(void) /* LD A,(DE) */
{
A = *(ram + (D << 8) + E);
return(7);
}
static int op_ldann(void) /* LD A,(nn) */
{
register unsigned i;
i = *PC++;
i += *PC++ << 8;
A = *(ram + i);
return(13);
}
static int op_ldbca(void) /* LD (BC),A */
{
*(ram + (B << 8) + C) = A;
return(7);
}
static int op_lddea(void) /* LD (DE),A */
{
*(ram + (D << 8) + E) = A;
return(7);
}
static int op_ldnna(void) /* LD (nn),A */
{
register unsigned i;
i = *PC++;
i += *PC++ << 8;
*(ram + i) = A;
return(13);
}
static int op_ldhla(void) /* LD (HL),A */
{
*(ram + (H << 8) + L) = A;
return(7);
}
static int op_ldhlb(void) /* LD (HL),B */
{
*(ram + (H << 8) + L) = B;
return(7);
}
static int op_ldhlc(void) /* LD (HL),C */
{
*(ram + (H << 8) + L) = C;
return(7);
}
static int op_ldhld(void) /* LD (HL),D */
{
*(ram + (H << 8) + L) = D;
return(7);
}
static int op_ldhle(void) /* LD (HL),E */
{
*(ram + (H << 8) + L) = E;
return(7);
}
static int op_ldhlh(void) /* LD (HL),H */
{
*(ram + (H << 8) + L) = H;
return(7);
}
static int op_ldhll(void) /* LD (HL),L */
{
*(ram + (H << 8) + L) = L;
return(7);
}
static int op_ldhl1(void) /* LD (HL),n */
{
*(ram + (H << 8) + L) = *PC++;
return(10);
}
static int op_ldaa(void) /* LD A,A */
{
return(4);
}
static int op_ldab(void) /* LD A,B */
{
A = B;
return(4);
}
static int op_ldac(void) /* LD A,C */
{
A = C;
return(4);
}
static int op_ldad(void) /* LD A,D */
{
A = D;
return(4);
}
static int op_ldae(void) /* LD A,E */
{
A = E;
return(4);
}
static int op_ldah(void) /* LD A,H */
{
A = H;
return(4);
}
static int op_ldal(void) /* LD A,L */
{
A = L;
return(4);
}
static int op_ldahl(void) /* LD A,(HL) */
{
A = *(ram + (H << 8) + L);
return(7);
}
static int op_ldba(void) /* LD B,A */
{
B = A;
return(4);
}
static int op_ldbb(void) /* LD B,B */
{
return(4);
}
static int op_ldbc(void) /* LD B,C */
{
B = C;
return(4);
}
static int op_ldbd(void) /* LD B,D */
{
B = D;
return(4);
}
static int op_ldbe(void) /* LD B,E */
{
B = E;
return(4);
}
static int op_ldbh(void) /* LD B,H */
{
B = H;
return(4);
}
static int op_ldbl(void) /* LD B,L */
{
B = L;
return(4);
}
static int op_ldbhl(void) /* LD B,(HL) */
{
B = *(ram + (H << 8) + L);
return(7);
}
static int op_ldca(void) /* LD C,A */
{
C = A;
return(4);
}
static int op_ldcb(void) /* LD C,B */
{
C = B;
return(4);
}
static int op_ldcc(void) /* LD C,C */
{
return(4);
}
static int op_ldcd(void) /* LD C,D */
{
C = D;
return(4);
}
static int op_ldce(void) /* LD C,E */
{
C = E;
return(4);
}
static int op_ldch(void) /* LD C,H */
{
C = H;
return(4);
}
static int op_ldcl(void) /* LD C,L */
{
C = L;
return(4);
}
static int op_ldchl(void) /* LD C,(HL) */
{
C = *(ram + (H << 8) + L);
return(7);
}
static int op_ldda(void) /* LD D,A */
{
D = A;
return(4);
}
static int op_lddb(void) /* LD D,B */
{
D = B;
return(4);
}
static int op_lddc(void) /* LD D,C */
{
D = C;
return(4);
}
static int op_lddd(void) /* LD D,D */
{
return(4);
}
static int op_ldde(void) /* LD D,E */
{
D = E;
return(4);
}
static int op_lddh(void) /* LD D,H */
{
D = H;
return(4);
}
static int op_lddl(void) /* LD D,L */
{
D = L;
return(4);
}
static int op_lddhl(void) /* LD D,(HL) */
{
D = *(ram + (H << 8) + L);
return(7);
}
static int op_ldea(void) /* LD E,A */
{
E = A;
return(4);
}
static int op_ldeb(void) /* LD E,B */
{
E = B;
return(4);
}
static int op_ldec(void) /* LD E,C */
{
E = C;
return(4);
}
static int op_lded(void) /* LD E,D */
{
E = D;
return(4);
}
static int op_ldee(void) /* LD E,E */
{
return(4);
}
static int op_ldeh(void) /* LD E,H */
{
E = H;
return(4);
}
static int op_ldel(void) /* LD E,L */
{
E = L;
return(4);
}
static int op_ldehl(void) /* LD E,(HL) */
{
E = *(ram + (H << 8) + L);
return(7);
}
static int op_ldha(void) /* LD H,A */
{
H = A;
return(4);
}
static int op_ldhb(void) /* LD H,B */
{
H = B;
return(4);
}
static int op_ldhc(void) /* LD H,C */
{
H = C;
return(4);
}
static int op_ldhd(void) /* LD H,D */
{
H = D;
return(4);
}
static int op_ldhe(void) /* LD H,E */
{
H = E;
return(4);
}
static int op_ldhh(void) /* LD H,H */
{
return(4);
}
static int op_ldhl(void) /* LD H,L */
{
H = L;
return(4);
}
static int op_ldhhl(void) /* LD H,(HL) */
{
H = *(ram + (H << 8) + L);
return(7);
}
static int op_ldla(void) /* LD L,A */
{
L = A;
return(4);
}
static int op_ldlb(void) /* LD L,B */
{
L = B;
return(4);
}
static int op_ldlc(void) /* LD L,C */
{
L = C;
return(4);
}
static int op_ldld(void) /* LD L,D */
{
L = D;
return(4);
}
static int op_ldle(void) /* LD L,E */
{
L = E;
return(4);
}
static int op_ldlh(void) /* LD L,H */
{
L = H;
return(4);
}
static int op_ldll(void) /* LD L,L */
{
return(4);
}
static int op_ldlhl(void) /* LD L,(HL) */
{
L = *(ram + (H << 8) + L);
return(7);
}
static int op_ldbcnn(void) /* LD BC,nn */
{
C = *PC++;
B = *PC++;
return(10);
}
static int op_lddenn(void) /* LD DE,nn */
{
E = *PC++;
D = *PC++;
return(10);
}
static int op_ldhlnn(void) /* LD HL,nn */
{
L = *PC++;
H = *PC++;
return(10);
}
static int op_ldspnn(void) /* LD SP,nn */
{
STACK = ram + *PC++;
STACK += *PC++ << 8;
return(10);
}
static int op_ldsphl(void) /* LD SP,HL */
{
STACK = ram + (H << 8) + L;
return(6);
}
static int op_ldhlin(void) /* LD HL,(nn) */
{
register unsigned i;
i = *PC++;
i += *PC++ << 8;
L = *(ram + i);
H = *(ram + i + 1);
return(16);
}
static int op_ldinhl(void) /* LD (nn),HL */
{
register unsigned i;
i = *PC++;
i += *PC++ << 8;
*(ram + i) = L;
*(ram + i + 1) = H;
return(16);
}
static int op_incbc(void) /* INC BC */
{
C++;
if (!C)
B++;
return(6);
}
static int op_incde(void) /* INC DE */
{
E++;
if (!E)
D++;
return(6);
}
static int op_inchl(void) /* INC HL */
{
L++;
if (!L)
H++;
return(6);
}
static int op_incsp(void) /* INC SP */
{
STACK++;
#ifdef WANT_SPC
if (STACK > ram + 65535)
STACK = ram;
#endif
return(6);
}
static int op_decbc(void) /* DEC BC */
{
C--;
if (C == 0xff)
B--;
return(6);
}
static int op_decde(void) /* DEC DE */
{
E--;
if (E == 0xff)
D--;
return(6);
}
static int op_dechl(void) /* DEC HL */
{
L--;
if (L == 0xff)
H--;
return(6);
}
static int op_decsp(void) /* DEC SP */
{
STACK--;
#ifdef WANT_SPC
if (STACK < ram)
STACK = ram + 65535;
#endif
return(6);
}
static int op_adhlbc(void) /* ADD HL,BC */
{
register int carry;
carry = (L + C > 255) ? 1 : 0;
L += C;
((H & 0xf) + (B & 0xf) + carry > 0xf) ? (F |= H_FLAG) : (F &= ~H_FLAG);
(H + B + carry > 255) ? (F |= C_FLAG) : (F &= ~C_FLAG);
H += B + carry;
F &= ~N_FLAG;
return(11);
}
static int op_adhlde(void) /* ADD HL,DE */
{
register int carry;
carry = (L + E > 255) ? 1 : 0;
L += E;
((H & 0xf) + (D & 0xf) + carry > 0xf) ? (F |= H_FLAG) : (F &= ~H_FLAG);
(H + D + carry > 255) ? (F |= C_FLAG) : (F &= ~C_FLAG);
H += D + carry;
F &= ~N_FLAG;
return(11);
}
static int op_adhlhl(void) /* ADD HL,HL */
{
register int carry;
carry = (L << 1 > 255) ? 1 : 0;
L <<= 1;
((H & 0xf) + (H & 0xf) + carry > 0xf) ? (F |= H_FLAG) : (F &= ~H_FLAG);
(H + H + carry > 255) ? (F |= C_FLAG) : (F &= ~C_FLAG);
H += H + carry;
F &= ~N_FLAG;
return(11);
}
static int op_adhlsp(void) /* ADD HL,SP */
{
register int carry;
BYTE spl = (STACK - ram) & 0xff;
BYTE sph = (STACK - ram) >> 8;
carry = (L + spl > 255) ? 1 : 0;
L += spl;
((H & 0xf) + (sph & 0xf) + carry > 0xf) ? (F |= H_FLAG)
: (F &= ~H_FLAG);
(H + sph + carry > 255) ? (F |= C_FLAG) : (F &= ~C_FLAG);
H += sph + carry;
F &= ~N_FLAG;
return(11);
}
static int op_anda(void) /* AND A */
{
(A & 128) ? (F |= S_FLAG) : (F &= ~S_FLAG);
(A) ? (F &= ~Z_FLAG) : (F |= Z_FLAG);
F |= H_FLAG;
(parrity[A]) ? (F &= ~P_FLAG) : (F |= P_FLAG);
F &= ~(N_FLAG | C_FLAG);
return(4);
}
static int op_andb(void) /* AND B */
{
A &= B;
(A & 128) ? (F |= S_FLAG) : (F &= ~S_FLAG);
(A) ? (F &= ~Z_FLAG) : (F |= Z_FLAG);
F |= H_FLAG;
(parrity[A]) ? (F &= ~P_FLAG) : (F |= P_FLAG);
F &= ~(N_FLAG | C_FLAG);
return(4);
}
static int op_andc(void) /* AND C */
{
A &= C;
(A & 128) ? (F |= S_FLAG) : (F &= ~S_FLAG);
(A) ? (F &= ~Z_FLAG) : (F |= Z_FLAG);
F |= H_FLAG;
(parrity[A]) ? (F &= ~P_FLAG) : (F |= P_FLAG);
F &= ~(N_FLAG | C_FLAG);
return(4);
}
static int op_andd(void) /* AND D */
{
A &= D;
(A & 128) ? (F |= S_FLAG) : (F &= ~S_FLAG);
(A) ? (F &= ~Z_FLAG) : (F |= Z_FLAG);
F |= H_FLAG;
(parrity[A]) ? (F &= ~P_FLAG) : (F |= P_FLAG);
F &= ~(N_FLAG | C_FLAG);
return(4);
}
static int op_ande(void) /* AND E */
{
A &= E;
(A & 128) ? (F |= S_FLAG) : (F &= ~S_FLAG);
(A) ? (F &= ~Z_FLAG) : (F |= Z_FLAG);
F |= H_FLAG;
(parrity[A]) ? (F &= ~P_FLAG) : (F |= P_FLAG);
F &= ~(N_FLAG | C_FLAG);
return(4);
}
static int op_andh(void) /* AND H */
{
A &= H;
(A & 128) ? (F |= S_FLAG) : (F &= ~S_FLAG);
(A) ? (F &= ~Z_FLAG) : (F |= Z_FLAG);
F |= H_FLAG;
(parrity[A]) ? (F &= ~P_FLAG) : (F |= P_FLAG);
F &= ~(N_FLAG | C_FLAG);
return(4);
}
static int op_andl(void) /* AND L */
{
A &= L;
(A & 128) ? (F |= S_FLAG) : (F &= ~S_FLAG);
(A) ? (F &= ~Z_FLAG) : (F |= Z_FLAG);
F |= H_FLAG;
(parrity[A]) ? (F &= ~P_FLAG) : (F |= P_FLAG);
F &= ~(N_FLAG | C_FLAG);
return(4);
}
static int op_andhl(void) /* AND (HL) */
{
A &= *(ram + (H << 8) + L);
(A & 128) ? (F |= S_FLAG) : (F &= ~S_FLAG);
(A) ? (F &= ~Z_FLAG) : (F |= Z_FLAG);
F |= H_FLAG;
(parrity[A]) ? (F &= ~P_FLAG) : (F |= P_FLAG);
F &= ~(N_FLAG | C_FLAG);
return(7);
}
static int op_andn(void) /* AND n */
{
A &= *PC++;
(A & 128) ? (F |= S_FLAG) : (F &= ~S_FLAG);
(A) ? (F &= ~Z_FLAG) : (F |= Z_FLAG);
F |= H_FLAG;
(parrity[A]) ? (F &= ~P_FLAG) : (F |= P_FLAG);
F &= ~(N_FLAG | C_FLAG);
return(7);
}
static int op_ora(void) /* OR A */
{
(A & 128) ? (F |= S_FLAG) : (F &= ~S_FLAG);
(A) ? (F &= ~Z_FLAG) : (F |= Z_FLAG);
(parrity[A]) ? (F &= ~P_FLAG) : (F |= P_FLAG);
F &= ~(H_FLAG | N_FLAG | C_FLAG);
return(4);
}
static int op_orb(void) /* OR B */
{
A |= B;
(A & 128) ? (F |= S_FLAG) : (F &= ~S_FLAG);
(A) ? (F &= ~Z_FLAG) : (F |= Z_FLAG);
(parrity[A]) ? (F &= ~P_FLAG) : (F |= P_FLAG);
F &= ~(H_FLAG | N_FLAG | C_FLAG);
return(4);
}
static int op_orc(void) /* OR C */
{
A |= C;
(A & 128) ? (F |= S_FLAG) : (F &= ~S_FLAG);
(A) ? (F &= ~Z_FLAG) : (F |= Z_FLAG);
(parrity[A]) ? (F &= ~P_FLAG) : (F |= P_FLAG);
F &= ~(H_FLAG | N_FLAG | C_FLAG);
return(4);
}
static int op_ord(void) /* OR D */
{
A |= D;
(A & 128) ? (F |= S_FLAG) : (F &= ~S_FLAG);
(A) ? (F &= ~Z_FLAG) : (F |= Z_FLAG);
(parrity[A]) ? (F &= ~P_FLAG) : (F |= P_FLAG);
F &= ~(H_FLAG | N_FLAG | C_FLAG);
return(4);
}
static int op_ore(void) /* OR E */
{
A |= E;
(A & 128) ? (F |= S_FLAG) : (F &= ~S_FLAG);
(A) ? (F &= ~Z_FLAG) : (F |= Z_FLAG);
(parrity[A]) ? (F &= ~P_FLAG) : (F |= P_FLAG);
F &= ~(H_FLAG | N_FLAG | C_FLAG);
return(4);
}
static int op_orh(void) /* OR H */
{
A |= H;
(A & 128) ? (F |= S_FLAG) : (F &= ~S_FLAG);
(A) ? (F &= ~Z_FLAG) : (F |= Z_FLAG);
(parrity[A]) ? (F &= ~P_FLAG) : (F |= P_FLAG);
F &= ~(H_FLAG | N_FLAG | C_FLAG);
return(4);
}
static int op_orl(void) /* OR L */
{
A |= L;
(A & 128) ? (F |= S_FLAG) : (F &= ~S_FLAG);
(A) ? (F &= ~Z_FLAG) : (F |= Z_FLAG);
(parrity[A]) ? (F &= ~P_FLAG) : (F |= P_FLAG);
F &= ~(H_FLAG | N_FLAG | C_FLAG);
return(4);
}
static int op_orhl(void) /* OR (HL) */
{
A |= *(ram + (H << 8) + L);
(A & 128) ? (F |= S_FLAG) : (F &= ~S_FLAG);
(A) ? (F &= ~Z_FLAG) : (F |= Z_FLAG);
(parrity[A]) ? (F &= ~P_FLAG) : (F |= P_FLAG);
F &= ~(H_FLAG | N_FLAG | C_FLAG);
return(7);
}
static int op_orn(void) /* OR n */
{
A |= *PC++;
(A & 128) ? (F |= S_FLAG) : (F &= ~S_FLAG);
(A) ? (F &= ~Z_FLAG) : (F |= Z_FLAG);
(parrity[A]) ? (F &= ~P_FLAG) : (F |= P_FLAG);
F &= ~(H_FLAG | N_FLAG | C_FLAG);
return(7);
}
static int op_xora(void) /* XOR A */
{
A = 0;
F &= ~(S_FLAG | H_FLAG | N_FLAG | C_FLAG);
F |= Z_FLAG | P_FLAG;
return(4);
}
static int op_xorb(void) /* XOR B */
{
A ^= B;
(A & 128) ? (F |= S_FLAG) : (F &= ~S_FLAG);
(A) ? (F &= ~Z_FLAG) : (F |= Z_FLAG);
(parrity[A]) ? (F &= ~P_FLAG) : (F |= P_FLAG);
F &= ~(H_FLAG | N_FLAG | C_FLAG);
return(4);
}
static int op_xorc(void) /* XOR C */
{
A ^= C;
(A & 128) ? (F |= S_FLAG) : (F &= ~S_FLAG);
(A) ? (F &= ~Z_FLAG) : (F |= Z_FLAG);
(parrity[A]) ? (F &= ~P_FLAG) : (F |= P_FLAG);
F &= ~(H_FLAG | N_FLAG | C_FLAG);
return(4);
}
static int op_xord(void) /* XOR D */
{
A ^= D;
(A & 128) ? (F |= S_FLAG) : (F &= ~S_FLAG);
(A) ? (F &= ~Z_FLAG) : (F |= Z_FLAG);
(parrity[A]) ? (F &= ~P_FLAG) : (F |= P_FLAG);
F &= ~(H_FLAG | N_FLAG | C_FLAG);
return(4);
}
static int op_xore(void) /* XOR E */
{
A ^= E;
(A & 128) ? (F |= S_FLAG) : (F &= ~S_FLAG);
(A) ? (F &= ~Z_FLAG) : (F |= Z_FLAG);
(parrity[A]) ? (F &= ~P_FLAG) : (F |= P_FLAG);
F &= ~(H_FLAG | N_FLAG | C_FLAG);
return(4);
}
static int op_xorh(void) /* XOR H */
{
A ^= H;
(A & 128) ? (F |= S_FLAG) : (F &= ~S_FLAG);
(A) ? (F &= ~Z_FLAG) : (F |= Z_FLAG);
(parrity[A]) ? (F &= ~P_FLAG) : (F |= P_FLAG);
F &= ~(H_FLAG | N_FLAG | C_FLAG);
return(4);
}
static int op_xorl(void) /* XOR L */
{
A ^= L;
(A & 128) ? (F |= S_FLAG) : (F &= ~S_FLAG);
(A) ? (F &= ~Z_FLAG) : (F |= Z_FLAG);
(parrity[A]) ? (F &= ~P_FLAG) : (F |= P_FLAG);
F &= ~(H_FLAG | N_FLAG | C_FLAG);
return(4);
}
static int op_xorhl(void) /* XOR (HL) */
{
A ^= *(ram + (H << 8) + L);
(A & 128) ? (F |= S_FLAG) : (F &= ~S_FLAG);
(A) ? (F &= ~Z_FLAG) : (F |= Z_FLAG);
(parrity[A]) ? (F &= ~P_FLAG) : (F |= P_FLAG);
F &= ~(H_FLAG | N_FLAG | C_FLAG);
return(7);
}
static int op_xorn(void) /* XOR n */
{
A ^= *PC++;
(A & 128) ? (F |= S_FLAG) : (F &= ~S_FLAG);
(A) ? (F &= ~Z_FLAG) : (F |= Z_FLAG);
(parrity[A]) ? (F &= ~P_FLAG) : (F |= P_FLAG);
F &= ~(H_FLAG | N_FLAG | C_FLAG);
return(7);
}
static int op_adda(void) /* ADD A,A */
{
register int i;
((A & 0xf) + (A & 0xf) > 0xf) ? (F |= H_FLAG) : (F &= ~H_FLAG);
((A << 1) > 255) ? (F |= C_FLAG) : (F &= ~C_FLAG);
A = i = ((char) A) << 1;
(i < -128 || i > 127) ? (F |= P_FLAG) : (F &= ~P_FLAG);
(i & 128) ? (F |= S_FLAG) : (F &= ~S_FLAG);
(A) ? (F &= ~Z_FLAG) : (F |= Z_FLAG);
F &= ~N_FLAG;
return(4);
}
static int op_addb(void) /* ADD A,B */
{
register int i;
((A & 0xf) + (B & 0xf) > 0xf) ? (F |= H_FLAG) : (F &= ~H_FLAG);
(A + B > 255) ? (F |= C_FLAG) : (F &= ~C_FLAG);
A = i = (char) A + (char) B;
(i < -128 || i > 127) ? (F |= P_FLAG) : (F &= ~P_FLAG);
(i & 128) ? (F |= S_FLAG) : (F &= ~S_FLAG);
(A) ? (F &= ~Z_FLAG) : (F |= Z_FLAG);
F &= ~N_FLAG;
return(4);
}
static int op_addc(void) /* ADD A,C */
{
register int i;
((A & 0xf) + (C & 0xf) > 0xf) ? (F |= H_FLAG) : (F &= ~H_FLAG);
(A + C > 255) ? (F |= C_FLAG) : (F &= ~C_FLAG);
A = i = (char) A + (char) C;
(i < -128 || i > 127) ? (F |= P_FLAG) : (F &= ~P_FLAG);
(i & 128) ? (F |= S_FLAG) : (F &= ~S_FLAG);
(A) ? (F &= ~Z_FLAG) : (F |= Z_FLAG);
F &= ~N_FLAG;
return(4);
}
static int op_addd(void) /* ADD A,Dn*/
{
register int i;
((A & 0xf) + (D & 0xf) > 0xf) ? (F |= H_FLAG) : (F &= ~H_FLAG);
(A + D > 255) ? (F |= C_FLAG) : (F &= ~C_FLAG);
A = i = (char) A + (char) D;
(i < -128 || i > 127) ? (F |= P_FLAG) : (F &= ~P_FLAG);
(i & 128) ? (F |= S_FLAG) : (F &= ~S_FLAG);
(A) ? (F &= ~Z_FLAG) : (F |= Z_FLAG);
F &= ~N_FLAG;
return(4);
}
static int op_adde(void) /* ADD A,E */
{
register int i;
((A & 0xf) + (E & 0xf) > 0xf) ? (F |= H_FLAG) : (F &= ~H_FLAG);
(A + E > 255) ? (F |= C_FLAG) : (F &= ~C_FLAG);
A = i = (char) A + (char) E;
(i < -128 || i > 127) ? (F |= P_FLAG) : (F &= ~P_FLAG);
(i & 128) ? (F |= S_FLAG) : (F &= ~S_FLAG);
(A) ? (F &= ~Z_FLAG) : (F |= Z_FLAG);
F &= ~N_FLAG;
return(4);
}
static int op_addh(void) /* ADD A,H */
{
register int i;
((A & 0xf) + (H & 0xf) > 0xf) ? (F |= H_FLAG) : (F &= ~H_FLAG);
(A + H > 255) ? (F |= C_FLAG) : (F &= ~C_FLAG);
A = i = (char) A + (char) H;
(i < -128 || i > 127) ? (F |= P_FLAG) : (F &= ~P_FLAG);
(i & 128) ? (F |= S_FLAG) : (F &= ~S_FLAG);
(A) ? (F &= ~Z_FLAG) : (F |= Z_FLAG);
F &= ~N_FLAG;
return(4);
}
static int op_addl(void) /* ADD A,L */
{
register int i;
((A & 0xf) + (L & 0xf) > 0xf) ? (F |= H_FLAG) : (F &= ~H_FLAG);
(A + L > 255) ? (F |= C_FLAG) : (F &= ~C_FLAG);
A = i = (char) A + (char) L;
(i < -128 || i > 127) ? (F |= P_FLAG) : (F &= ~P_FLAG);
(i & 128) ? (F |= S_FLAG) : (F &= ~S_FLAG);
(A) ? (F &= ~Z_FLAG) : (F |= Z_FLAG);
F &= ~N_FLAG;
return(4);
}
static int op_addhl(void) /* ADD A,(HL) */
{
register int i;
register BYTE P;
P = *(ram + (H << 8) + L);
((A & 0xf) + (P & 0xf) > 0xf) ? (F |= H_FLAG) : (F &= ~H_FLAG);
(A + P > 255) ? (F |= C_FLAG) : (F &= ~C_FLAG);
A = i = (char) A + (char) P;
(i < -128 || i > 127) ? (F |= P_FLAG) : (F &= ~P_FLAG);
(i & 128) ? (F |= S_FLAG) : (F &= ~S_FLAG);
(A) ? (F &= ~Z_FLAG) : (F |= Z_FLAG);
F &= ~N_FLAG;
return(7);
}
static int op_addn(void) /* ADD A,n */
{
register int i;
register BYTE P;
P = *PC++;
((A & 0xf) + (P & 0xf) > 0xf) ? (F |= H_FLAG) : (F &= ~H_FLAG);
(A + P > 255) ? (F |= C_FLAG) : (F &= ~C_FLAG);
A = i = (char) A + (char) P;
(i < -128 || i > 127) ? (F |= P_FLAG) : (F &= ~P_FLAG);
(i & 128) ? (F |= S_FLAG) : (F &= ~S_FLAG);
(A) ? (F &= ~Z_FLAG) : (F |= Z_FLAG);
F &= ~N_FLAG;
return(7);
}
static int op_adca(void) /* ADC A,A */
{
register int i, carry;
carry = (F & C_FLAG) ? 1 : 0;
((A & 0xf) + (A & 0xf) + carry > 0xf) ? (F |= H_FLAG) : (F &= ~H_FLAG);
((A << 1) + carry > 255) ? (F |= C_FLAG) : (F &= ~C_FLAG);
A = i = (((char) A) << 1) + carry;
(i < -128 || i > 127) ? (F |= P_FLAG) : (F &= ~P_FLAG);
(i & 128) ? (F |= S_FLAG) : (F &= ~S_FLAG);
(A) ? (F &= ~Z_FLAG) : (F |= Z_FLAG);
F &= ~N_FLAG;
return(4);
}
static int op_adcb(void) /* ADC A,B */
{
register int i, carry;
carry = (F & C_FLAG) ? 1 : 0;
((A & 0xf) + (B & 0xf) + carry > 0xf) ? (F |= H_FLAG) : (F &= ~H_FLAG);
(A + B + carry > 255) ? (F |= C_FLAG) : (F &= ~C_FLAG);
A = i = (char) A + (char) B + carry;
(i < -128 || i > 127) ? (F |= P_FLAG) : (F &= ~P_FLAG);
(i & 128) ? (F |= S_FLAG) : (F &= ~S_FLAG);
(A) ? (F &= ~Z_FLAG) : (F |= Z_FLAG);
F &= ~N_FLAG;
return(4);
}
static int op_adcc(void) /* ADC A,C */
{
register int i, carry;
carry = (F & C_FLAG) ? 1 : 0;
((A & 0xf) + (C & 0xf) + carry > 0xf) ? (F |= H_FLAG) : (F &= ~H_FLAG);
(A + C + carry > 255) ? (F |= C_FLAG) : (F &= ~C_FLAG);
A = i = (char) A + (char) C + carry;
(i < -128 || i > 127) ? (F |= P_FLAG) : (F &= ~P_FLAG);
(i & 128) ? (F |= S_FLAG) : (F &= ~S_FLAG);
(A) ? (F &= ~Z_FLAG) : (F |= Z_FLAG);
F &= ~N_FLAG;
return(4);
}
static int op_adcd(void) /* ADC A,D */
{
register int i, carry;
carry = (F & C_FLAG) ? 1 : 0;
((A & 0xf) + (D & 0xf) + carry > 0xf) ? (F |= H_FLAG) : (F &= ~H_FLAG);
(A + D + carry > 255) ? (F |= C_FLAG) : (F &= ~C_FLAG);
A = i = (char) A + (char) D + carry;
(i < -128 || i > 127) ? (F |= P_FLAG) : (F &= ~P_FLAG);
(i & 128) ? (F |= S_FLAG) : (F &= ~S_FLAG);
(A) ? (F &= ~Z_FLAG) : (F |= Z_FLAG);
F &= ~N_FLAG;
return(4);
}
static int op_adce(void) /* ADC A,E */
{
register int i, carry;
carry = (F & C_FLAG) ? 1 : 0;
((A & 0xf) + (E & 0xf) + carry > 0xf) ? (F |= H_FLAG) : (F &= ~H_FLAG);
(A + E + carry > 255) ? (F |= C_FLAG) : (F &= ~C_FLAG);
A = i = (char) A + (char) E + carry;
(i < -128 || i > 127) ? (F |= P_FLAG) : (F &= ~P_FLAG);
(i & 128) ? (F |= S_FLAG) : (F &= ~S_FLAG);
(A) ? (F &= ~Z_FLAG) : (F |= Z_FLAG);
F &= ~N_FLAG;
return(4);
}
static int op_adch(void) /* ADC A,H */
{
register int i, carry;
carry = (F & C_FLAG) ? 1 : 0;
((A & 0xf) + (H & 0xf) + carry > 0xf) ? (F |= H_FLAG) : (F &= ~H_FLAG);
(A + H + carry > 255) ? (F |= C_FLAG) : (F &= ~C_FLAG);
A = i = (char) A + (char) H + carry;
(i < -128 || i > 127) ? (F |= P_FLAG) : (F &= ~P_FLAG);
(i & 128) ? (F |= S_FLAG) : (F &= ~S_FLAG);
(A) ? (F &= ~Z_FLAG) : (F |= Z_FLAG);
F &= ~N_FLAG;
return(4);
}
static int op_adcl(void) /* ADC A,L */
{
register int i, carry;
carry = (F & C_FLAG) ? 1 : 0;
((A & 0xf) + (L & 0xf) + carry > 0xf) ? (F |= H_FLAG) : (F &= ~H_FLAG);
(A + L + carry > 255) ? (F |= C_FLAG) : (F &= ~C_FLAG);
A = i = (char) A + (char) L + carry;
(i < -128 || i > 127) ? (F |= P_FLAG) : (F &= ~P_FLAG);
(i & 128) ? (F |= S_FLAG) : (F &= ~S_FLAG);
(A) ? (F &= ~Z_FLAG) : (F |= Z_FLAG);
F &= ~N_FLAG;
return(4);
}
static int op_adchl(void) /* ADC A,(HL) */
{
register int i, carry;
register BYTE P;
P = *(ram + (H << 8) + L);
carry = (F & C_FLAG) ? 1 : 0;
((A & 0xf) + (P & 0xf) + carry > 0xf) ? (F |= H_FLAG) : (F &= ~H_FLAG);
(A + P + carry > 255) ? (F |= C_FLAG) : (F &= ~C_FLAG);
A = i = (char) A + (char) P + carry;
(i < -128 || i > 127) ? (F |= P_FLAG) : (F &= ~P_FLAG);
(i & 128) ? (F |= S_FLAG) : (F &= ~S_FLAG);
(A) ? (F &= ~Z_FLAG) : (F |= Z_FLAG);
F &= ~N_FLAG;
return(7);
}
static int op_adcn(void) /* ADC A,n */
{
register int i, carry;
register BYTE P;
carry = (F & C_FLAG) ? 1 : 0;
P = *PC++;
((A & 0xf) + (P & 0xf) + carry > 0xf) ? (F |= H_FLAG) : (F &= ~H_FLAG);
(A + P + carry > 255) ? (F |= C_FLAG) : (F &= ~C_FLAG);
A = i = (char) A + (char) P + carry;
(i < -128 || i > 127) ? (F |= P_FLAG) : (F &= ~P_FLAG);
(i & 128) ? (F |= S_FLAG) : (F &= ~S_FLAG);
(A) ? (F &= ~Z_FLAG) : (F |= Z_FLAG);
F &= ~N_FLAG;
return(7);
}
static int op_suba(void) /* SUB A,A */
{
A = 0;
F &= ~(S_FLAG | H_FLAG | P_FLAG | C_FLAG);
F |= Z_FLAG | N_FLAG;
return(4);
}
static int op_subb(void) /* SUB A,B */
{
register int i;
((B & 0xf) > (A & 0xf)) ? (F |= H_FLAG) : (F &= ~H_FLAG);
(B > A) ? (F |= C_FLAG) : (F &= ~C_FLAG);
A = i = (char) A - (char) B;
(i < -128 || i > 127) ? (F |= P_FLAG) : (F &= ~P_FLAG);
(i & 128) ? (F |= S_FLAG) : (F &= ~S_FLAG);
(A) ? (F &= ~Z_FLAG) : (F |= Z_FLAG);
F |= N_FLAG;
return(4);
}
static int op_subc(void) /* SUB A,C */
{
register int i;
((C & 0xf) > (A & 0xf)) ? (F |= H_FLAG) : (F &= ~H_FLAG);
(C > A) ? (F |= C_FLAG) : (F &= ~C_FLAG);
A = i = (char) A - (char) C;
(i < -128 || i > 127) ? (F |= P_FLAG) : (F &= ~P_FLAG);
(i & 128) ? (F |= S_FLAG) : (F &= ~S_FLAG);
(A) ? (F &= ~Z_FLAG) : (F |= Z_FLAG);
F |= N_FLAG;
return(4);
}
static int op_subd(void) /* SUB A,D */
{
register int i;
((D & 0xf) > (A & 0xf)) ? (F |= H_FLAG) : (F &= ~H_FLAG);
(D > A) ? (F |= C_FLAG) : (F &= ~C_FLAG);
A = i = (char) A - (char) D;
(i < -128 || i > 127) ? (F |= P_FLAG) : (F &= ~P_FLAG);
(i & 128) ? (F |= S_FLAG) : (F &= ~S_FLAG);
(A) ? (F &= ~Z_FLAG) : (F |= Z_FLAG);
F |= N_FLAG;
return(4);
}
static int op_sube(void) /* SUB A,E */
{
register int i;
((E & 0xf) > (A & 0xf)) ? (F |= H_FLAG) : (F &= ~H_FLAG);
(E > A) ? (F |= C_FLAG) : (F &= ~C_FLAG);
A = i = (char) A - (char) E;
(i < -128 || i > 127) ? (F |= P_FLAG) : (F &= ~P_FLAG);
(i & 128) ? (F |= S_FLAG) : (F &= ~S_FLAG);
(A) ? (F &= ~Z_FLAG) : (F |= Z_FLAG);
F |= N_FLAG;
return(4);
}
static int op_subh(void) /* SUB A,H */
{
register int i;
((H & 0xf) > (A & 0xf)) ? (F |= H_FLAG) : (F &= ~H_FLAG);
(H > A) ? (F |= C_FLAG) : (F &= ~C_FLAG);
A = i = (char) A - (char) H;
(i < -128 || i > 127) ? (F |= P_FLAG) : (F &= ~P_FLAG);
(i & 128) ? (F |= S_FLAG) : (F &= ~S_FLAG);
(A) ? (F &= ~Z_FLAG) : (F |= Z_FLAG);
F |= N_FLAG;
return(4);
}
static int op_subl(void) /* SUB A,L */
{
register int i;
((L & 0xf) > (A & 0xf)) ? (F |= H_FLAG) : (F &= ~H_FLAG);
(L > A) ? (F |= C_FLAG) : (F &= ~C_FLAG);
A = i = (char) A - (char) L;
(i < -128 || i > 127) ? (F |= P_FLAG) : (F &= ~P_FLAG);
(i & 128) ? (F |= S_FLAG) : (F &= ~S_FLAG);
(A) ? (F &= ~Z_FLAG) : (F |= Z_FLAG);
F |= N_FLAG;
return(4);
}
static int op_subhl(void) /* SUB A,(HL) */
{
register int i;
register BYTE P;
P = *(ram + (H << 8) + L);
((P & 0xf) > (A & 0xf)) ? (F |= H_FLAG) : (F &= ~H_FLAG);
(P > A) ? (F |= C_FLAG) : (F &= ~C_FLAG);
A = i = (char) A - (char) P;
(i < -128 || i > 127) ? (F |= P_FLAG) : (F &= ~P_FLAG);
(i & 128) ? (F |= S_FLAG) : (F &= ~S_FLAG);
(A) ? (F &= ~Z_FLAG) : (F |= Z_FLAG);
F |= N_FLAG;
return(7);
}
static int op_subn(void) /* SUB A,n */
{
register int i;
register BYTE P;
P = *PC++;
((P & 0xf) > (A & 0xf)) ? (F |= H_FLAG) : (F &= ~H_FLAG);
(P > A) ? (F |= C_FLAG) : (F &= ~C_FLAG);
A = i = (char) A - (char) P;
(i < -128 || i > 127) ? (F |= P_FLAG) : (F &= ~P_FLAG);
(i & 128) ? (F |= S_FLAG) : (F &= ~S_FLAG);
(A) ? (F &= ~Z_FLAG) : (F |= Z_FLAG);
F |= N_FLAG;
return(7);
}
static int op_sbca(void) /* SBC A,A */
{
if (F & C_FLAG) {
F |= S_FLAG | H_FLAG | N_FLAG | C_FLAG;
F &= ~(Z_FLAG | P_FLAG);
A = 255;
} else {
F |= Z_FLAG | N_FLAG;
F &= ~(S_FLAG | H_FLAG | P_FLAG | C_FLAG);
A = 0;
}
return(4);
}
static int op_sbcb(void) /* SBC A,B */
{
register int i, carry;
carry = (F & C_FLAG) ? 1 : 0;
((B & 0xf) + carry > (A & 0xf)) ? (F |= H_FLAG) : (F &= ~H_FLAG);
(B + carry > A) ? (F |= C_FLAG) : (F &= ~C_FLAG);
A = i = (char) A - (char) B - carry;
(i < -128 || i > 127) ? (F |= P_FLAG) : (F &= ~P_FLAG);
(i & 128) ? (F |= S_FLAG) : (F &= ~S_FLAG);
(A) ? (F &= ~Z_FLAG) : (F |= Z_FLAG);
F |= N_FLAG;
return(4);
}
static int op_sbcc(void) /* SBC A,C */
{
register int i, carry;
carry = (F & C_FLAG) ? 1 : 0;
((C & 0xf) + carry > (A & 0xf)) ? (F |= H_FLAG) : (F &= ~H_FLAG);
(C + carry > A) ? (F |= C_FLAG) : (F &= ~C_FLAG);
A = i = (char) A - (char) C - carry;
(i < -128 || i > 127) ? (F |= P_FLAG) : (F &= ~P_FLAG);
(i & 128) ? (F |= S_FLAG) : (F &= ~S_FLAG);
(A) ? (F &= ~Z_FLAG) : (F |= Z_FLAG);
F |= N_FLAG;
return(4);
}
static int op_sbcd(void) /* SBC A,D */
{
register int i, carry;
carry = (F & C_FLAG) ? 1 : 0;
((D & 0xf) + carry > (A & 0xf)) ? (F |= H_FLAG) : (F &= ~H_FLAG);
(D + carry > A) ? (F |= C_FLAG) : (F &= ~C_FLAG);
A = i = (char) A - (char) D - carry;
(i < -128 || i > 127) ? (F |= P_FLAG) : (F &= ~P_FLAG);
(i & 128) ? (F |= S_FLAG) : (F &= ~S_FLAG);
(A) ? (F &= ~Z_FLAG) : (F |= Z_FLAG);
F |= N_FLAG;
return(4);
}
static int op_sbce(void) /* SBC A,E */
{
register int i, carry;
carry = (F & C_FLAG) ? 1 : 0;
((E & 0xf) + carry > (A & 0xf)) ? (F |= H_FLAG) : (F &= ~H_FLAG);
(E + carry > A) ? (F |= C_FLAG) : (F &= ~C_FLAG);
A = i = (char) A - (char) E - carry;
(i < -128 || i > 127) ? (F |= P_FLAG) : (F &= ~P_FLAG);
(i & 128) ? (F |= S_FLAG) : (F &= ~S_FLAG);
(A) ? (F &= ~Z_FLAG) : (F |= Z_FLAG);
F |= N_FLAG;
return(4);
}
static int op_sbch(void) /* SBC A,H */
{
register int i, carry;
carry = (F & C_FLAG) ? 1 : 0;
((H & 0xf) + carry > (A & 0xf)) ? (F |= H_FLAG) : (F &= ~H_FLAG);
(H + carry > A) ? (F |= C_FLAG) : (F &= ~C_FLAG);
A = i = (char) A - (char) H - carry;
(i < -128 || i > 127) ? (F |= P_FLAG) : (F &= ~P_FLAG);
(i & 128) ? (F |= S_FLAG) : (F &= ~S_FLAG);
(A) ? (F &= ~Z_FLAG) : (F |= Z_FLAG);
F |= N_FLAG;
return(4);
}
static int op_sbcl(void) /* SBC A,L */
{
register int i, carry;
carry = (F & C_FLAG) ? 1 : 0;
((L & 0xf) + carry > (A & 0xf)) ? (F |= H_FLAG) : (F &= ~H_FLAG);
(L + carry > A) ? (F |= C_FLAG) : (F &= ~C_FLAG);
A = i = (char) A - (char) L - carry;
(i < -128 || i > 127) ? (F |= P_FLAG) : (F &= ~P_FLAG);
(i & 128) ? (F |= S_FLAG) : (F &= ~S_FLAG);
(A) ? (F &= ~Z_FLAG) : (F |= Z_FLAG);
F |= N_FLAG;
return(4);
}
static int op_sbchl(void) /* SBC A,(HL) */
{
register int i, carry;
register BYTE P;
P = *(ram + (H << 8) + L);
carry = (F & C_FLAG) ? 1 : 0;
((P & 0xf) + carry > (A & 0xf)) ? (F |= H_FLAG) : (F &= ~H_FLAG);
(P + carry > A) ? (F |= C_FLAG) : (F &= ~C_FLAG);
A = i = (char) A - (char) P - carry;
(i < -128 || i > 127) ? (F |= P_FLAG) : (F &= ~P_FLAG);
(i & 128) ? (F |= S_FLAG) : (F &= ~S_FLAG);
(A) ? (F &= ~Z_FLAG) : (F |= Z_FLAG);
F |= N_FLAG;
return(7);
}
static int op_sbcn(void) /* SBC A,n */
{
register int i, carry;
register BYTE P;
P = *PC++;
carry = (F & C_FLAG) ? 1 : 0;
((P & 0xf) + carry > (A & 0xf)) ? (F |= H_FLAG) : (F &= ~H_FLAG);
(P + carry > A) ? (F |= C_FLAG) : (F &= ~C_FLAG);
A = i = (char) A - (char) P - carry;
(i < -128 || i > 127) ? (F |= P_FLAG) : (F &= ~P_FLAG);
(i & 128) ? (F |= S_FLAG) : (F &= ~S_FLAG);
(A) ? (F &= ~Z_FLAG) : (F |= Z_FLAG);
F |= N_FLAG;
return(7);
}
static int op_cpa(void) /* CP A */
{
F &= ~(S_FLAG | H_FLAG | P_FLAG | C_FLAG);
F |= Z_FLAG | N_FLAG;
return(4);
}
static int op_cpb(void) /* CP B */
{
register int i;
((B & 0xf) > (A & 0xf)) ? (F |= H_FLAG) : (F &= ~H_FLAG);
(B > A) ? (F |= C_FLAG) : (F &= ~C_FLAG);
i = (char) A - (char) B;
(i < -128 || i > 127) ? (F |= P_FLAG) : (F &= ~P_FLAG);
(i & 128) ? (F |= S_FLAG) : (F &= ~S_FLAG);
(i) ? (F &= ~Z_FLAG) : (F |= Z_FLAG);
F |= N_FLAG;
return(4);
}
static int op_cpc(void) /* CP C */
{
register int i;
((C & 0xf) > (A & 0xf)) ? (F |= H_FLAG) : (F &= ~H_FLAG);
(C > A) ? (F |= C_FLAG) : (F &= ~C_FLAG);
i = (char) A - (char) C;
(i < -128 || i > 127) ? (F |= P_FLAG) : (F &= ~P_FLAG);
(i & 128) ? (F |= S_FLAG) : (F &= ~S_FLAG);
(i) ? (F &= ~Z_FLAG) : (F |= Z_FLAG);
F |= N_FLAG;
return(4);
}
static int op_cpd(void) /* CP D */
{
register int i;
((D & 0xf) > (A & 0xf)) ? (F |= H_FLAG) : (F &= ~H_FLAG);
(D > A) ? (F |= C_FLAG) : (F &= ~C_FLAG);
i = (char) A - (char) D;
(i < -128 || i > 127) ? (F |= P_FLAG) : (F &= ~P_FLAG);
(i & 128) ? (F |= S_FLAG) : (F &= ~S_FLAG);
(i) ? (F &= ~Z_FLAG) : (F |= Z_FLAG);
F |= N_FLAG;
return(4);
}
static int op_cpe(void) /* CP E */
{
register int i;
((E & 0xf) > (A & 0xf)) ? (F |= H_FLAG) : (F &= ~H_FLAG);
(E > A) ? (F |= C_FLAG) : (F &= ~C_FLAG);
i = (char) A - (char) E;
(i < -128 || i > 127) ? (F |= P_FLAG) : (F &= ~P_FLAG);
(i & 128) ? (F |= S_FLAG) : (F &= ~S_FLAG);
(i) ? (F &= ~Z_FLAG) : (F |= Z_FLAG);
F |= N_FLAG;
return(4);
}
static int op_cph(void) /* CP H */
{
register int i;
((H & 0xf) > (A & 0xf)) ? (F |= H_FLAG) : (F &= ~H_FLAG);
(H > A) ? (F |= C_FLAG) : (F &= ~C_FLAG);
i = (char) A - (char) H;
(i < -128 || i > 127) ? (F |= P_FLAG) : (F &= ~P_FLAG);
(i & 128) ? (F |= S_FLAG) : (F &= ~S_FLAG);
(i) ? (F &= ~Z_FLAG) : (F |= Z_FLAG);
F |= N_FLAG;
return(4);
}
static int op_cplr(void) /* CP L */
{
register int i;
((L & 0xf) > (A & 0xf)) ? (F |= H_FLAG) : (F &= ~H_FLAG);
(L > A) ? (F |= C_FLAG) : (F &= ~C_FLAG);
i = (char) A - (char) L;
(i < -128 || i > 127) ? (F |= P_FLAG) : (F &= ~P_FLAG);
(i & 128) ? (F |= S_FLAG) : (F &= ~S_FLAG);
(i) ? (F &= ~Z_FLAG) : (F |= Z_FLAG);
F |= N_FLAG;
return(4);
}
static int op_cphl(void) /* CP (HL) */
{
register int i;
register BYTE P;
P = *(ram + (H << 8) + L);
((P & 0xf) > (A & 0xf)) ? (F |= H_FLAG) : (F &= ~H_FLAG);
(P > A) ? (F |= C_FLAG) : (F &= ~C_FLAG);
i = (char) A - (char) P;
(i < -128 || i > 127) ? (F |= P_FLAG) : (F &= ~P_FLAG);
(i & 128) ? (F |= S_FLAG) : (F &= ~S_FLAG);
(i) ? (F &= ~Z_FLAG) : (F |= Z_FLAG);
F |= N_FLAG;
return(7);
}
static int op_cpn(void) /* CP n */
{
register int i;
register BYTE P;
P = *PC++;
((P & 0xf) > (A & 0xf)) ? (F |= H_FLAG) : (F &= ~H_FLAG);
(P > A) ? (F |= C_FLAG) : (F &= ~C_FLAG);
i = (char) A - (char) P;
(i < -128 || i > 127) ? (F |= P_FLAG) : (F &= ~P_FLAG);
(i & 128) ? (F |= S_FLAG) : (F &= ~S_FLAG);
(i) ? (F &= ~Z_FLAG) : (F |= Z_FLAG);
F |= N_FLAG;
return(7);
}
static int op_inca(void) /* INC A */
{
((A & 0xf) + 1 > 0xf) ? (F |= H_FLAG) : (F &= ~H_FLAG);
A++;
(A == 128) ? (F |= P_FLAG) : (F &= ~P_FLAG);
(A & 128) ? (F |= S_FLAG) : (F &= ~S_FLAG);
(A) ? (F &= ~Z_FLAG) : (F |= Z_FLAG);
F &= ~N_FLAG;
return(4);
}
static int op_incb(void) /* INC B */
{
((B & 0xf) + 1 > 0xf) ? (F |= H_FLAG) : (F &= ~H_FLAG);
B++;
(B == 128) ? (F |= P_FLAG) : (F &= ~P_FLAG);
(B & 128) ? (F |= S_FLAG) : (F &= ~S_FLAG);
(B) ? (F &= ~Z_FLAG) : (F |= Z_FLAG);
F &= ~N_FLAG;
return(4);
}
static int op_incc(void) /* INC C */
{
((C & 0xf) + 1 > 0xf) ? (F |= H_FLAG) : (F &= ~H_FLAG);
C++;
(C == 128) ? (F |= P_FLAG) : (F &= ~P_FLAG);
(C & 128) ? (F |= S_FLAG) : (F &= ~S_FLAG);
(C) ? (F &= ~Z_FLAG) : (F |= Z_FLAG);
F &= ~N_FLAG;
return(4);
}
static int op_incd(void) /* INC D */
{
((D & 0xf) + 1 > 0xf) ? (F |= H_FLAG) : (F &= ~H_FLAG);
D++;
(D == 128) ? (F |= P_FLAG) : (F &= ~P_FLAG);
(D & 128) ? (F |= S_FLAG) : (F &= ~S_FLAG);
(D) ? (F &= ~Z_FLAG) : (F |= Z_FLAG);
F &= ~N_FLAG;
return(4);
}
static int op_ince(void) /* INC E */
{
((E & 0xf) + 1 > 0xf) ? (F |= H_FLAG) : (F &= ~H_FLAG);
E++;
(E == 128) ? (F |= P_FLAG) : (F &= ~P_FLAG);
(E & 128) ? (F |= S_FLAG) : (F &= ~S_FLAG);
(E) ? (F &= ~Z_FLAG) : (F |= Z_FLAG);
F &= ~N_FLAG;
return(4);
}
static int op_inch(void) /* INC H */
{
((H & 0xf) + 1 > 0xf) ? (F |= H_FLAG) : (F &= ~H_FLAG);
H++;
(H == 128) ? (F |= P_FLAG) : (F &= ~P_FLAG);
(H & 128) ? (F |= S_FLAG) : (F &= ~S_FLAG);
(H) ? (F &= ~Z_FLAG) : (F |= Z_FLAG);
F &= ~N_FLAG;
return(4);
}
static int op_incl(void) /* INC L */
{
((L & 0xf) + 1 > 0xf) ? (F |= H_FLAG) : (F &= ~H_FLAG);
L++;
(L == 128) ? (F |= P_FLAG) : (F &= ~P_FLAG);
(L & 128) ? (F |= S_FLAG) : (F &= ~S_FLAG);
(L) ? (F &= ~Z_FLAG) : (F |= Z_FLAG);
F &= ~N_FLAG;
return(4);
}
static int op_incihl(void) /* INC (HL) */
{
register BYTE *p;
p = ram + (H << 8) + L;
((*p & 0xf) + 1 > 0xf) ? (F |= H_FLAG) : (F &= ~H_FLAG);
(*p)++;
(*p == 128) ? (F |= P_FLAG) : (F &= ~P_FLAG);
(*p & 128) ? (F |= S_FLAG) : (F &= ~S_FLAG);
(*p) ? (F &= ~Z_FLAG) : (F |= Z_FLAG);
F &= ~N_FLAG;
return(11);
}
static int op_deca(void) /* DEC A */
{
(((A - 1) & 0xf) == 0xf) ? (F |= H_FLAG) : (F &= ~H_FLAG);
A--;
(A == 127) ? (F |= P_FLAG) : (F &= ~P_FLAG);
(A & 128) ? (F |= S_FLAG) : (F &= ~S_FLAG);
(A) ? (F &= ~Z_FLAG) : (F |= Z_FLAG);
F |= N_FLAG;
return(4);
}
static int op_decb(void) /* DEC B */
{
(((B - 1) & 0xf) == 0xf) ? (F |= H_FLAG) : (F &= ~H_FLAG);
B--;
(B == 127) ? (F |= P_FLAG) : (F &= ~P_FLAG);
(B & 128) ? (F |= S_FLAG) : (F &= ~S_FLAG);
(B) ? (F &= ~Z_FLAG) : (F |= Z_FLAG);
F |= N_FLAG;
return(4);
}
static int op_decc(void) /* DEC C */
{
(((C - 1) & 0xf) == 0xf) ? (F |= H_FLAG) : (F &= ~H_FLAG);
C--;
(C == 127) ? (F |= P_FLAG) : (F &= ~P_FLAG);
(C & 128) ? (F |= S_FLAG) : (F &= ~S_FLAG);
(C) ? (F &= ~Z_FLAG) : (F |= Z_FLAG);
F |= N_FLAG;
return(4);
}
static int op_decd(void) /* DEC D */
{
(((D - 1) & 0xf) == 0xf) ? (F |= H_FLAG) : (F &= ~H_FLAG);
D--;
(D == 127) ? (F |= P_FLAG) : (F &= ~P_FLAG);
(D & 128) ? (F |= S_FLAG) : (F &= ~S_FLAG);
(D) ? (F &= ~Z_FLAG) : (F |= Z_FLAG);
F |= N_FLAG;
return(4);
}
static int op_dece(void) /* DEC E */
{
(((E - 1) & 0xf) == 0xf) ? (F |= H_FLAG) : (F &= ~H_FLAG);
E--;
(E == 127) ? (F |= P_FLAG) : (F &= ~P_FLAG);
(E & 128) ? (F |= S_FLAG) : (F &= ~S_FLAG);
(E) ? (F &= ~Z_FLAG) : (F |= Z_FLAG);
F |= N_FLAG;
return(4);
}
static int op_dech(void) /* DEC H */
{
(((H - 1) & 0xf) == 0xf) ? (F |= H_FLAG) : (F &= ~H_FLAG);
H--;
(H == 127) ? (F |= P_FLAG) : (F &= ~P_FLAG);
(H & 128) ? (F |= S_FLAG) : (F &= ~S_FLAG);
(H) ? (F &= ~Z_FLAG) : (F |= Z_FLAG);
F |= N_FLAG;
return(4);
}
static int op_decl(void) /* DEC L */
{
(((L - 1) & 0xf) == 0xf) ? (F |= H_FLAG) : (F &= ~H_FLAG);
L--;
(L == 127) ? (F |= P_FLAG) : (F &= ~P_FLAG);
(L & 128) ? (F |= S_FLAG) : (F &= ~S_FLAG);
(L) ? (F &= ~Z_FLAG) : (F |= Z_FLAG);
F |= N_FLAG;
return(4);
}
static int op_decihl(void) /* DEC (HL) */
{
register BYTE *p;
p = ram + (H << 8) + L;
(((*p - 1) & 0xf) == 0xf) ? (F |= H_FLAG) : (F &= ~H_FLAG);
(*p)--;
(*p == 127) ? (F |= P_FLAG) : (F &= ~P_FLAG);
(*p & 128) ? (F |= S_FLAG) : (F &= ~S_FLAG);
(*p) ? (F &= ~Z_FLAG) : (F |= Z_FLAG);
F |= N_FLAG;
return(11);
}
static int op_rlca(void) /* RLCA */
{
register int i;
i = (A & 128) ? 1 : 0;
(i) ? (F |= C_FLAG) : (F &= ~C_FLAG);
F &= ~(H_FLAG | N_FLAG);
A <<= 1;
A |= i;
return(4);
}
static int op_rrca(void) /* RRCA */
{
register int i;
i = A & 1;
(i) ? (F |= C_FLAG) : (F &= ~C_FLAG);
F &= ~(H_FLAG | N_FLAG);
A >>= 1;
if (i) A |= 128;
return(4);
}
static int op_rla(void) /* RLA */
{
register int old_c_flag;
old_c_flag = F & C_FLAG;
(A & 128) ? (F |= C_FLAG) : (F &= ~C_FLAG);
F &= ~(H_FLAG | N_FLAG);
A <<= 1;
if (old_c_flag) A |= 1;
return(4);
}
static int op_rra(void) /* RRA */
{
register int i, old_c_flag;
old_c_flag = F & C_FLAG;
i = A & 1;
(i) ? (F |= C_FLAG) : (F &= ~C_FLAG);
F &= ~(H_FLAG | N_FLAG);
A >>= 1;
if (old_c_flag) A |= 128;
return(4);
}
static int op_exdehl(void) /* EX DE,HL */
{
register unsigned i;
i = D;
D = H;
H = i;
i = E;
E = L;
L = i;
return(4);
}
static int op_exafaf(void) /* EX AF,AF' */
{
register unsigned i;
i = A;
A = A_;
A_ = i;
i = F;
F = F_;
F_ = i;
return(4);
}
static int op_exx(void) /* EXX */
{
register unsigned i;
i = B;
B = B_;
B_ = i;
i = C;
C = C_;
C_ = i;
i = D;
D = D_;
D_ = i;
i = E;
E = E_;
E_ = i;
i = H;
H = H_;
H_ = i;
i = L;
L = L_;
L_ = i;
return(4);
}
static int op_exsphl(void) /* EX (SP),HL */
{
register int i;
i = *STACK;
*STACK = L;
L = i;
i = *(STACK + 1);
*(STACK + 1) = H;
H = i;
return(19);
}
static int op_pushaf(void) /* PUSH AF */
{
#ifdef WANT_SPC
if (STACK <= ram)
STACK = ram + 65536L;
#endif
*--STACK = A;
#ifdef WANT_SPC
if (STACK <= ram)
STACK = ram + 65536L;
#endif
*--STACK = F;
return(11);
}
static int op_pushbc(void) /* PUSH BC */
{
#ifdef WANT_SPC
if (STACK <= ram)
STACK = ram + 65536L;
#endif
*--STACK = B;
#ifdef WANT_SPC
if (STACK <= ram)
STACK = ram + 65536L;
#endif
*--STACK = C;
return(11);
}
static int op_pushde(void) /* PUSH DE */
{
#ifdef WANT_SPC
if (STACK <= ram)
STACK = ram + 65536L;
#endif
*--STACK = D;
#ifdef WANT_SPC
if (STACK <= ram)
STACK = ram + 65536L;
#endif
*--STACK = E;
return(11);
}
static int op_pushhl(void) /* PUSH HL */
{
#ifdef WANT_SPC
if (STACK <= ram)
STACK = ram + 65536L;
#endif
*--STACK = H;
#ifdef WANT_SPC
if (STACK <= ram)
STACK = ram + 65536L;
#endif
*--STACK = L;
return(11);
}
static int op_popaf(void) /* POP AF */
{
F = *STACK++;
#ifdef WANT_SPC
if (STACK >= ram + 65536L)
STACK = ram;
#endif
A = *STACK++;
#ifdef WANT_SPC
if (STACK >= ram + 65536L)
STACK = ram;
#endif
return(10);
}
static int op_popbc(void) /* POP BC */
{
C = *STACK++;
#ifdef WANT_SPC
if (STACK >= ram + 65536L)
STACK = ram;
#endif
B = *STACK++;
#ifdef WANT_SPC
if (STACK >= ram + 65536L)
STACK = ram;
#endif
return(10);
}
static int op_popde(void) /* POP DE */
{
E = *STACK++;
#ifdef WANT_SPC
if (STACK >= ram + 65536L)
STACK = ram;
#endif
D = *STACK++;
#ifdef WANT_SPC
if (STACK >= ram + 65536L)
STACK = ram;
#endif
return(10);
}
static int op_pophl(void) /* POP HL */
{
L = *STACK++;
#ifdef WANT_SPC
if (STACK >= ram + 65536L)
STACK = ram;
#endif
H = *STACK++;
#ifdef WANT_SPC
if (STACK >= ram + 65536L)
STACK = ram;
#endif
return(10);
}
static int op_jp(void) /* JP */
{
register unsigned i;
i = *PC++;
i += *PC << 8;
PC = ram + i;
return(10);
}
static int op_jphl(void) /* JP (HL) */
{
PC = ram + (H << 8) + L;
return(4);
}
static int op_jr(void) /* JR */
{
PC += (char) *PC + 1;
return(12);
}
static int op_djnz(void) /* DJNZ */
{
if (--B) {
PC += (char) *PC + 1;
return(13);
} else {
PC++;
return(8);
}
}
static int op_call(void) /* CALL */
{
register unsigned i;
i = *PC++;
i += *PC++ << 8;
#ifdef WANT_SPC
if (STACK <= ram)
STACK = ram + 65536L;
#endif
*--STACK = (PC - ram) >> 8;
#ifdef WANT_SPC
if (STACK <= ram)
STACK = ram + 65536L;
#endif
*--STACK = (PC - ram);
PC = ram + i;
return(17);
}
static int op_ret(void) /* RET */
{
register unsigned i;
i = *STACK++;
#ifdef WANT_SPC
if (STACK >= ram + 65536L)
STACK = ram;
#endif
i += *STACK++ << 8;
#ifdef WANT_SPC
if (STACK >= ram + 65536L)
STACK = ram;
#endif
PC = ram + i;
return(10);
}
static int op_jpz(void) /* JP Z,nn */
{
register unsigned i;
if (F & Z_FLAG) {
i = *PC++;
i += *PC++ << 8;
PC = ram + i;
} else
PC += 2;
return(10);
}
static int op_jpnz(void) /* JP NZ,nn */
{
register unsigned i;
if (!(F & Z_FLAG)) {
i = *PC++;
i += *PC++ << 8;
PC = ram + i;
} else
PC += 2;
return(10);
}
static int op_jpc(void) /* JP C,nn */
{
register unsigned i;
if (F & C_FLAG) {
i = *PC++;
i += *PC++ << 8;
PC = ram + i;
} else
PC += 2;
return(10);
}
static int op_jpnc(void) /* JP NC,nn */
{
register unsigned i;
if (!(F & C_FLAG)) {
i = *PC++;
i += *PC++ << 8;
PC = ram + i;
} else
PC += 2;
return(10);
}
static int op_jppe(void) /* JP PE,nn */
{
register unsigned i;
if (F & P_FLAG) {
i = *PC++;
i += *PC++ << 8;
PC = ram + i;
} else
PC += 2;
return(10);
}
static int op_jppo(void) /* JP PO,nn */
{
register unsigned i;
if (!(F & P_FLAG)) {
i = *PC++;
i += *PC++ << 8;
PC = ram + i;
} else
PC += 2;
return(10);
}
static int op_jpm(void) /* JP M,nn */
{
register unsigned i;
if (F & S_FLAG) {
i = *PC++;
i += *PC++ << 8;
PC = ram + i;
} else
PC += 2;
return(10);
}
static int op_jpp(void) /* JP P,nn */
{
register unsigned i;
if (!(F & S_FLAG)) {
i = *PC++;
i += *PC++ << 8;
PC = ram + i;
} else
PC += 2;
return(10);
}
static int op_calz(void) /* CALL Z,nn */
{
register unsigned i;
if (F & Z_FLAG) {
i = *PC++;
i += *PC++ << 8;
#ifdef WANT_SPC
if (STACK <= ram)
STACK = ram + 65536L;
#endif
*--STACK = (PC - ram) >> 8;
#ifdef WANT_SPC
if (STACK <= ram)
STACK = ram + 65536L;
#endif
*--STACK = (PC - ram);
PC = ram + i;
return(17);
} else {
PC += 2;
return(10);
}
}
static int op_calnz(void) /* CALL NZ,nn */
{
register unsigned i;
if (!(F & Z_FLAG)) {
i = *PC++;
i += *PC++ << 8;
#ifdef WANT_SPC
if (STACK <= ram)
STACK = ram + 65536L;
#endif
*--STACK = (PC - ram) >> 8;
#ifdef WANT_SPC
if (STACK <= ram)
STACK = ram + 65536L;
#endif
*--STACK = (PC - ram);
PC = ram + i;
return(17);
} else {
PC += 2;
return(10);
}
}
static int op_calc(void) /* CALL C,nn */
{
register unsigned i;
if (F & C_FLAG) {
i = *PC++;
i += *PC++ << 8;
#ifdef WANT_SPC
if (STACK <= ram)
STACK = ram + 65536L;
#endif
*--STACK = (PC - ram) >> 8;
#ifdef WANT_SPC
if (STACK <= ram)
STACK = ram + 65536L;
#endif
*--STACK = (PC - ram);
PC = ram + i;
return(17);
} else {
PC += 2;
return(10);
}
}
static int op_calnc(void) /* CALL NC,nn */
{
register unsigned i;
if (!(F & C_FLAG)) {
i = *PC++;
i += *PC++ << 8;
#ifdef WANT_SPC
if (STACK <= ram)
STACK = ram + 65536L;
#endif
*--STACK = (PC - ram) >> 8;
#ifdef WANT_SPC
if (STACK <= ram)
STACK = ram + 65536L;
#endif
*--STACK = (PC - ram);
PC = ram + i;
return(17);
} else {
PC += 2;
return(10);
}
}
static int op_calpe(void) /* CALL PE,nn */
{
register unsigned i;
if (F & P_FLAG) {
i = *PC++;
i += *PC++ << 8;
#ifdef WANT_SPC
if (STACK <= ram)
STACK = ram + 65536L;
#endif
*--STACK = (PC - ram) >> 8;
#ifdef WANT_SPC
if (STACK <= ram)
STACK = ram + 65536L;
#endif
*--STACK = (PC - ram);
PC = ram + i;
return(17);
} else {
PC += 2;
return(10);
}
}
static int op_calpo(void) /* CALL PO,nn */
{
register unsigned i;
if (!(F & P_FLAG)) {
i = *PC++;
i += *PC++ << 8;
#ifdef WANT_SPC
if (STACK <= ram)
STACK = ram + 65536L;
#endif
*--STACK = (PC - ram) >> 8;
#ifdef WANT_SPC
if (STACK <= ram)
STACK = ram + 65536L;
#endif
*--STACK = (PC - ram);
PC = ram + i;
return(17);
} else {
PC += 2;
return(10);
}
}
static int op_calm(void) /* CALL M,nn */
{
register unsigned i;
if (F & S_FLAG) {
i = *PC++;
i += *PC++ << 8;
#ifdef WANT_SPC
if (STACK <= ram)
STACK = ram + 65536L;
#endif
*--STACK = (PC - ram) >> 8;
#ifdef WANT_SPC
if (STACK <= ram)
STACK = ram + 65536L;
#endif
*--STACK = (PC - ram);
PC = ram + i;
return(17);
} else {
PC += 2;
return(10);
}
}
static int op_calp(void) /* CALL P,nn */
{
register unsigned i;
if (!(F & S_FLAG)) {
i = *PC++;
i += *PC++ << 8;
#ifdef WANT_SPC
if (STACK <= ram)
STACK = ram + 65536L;
#endif
*--STACK = (PC - ram) >> 8;
#ifdef WANT_SPC
if (STACK <= ram)
STACK = ram + 65536L;
#endif
*--STACK = (PC - ram);
PC = ram + i;
return(17);
} else {
PC += 2;
return(10);
}
}
static int op_retz(void) /* RET Z */
{
register unsigned i;
if (F & Z_FLAG) {
i = *STACK++;
#ifdef WANT_SPC
if (STACK >= ram + 65536L)
STACK = ram;
#endif
i += *STACK++ << 8;
#ifdef WANT_SPC
if (STACK >= ram + 65536L)
STACK = ram;
#endif
PC = ram + i;
return(11);
} else {
return(5);
}
}
static int op_retnz(void) /* RET NZ */
{
register unsigned i;
if (!(F & Z_FLAG)) {
i = *STACK++;
#ifdef WANT_SPC
if (STACK >= ram + 65536L)
STACK = ram;
#endif
i += *STACK++ << 8;
#ifdef WANT_SPC
if (STACK >= ram + 65536L)
STACK = ram;
#endif
PC = ram + i;
return(11);
} else {
return(5);
}
}
static int op_retc(void) /* RET C */
{
register unsigned i;
if (F & C_FLAG) {
i = *STACK++;
#ifdef WANT_SPC
if (STACK >= ram + 65536L)
STACK = ram;
#endif
i += *STACK++ << 8;
#ifdef WANT_SPC
if (STACK >= ram + 65536L)
STACK = ram;
#endif
PC = ram + i;
return(11);
} else {
return(5);
}
}
static int op_retnc(void) /* RET NC */
{
register unsigned i;
if (!(F & C_FLAG)) {
i = *STACK++;
#ifdef WANT_SPC
if (STACK >= ram + 65536L)
STACK = ram;
#endif
i += *STACK++ << 8;
#ifdef WANT_SPC
if (STACK >= ram + 65536L)
STACK = ram;
#endif
PC = ram + i;
return(11);
} else {
return(5);
}
}
static int op_retpe(void) /* RET PE */
{
register unsigned i;
if (F & P_FLAG) {
i = *STACK++;
#ifdef WANT_SPC
if (STACK >= ram + 65536L)
STACK = ram;
#endif
i += *STACK++ << 8;
#ifdef WANT_SPC
if (STACK >= ram + 65536L)
STACK = ram;
#endif
PC = ram + i;
return(11);
} else {
return(5);
}
}
static int op_retpo(void) /* RET PO */
{
register unsigned i;
if (!(F & P_FLAG)) {
i = *STACK++;
#ifdef WANT_SPC
if (STACK >= ram + 65536L)
STACK = ram;
#endif
i += *STACK++ << 8;
#ifdef WANT_SPC
if (STACK >= ram + 65536L)
STACK = ram;
#endif
PC = ram + i;
return(11);
} else {
return(5);
}
}
static int op_retm(void) /* RET M */
{
register unsigned i;
if (F & S_FLAG) {
i = *STACK++;
#ifdef WANT_SPC
if (STACK >= ram + 65536L)
STACK = ram;
#endif
i += *STACK++ << 8;
#ifdef WANT_SPC
if (STACK >= ram + 65536L)
STACK = ram;
#endif
PC = ram + i;
return(11);
} else {
return(5);
}
}
static int op_retp(void) /* RET P */
{
register unsigned i;
if (!(F & S_FLAG)) {
i = *STACK++;
#ifdef WANT_SPC
if (STACK >= ram + 65536L)
STACK = ram;
#endif
i += *STACK++ << 8;
#ifdef WANT_SPC
if (STACK >= ram + 65536L)
STACK = ram;
#endif
PC = ram + i;
return(11);
} else {
return(5);
}
}
static int op_jrz(void) /* JR Z,n */
{
if (F & Z_FLAG) {
PC += (char) *PC + 1;
return(12);
} else {
PC++;
return(7);
}
}
static int op_jrnz(void) /* JR NZ,n */
{
if (!(F & Z_FLAG)) {
PC += (char) *PC + 1;
return(12);
} else {
PC++;
return(7);
}
}
static int op_jrc(void) /* JR C,n */
{
if (F & C_FLAG) {
PC += (char) *PC + 1;
return(12);
} else {
PC++;
return(7);
}
}
static int op_jrnc(void) /* JR NC,n */
{
if (!(F & C_FLAG)) {
PC += (char) *PC + 1;
return(12);
} else {
PC++;
return(7);
}
}
static int op_rst00(void) /* RST 00 */
{
#ifdef WANT_SPC
if (STACK <= ram)
STACK = ram + 65536L;
#endif
*--STACK = (PC - ram) >> 8;
#ifdef WANT_SPC
if (STACK <= ram)
STACK = ram + 65536L;
#endif
*--STACK = (PC - ram);
PC = ram;
return(11);
}
static int op_rst08(void) /* RST 08 */
{
#ifdef WANT_SPC
if (STACK <= ram)
STACK = ram + 65536L;
#endif
*--STACK = (PC - ram) >> 8;
#ifdef WANT_SPC
if (STACK <= ram)
STACK = ram + 65536L;
#endif
*--STACK = (PC - ram);
PC = ram + 0x08;
return(11);
}
static int op_rst10(void) /* RST 10 */
{
#ifdef WANT_SPC
if (STACK <= ram)
STACK = ram + 65536L;
#endif
*--STACK = (PC - ram) >> 8;
#ifdef WANT_SPC
if (STACK <= ram)
STACK = ram + 65536L;
#endif
*--STACK = (PC - ram);
PC = ram + 0x10;
return(11);
}
static int op_rst18(void) /* RST 18 */
{
#ifdef WANT_SPC
if (STACK <= ram)
STACK = ram + 65536L;
#endif
*--STACK = (PC - ram) >> 8;
#ifdef WANT_SPC
if (STACK <= ram)
STACK = ram + 65536L;
#endif
*--STACK = (PC - ram);
PC = ram + 0x18;
return(11);
}
static int op_rst20(void) /* RST 20 */
{
#ifdef WANT_SPC
if (STACK <= ram)
STACK = ram + 65536L;
#endif
*--STACK = (PC - ram) >> 8;
#ifdef WANT_SPC
if (STACK <= ram)
STACK = ram + 65536L;
#endif
*--STACK = (PC - ram);
PC = ram + 0x20;
return(11);
}
static int op_rst28(void) /* RST 28 */
{
#ifdef WANT_SPC
if (STACK <= ram)
STACK = ram + 65536L;
#endif
*--STACK = (PC - ram) >> 8;
#ifdef WANT_SPC
if (STACK <= ram)
STACK = ram + 65536L;
#endif
*--STACK = (PC - ram);
PC = ram + 0x28;
return(11);
}
static int op_rst30(void) /* RST 30 */
{
#ifdef WANT_SPC
if (STACK <= ram)
STACK = ram + 65536L;
#endif
*--STACK = (PC - ram) >> 8;
#ifdef WANT_SPC
if (STACK <= ram)
STACK = ram + 65536L;
#endif
*--STACK = (PC - ram);
PC = ram + 0x30;
return(11);
}
static int op_rst38(void) /* RST 38 */
{
#ifdef WANT_SPC
if (STACK <= ram)
STACK = ram + 65536L;
#endif
*--STACK = (PC - ram) >> 8;
#ifdef WANT_SPC
if (STACK <= ram)
STACK = ram + 65536L;
#endif
*--STACK = (PC - ram);
PC = ram + 0x38;
return(11);
}
View Git Blame Copy Permalink