t11ops.c

这个是延伸mame的在wince平台下的游戏模拟器的代码

static void bis_rgd_rg(void)    { BIS_X(RGD,RG);  }
static void bis_rgd_rgd(void)   { BIS_M(RGD,RGD); }
static void bis_rgd_in(void)    { BIS_M(RGD,IN);  }
static void bis_rgd_ind(void)   { BIS_M(RGD,IND); }
static void bis_rgd_de(void)    { BIS_M(RGD,DE);  }
static void bis_rgd_ded(void)   { BIS_M(RGD,DED); }
static void bis_rgd_ix(void)    { BIS_M(RGD,IX);  }
static void bis_rgd_ixd(void)   { BIS_M(RGD,IXD); }
static void bis_in_rg(void)     { BIS_X(IN,RG);   }
static void bis_in_rgd(void)    { BIS_M(IN,RGD);  }
static void bis_in_in(void)     { BIS_M(IN,IN);   }
static void bis_in_ind(void)    { BIS_M(IN,IND);  }
static void bis_in_de(void)     { BIS_M(IN,DE);   }
static void bis_in_ded(void)    { BIS_M(IN,DED);  }
static void bis_in_ix(void)     { BIS_M(IN,IX);   }
static void bis_in_ixd(void)    { BIS_M(IN,IXD);  }
static void bis_ind_rg(void)    { BIS_X(IND,RG);  }
static void bis_ind_rgd(void)   { BIS_M(IND,RGD); }
static void bis_ind_in(void)    { BIS_M(IND,IN);  }
static void bis_ind_ind(void)   { BIS_M(IND,IND); }
static void bis_ind_de(void)    { BIS_M(IND,DE);  }
static void bis_ind_ded(void)   { BIS_M(IND,DED); }
static void bis_ind_ix(void)    { BIS_M(IND,IX);  }
static void bis_ind_ixd(void)   { BIS_M(IND,IXD); }
static void bis_de_rg(void)     { BIS_X(DE,RG);   }
static void bis_de_rgd(void)    { BIS_M(DE,RGD);  }
static void bis_de_in(void)     { BIS_M(DE,IN);   }
static void bis_de_ind(void)    { BIS_M(DE,IND);  }
static void bis_de_de(void)     { BIS_M(DE,DE);   }
static void bis_de_ded(void)    { BIS_M(DE,DED);  }
static void bis_de_ix(void)     { BIS_M(DE,IX);   }
static void bis_de_ixd(void)    { BIS_M(DE,IXD);  }
static void bis_ded_rg(void)    { BIS_X(DED,RG);  }
static void bis_ded_rgd(void)   { BIS_M(DED,RGD); }
static void bis_ded_in(void)    { BIS_M(DED,IN);  }
static void bis_ded_ind(void)   { BIS_M(DED,IND); }
static void bis_ded_de(void)    { BIS_M(DED,DE);  }
static void bis_ded_ded(void)   { BIS_M(DED,DED); }
static void bis_ded_ix(void)    { BIS_M(DED,IX);  }
static void bis_ded_ixd(void)   { BIS_M(DED,IXD); }
static void bis_ix_rg(void)     { BIS_X(IX,RG);   }
static void bis_ix_rgd(void)    { BIS_M(IX,RGD);  }
static void bis_ix_in(void)     { BIS_M(IX,IN);   }
static void bis_ix_ind(void)    { BIS_M(IX,IND);  }
static void bis_ix_de(void)     { BIS_M(IX,DE);   }
static void bis_ix_ded(void)    { BIS_M(IX,DED);  }
static void bis_ix_ix(void)     { BIS_M(IX,IX);   }
static void bis_ix_ixd(void)    { BIS_M(IX,IXD);  }
static void bis_ixd_rg(void)    { BIS_X(IXD,RG);  }
static void bis_ixd_rgd(void)   { BIS_M(IXD,RGD); }
static void bis_ixd_in(void)    { BIS_M(IXD,IN);  }
static void bis_ixd_ind(void)   { BIS_M(IXD,IND); }
static void bis_ixd_de(void)    { BIS_M(IXD,DE);  }
static void bis_ixd_ded(void)   { BIS_M(IXD,DED); }
static void bis_ixd_ix(void)    { BIS_M(IXD,IX);  }
static void bis_ixd_ixd(void)   { BIS_M(IXD,IXD); }

static void add_rg_rg(void)     { ADD_R(RG,RG);   }
static void add_rg_rgd(void)    { ADD_M(RG,RGD);  }
static void add_rg_in(void)     { ADD_M(RG,IN);   }
static void add_rg_ind(void)    { ADD_M(RG,IND);  }
static void add_rg_de(void)     { ADD_M(RG,DE);   }
static void add_rg_ded(void)    { ADD_M(RG,DED);  }
static void add_rg_ix(void)     { ADD_M(RG,IX);   }
static void add_rg_ixd(void)    { ADD_M(RG,IXD);  }
static void add_rgd_rg(void)    { ADD_X(RGD,RG);  }
static void add_rgd_rgd(void)   { ADD_M(RGD,RGD); }
static void add_rgd_in(void)    { ADD_M(RGD,IN);  }
static void add_rgd_ind(void)   { ADD_M(RGD,IND); }
static void add_rgd_de(void)    { ADD_M(RGD,DE);  }
static void add_rgd_ded(void)   { ADD_M(RGD,DED); }
static void add_rgd_ix(void)    { ADD_M(RGD,IX);  }
static void add_rgd_ixd(void)   { ADD_M(RGD,IXD); }
static void add_in_rg(void)     { ADD_X(IN,RG);   }
static void add_in_rgd(void)    { ADD_M(IN,RGD);  }
static void add_in_in(void)     { ADD_M(IN,IN);   }
static void add_in_ind(void)    { ADD_M(IN,IND);  }
static void add_in_de(void)     { ADD_M(IN,DE);   }
static void add_in_ded(void)    { ADD_M(IN,DED);  }
static void add_in_ix(void)     { ADD_M(IN,IX);   }
static void add_in_ixd(void)    { ADD_M(IN,IXD);  }
static void add_ind_rg(void)    { ADD_X(IND,RG);  }
static void add_ind_rgd(void)   { ADD_M(IND,RGD); }
static void add_ind_in(void)    { ADD_M(IND,IN);  }
static void add_ind_ind(void)   { ADD_M(IND,IND); }
static void add_ind_de(void)    { ADD_M(IND,DE);  }
static void add_ind_ded(void)   { ADD_M(IND,DED); }
static void add_ind_ix(void)    { ADD_M(IND,IX);  }
static void add_ind_ixd(void)   { ADD_M(IND,IXD); }
static void add_de_rg(void)     { ADD_X(DE,RG);   }
static void add_de_rgd(void)    { ADD_M(DE,RGD);  }
static void add_de_in(void)     { ADD_M(DE,IN);   }
static void add_de_ind(void)    { ADD_M(DE,IND);  }
static void add_de_de(void)     { ADD_M(DE,DE);   }
static void add_de_ded(void)    { ADD_M(DE,DED);  }
static void add_de_ix(void)     { ADD_M(DE,IX);   }
static void add_de_ixd(void)    { ADD_M(DE,IXD);  }
static void add_ded_rg(void)    { ADD_X(DED,RG);  }
static void add_ded_rgd(void)   { ADD_M(DED,RGD); }
static void add_ded_in(void)    { ADD_M(DED,IN);  }
static void add_ded_ind(void)   { ADD_M(DED,IND); }
static void add_ded_de(void)    { ADD_M(DED,DE);  }
static void add_ded_ded(void)   { ADD_M(DED,DED); }
static void add_ded_ix(void)    { ADD_M(DED,IX);  }
static void add_ded_ixd(void)   { ADD_M(DED,IXD); }
static void add_ix_rg(void)     { ADD_X(IX,RG);   }
static void add_ix_rgd(void)    { ADD_M(IX,RGD);  }
static void add_ix_in(void)     { ADD_M(IX,IN);   }
static void add_ix_ind(void)    { ADD_M(IX,IND);  }
static void add_ix_de(void)     { ADD_M(IX,DE);   }
static void add_ix_ded(void)    { ADD_M(IX,DED);  }
static void add_ix_ix(void)     { ADD_M(IX,IX);   }
static void add_ix_ixd(void)    { ADD_M(IX,IXD);  }
static void add_ixd_rg(void)    { ADD_X(IXD,RG);  }
static void add_ixd_rgd(void)   { ADD_M(IXD,RGD); }
static void add_ixd_in(void)    { ADD_M(IXD,IN);  }
static void add_ixd_ind(void)   { ADD_M(IXD,IND); }
static void add_ixd_de(void)    { ADD_M(IXD,DE);  }
static void add_ixd_ded(void)   { ADD_M(IXD,DED); }
static void add_ixd_ix(void)    { ADD_M(IXD,IX);  }
static void add_ixd_ixd(void)   { ADD_M(IXD,IXD); }

static void xor_rg(void)        { XOR_R(RG);  }
static void xor_rgd(void)       { XOR_M(RGD); }
static void xor_in(void)        { XOR_M(IN);  }
static void xor_ind(void)       { XOR_M(IND); }
static void xor_de(void)        { XOR_M(DE);  }
static void xor_ded(void)       { XOR_M(DED); }
static void xor_ix(void)        { XOR_M(IX);  }
static void xor_ixd(void)       { XOR_M(IXD); }

static void sob(void)
{
	int sreg, source;
	
	GET_SREG; source = REGD(sreg);
	source -= 1;
	REGW(sreg) = source;
	if (source)
		PC -= 2 * (state.op & 0x3f);
}

static void bpl(void)           { BR(!GET_N); }
static void bmi(void)           { BR( GET_N); }
static void bhi(void)           { BR(!GET_C && !GET_Z); }
static void blos(void)          { BR( GET_C ||  GET_Z); }
static void bvc(void)           { BR(!GET_V); }
static void bvs(void)           { BR( GET_V); }
static void bcc(void)           { BR(!GET_C); }
static void bcs(void)           { BR( GET_C); }

static void emt(void)
{
	PUSH(PSW);
	PUSH(PC);
	PC = RWORD(0x18);
	PSW = RWORD(0x1a);
}

static void trap(void)
{
	PUSH(PSW);
	PUSH(PC);
	PC = RWORD(0x1c);
	PSW = RWORD(0x1e);
}

static void clrb_rg(void)       { CLRB_R(RG);  }
static void clrb_rgd(void)      { CLRB_M(RGD); }
static void clrb_in(void)       { CLRB_M(IN);  }
static void clrb_ind(void)      { CLRB_M(IND); }
static void clrb_de(void)       { CLRB_M(DE);  }
static void clrb_ded(void)      { CLRB_M(DED); }
static void clrb_ix(void)       { CLRB_M(IX);  }
static void clrb_ixd(void)      { CLRB_M(IXD); }

static void comb_rg(void)       { COMB_R(RG);  }
static void comb_rgd(void)      { COMB_M(RGD); }
static void comb_in(void)       { COMB_M(IN);  }
static void comb_ind(void)      { COMB_M(IND); }
static void comb_de(void)       { COMB_M(DE);  }
static void comb_ded(void)      { COMB_M(DED); }
static void comb_ix(void)       { COMB_M(IX);  }
static void comb_ixd(void)      { COMB_M(IXD); }

static void incb_rg(void)       { INCB_R(RG);  }
static void incb_rgd(void)      { INCB_M(RGD); }
static void incb_in(void)       { INCB_M(IN);  }
static void incb_ind(void)      { INCB_M(IND); }
static void incb_de(void)       { INCB_M(DE);  }
static void incb_ded(void)      { INCB_M(DED); }
static void incb_ix(void)       { INCB_M(IX);  }
static void incb_ixd(void)      { INCB_M(IXD); }

static void decb_rg(void)       { DECB_R(RG);  }
static void decb_rgd(void)      { DECB_M(RGD); }
static void decb_in(void)       { DECB_M(IN);  }
static void decb_ind(void)      { DECB_M(IND); }
static void decb_de(void)       { DECB_M(DE);  }
static void decb_ded(void)      { DECB_M(DED); }
static void decb_ix(void)       { DECB_M(IX);  }
static void decb_ixd(void)      { DECB_M(IXD); }

static void negb_rg(void)       { NEGB_R(RG);  }
static void negb_rgd(void)      { NEGB_M(RGD); }
static void negb_in(void)       { NEGB_M(IN);  }
static void negb_ind(void)      { NEGB_M(IND); }
static void negb_de(void)       { NEGB_M(DE);  }
static void negb_ded(void)      { NEGB_M(DED); }
static void negb_ix(void)       { NEGB_M(IX);  }
static void negb_ixd(void)      { NEGB_M(IXD); }

static void adcb_rg(void)       { ADCB_R(RG);  }
static void adcb_rgd(void)      { ADCB_M(RGD); }
static void adcb_in(void)       { ADCB_M(IN);  }
static void adcb_ind(void)      { ADCB_M(IND); }
static void adcb_de(void)       { ADCB_M(DE);  }
static void adcb_ded(void)      { ADCB_M(DED); }
static void adcb_ix(void)       { ADCB_M(IX);  }
static void adcb_ixd(void)      { ADCB_M(IXD); }

static void sbcb_rg(void)       { SBCB_R(RG);  }
static void sbcb_rgd(void)      { SBCB_M(RGD); }
static void sbcb_in(void)       { SBCB_M(IN);  }
static void sbcb_ind(void)      { SBCB_M(IND); }
static void sbcb_de(void)       { SBCB_M(DE);  }
static void sbcb_ded(void)      { SBCB_M(DED); }
static void sbcb_ix(void)       { SBCB_M(IX);  }
static void sbcb_ixd(void)      { SBCB_M(IXD); }

static void tstb_rg(void)       { TSTB_R(RG);  }
static void tstb_rgd(void)      { TSTB_M(RGD); }
static void tstb_in(void)       { TSTB_M(IN);  }
static void tstb_ind(void)      { TSTB_M(IND); }
static void tstb_de(void)       { TSTB_M(DE);  }