t11ops.c

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

static void mov_de_rgd(void)    { MOV_M(DE,RGD);  }
static void mov_de_in(void)     { MOV_M(DE,IN);   }
static void mov_de_ind(void)    { MOV_M(DE,IND);  }
static void mov_de_de(void)     { MOV_M(DE,DE);   }
static void mov_de_ded(void)    { MOV_M(DE,DED);  }
static void mov_de_ix(void)     { MOV_M(DE,IX);   }
static void mov_de_ixd(void)    { MOV_M(DE,IXD);  }
static void mov_ded_rg(void)    { MOV_M(DED,RG);  }
static void mov_ded_rgd(void)   { MOV_M(DED,RGD); }
static void mov_ded_in(void)    { MOV_M(DED,IN);  }
static void mov_ded_ind(void)   { MOV_M(DED,IND); }
static void mov_ded_de(void)    { MOV_M(DED,DE);  }
static void mov_ded_ded(void)   { MOV_M(DED,DED); }
static void mov_ded_ix(void)    { MOV_M(DED,IX);  }
static void mov_ded_ixd(void)   { MOV_M(DED,IXD); }
static void mov_ix_rg(void)     { MOV_M(IX,RG);   }
static void mov_ix_rgd(void)    { MOV_M(IX,RGD);  }
static void mov_ix_in(void)     { MOV_M(IX,IN);   }
static void mov_ix_ind(void)    { MOV_M(IX,IND);  }
static void mov_ix_de(void)     { MOV_M(IX,DE);   }
static void mov_ix_ded(void)    { MOV_M(IX,DED);  }
static void mov_ix_ix(void)     { MOV_M(IX,IX);   }
static void mov_ix_ixd(void)    { MOV_M(IX,IXD);  }
static void mov_ixd_rg(void)    { MOV_M(IXD,RG);  }
static void mov_ixd_rgd(void)   { MOV_M(IXD,RGD); }
static void mov_ixd_in(void)    { MOV_M(IXD,IN);  }
static void mov_ixd_ind(void)   { MOV_M(IXD,IND); }
static void mov_ixd_de(void)    { MOV_M(IXD,DE);  }
static void mov_ixd_ded(void)   { MOV_M(IXD,DED); }
static void mov_ixd_ix(void)    { MOV_M(IXD,IX);  }
static void mov_ixd_ixd(void)   { MOV_M(IXD,IXD); }

static void cmp_rg_rg(void)     { CMP_R(RG,RG);   }
static void cmp_rg_rgd(void)    { CMP_M(RG,RGD);  }
static void cmp_rg_in(void)     { CMP_M(RG,IN);   }
static void cmp_rg_ind(void)    { CMP_M(RG,IND);  }
static void cmp_rg_de(void)     { CMP_M(RG,DE);   }
static void cmp_rg_ded(void)    { CMP_M(RG,DED);  }
static void cmp_rg_ix(void)     { CMP_M(RG,IX);   }
static void cmp_rg_ixd(void)    { CMP_M(RG,IXD);  }
static void cmp_rgd_rg(void)    { CMP_M(RGD,RG);  }
static void cmp_rgd_rgd(void)   { CMP_M(RGD,RGD); }
static void cmp_rgd_in(void)    { CMP_M(RGD,IN);  }
static void cmp_rgd_ind(void)   { CMP_M(RGD,IND); }
static void cmp_rgd_de(void)    { CMP_M(RGD,DE);  }
static void cmp_rgd_ded(void)   { CMP_M(RGD,DED); }
static void cmp_rgd_ix(void)    { CMP_M(RGD,IX);  }
static void cmp_rgd_ixd(void)   { CMP_M(RGD,IXD); }
static void cmp_in_rg(void)     { CMP_M(IN,RG);   }
static void cmp_in_rgd(void)    { CMP_M(IN,RGD);  }
static void cmp_in_in(void)     { CMP_M(IN,IN);   }
static void cmp_in_ind(void)    { CMP_M(IN,IND);  }
static void cmp_in_de(void)     { CMP_M(IN,DE);   }
static void cmp_in_ded(void)    { CMP_M(IN,DED);  }
static void cmp_in_ix(void)     { CMP_M(IN,IX);   }
static void cmp_in_ixd(void)    { CMP_M(IN,IXD);  }
static void cmp_ind_rg(void)    { CMP_M(IND,RG);  }
static void cmp_ind_rgd(void)   { CMP_M(IND,RGD); }
static void cmp_ind_in(void)    { CMP_M(IND,IN);  }
static void cmp_ind_ind(void)   { CMP_M(IND,IND); }
static void cmp_ind_de(void)    { CMP_M(IND,DE);  }
static void cmp_ind_ded(void)   { CMP_M(IND,DED); }
static void cmp_ind_ix(void)    { CMP_M(IND,IX);  }
static void cmp_ind_ixd(void)   { CMP_M(IND,IXD); }
static void cmp_de_rg(void)     { CMP_M(DE,RG);   }
static void cmp_de_rgd(void)    { CMP_M(DE,RGD);  }
static void cmp_de_in(void)     { CMP_M(DE,IN);   }
static void cmp_de_ind(void)    { CMP_M(DE,IND);  }
static void cmp_de_de(void)     { CMP_M(DE,DE);   }
static void cmp_de_ded(void)    { CMP_M(DE,DED);  }
static void cmp_de_ix(void)     { CMP_M(DE,IX);   }
static void cmp_de_ixd(void)    { CMP_M(DE,IXD);  }
static void cmp_ded_rg(void)    { CMP_M(DED,RG);  }
static void cmp_ded_rgd(void)   { CMP_M(DED,RGD); }
static void cmp_ded_in(void)    { CMP_M(DED,IN);  }
static void cmp_ded_ind(void)   { CMP_M(DED,IND); }
static void cmp_ded_de(void)    { CMP_M(DED,DE);  }
static void cmp_ded_ded(void)   { CMP_M(DED,DED); }
static void cmp_ded_ix(void)    { CMP_M(DED,IX);  }
static void cmp_ded_ixd(void)   { CMP_M(DED,IXD); }
static void cmp_ix_rg(void)     { CMP_M(IX,RG);   }
static void cmp_ix_rgd(void)    { CMP_M(IX,RGD);  }
static void cmp_ix_in(void)     { CMP_M(IX,IN);   }
static void cmp_ix_ind(void)    { CMP_M(IX,IND);  }
static void cmp_ix_de(void)     { CMP_M(IX,DE);   }
static void cmp_ix_ded(void)    { CMP_M(IX,DED);  }
static void cmp_ix_ix(void)     { CMP_M(IX,IX);   }
static void cmp_ix_ixd(void)    { CMP_M(IX,IXD);  }
static void cmp_ixd_rg(void)    { CMP_M(IXD,RG);  }
static void cmp_ixd_rgd(void)   { CMP_M(IXD,RGD); }
static void cmp_ixd_in(void)    { CMP_M(IXD,IN);  }
static void cmp_ixd_ind(void)   { CMP_M(IXD,IND); }
static void cmp_ixd_de(void)    { CMP_M(IXD,DE);  }
static void cmp_ixd_ded(void)   { CMP_M(IXD,DED); }
static void cmp_ixd_ix(void)    { CMP_M(IXD,IX);  }
static void cmp_ixd_ixd(void)   { CMP_M(IXD,IXD); }

static void bit_rg_rg(void)     { BIT_R(RG,RG);   }
static void bit_rg_rgd(void)    { BIT_M(RG,RGD);  }
static void bit_rg_in(void)     { BIT_M(RG,IN);   }
static void bit_rg_ind(void)    { BIT_M(RG,IND);  }
static void bit_rg_de(void)     { BIT_M(RG,DE);   }
static void bit_rg_ded(void)    { BIT_M(RG,DED);  }
static void bit_rg_ix(void)     { BIT_M(RG,IX);   }
static void bit_rg_ixd(void)    { BIT_M(RG,IXD);  }
static void bit_rgd_rg(void)    { BIT_M(RGD,RG);  }
static void bit_rgd_rgd(void)   { BIT_M(RGD,RGD); }
static void bit_rgd_in(void)    { BIT_M(RGD,IN);  }
static void bit_rgd_ind(void)   { BIT_M(RGD,IND); }
static void bit_rgd_de(void)    { BIT_M(RGD,DE);  }
static void bit_rgd_ded(void)   { BIT_M(RGD,DED); }
static void bit_rgd_ix(void)    { BIT_M(RGD,IX);  }
static void bit_rgd_ixd(void)   { BIT_M(RGD,IXD); }
static void bit_in_rg(void)     { BIT_M(IN,RG);   }
static void bit_in_rgd(void)    { BIT_M(IN,RGD);  }
static void bit_in_in(void)     { BIT_M(IN,IN);   }
static void bit_in_ind(void)    { BIT_M(IN,IND);  }
static void bit_in_de(void)     { BIT_M(IN,DE);   }
static void bit_in_ded(void)    { BIT_M(IN,DED);  }
static void bit_in_ix(void)     { BIT_M(IN,IX);   }
static void bit_in_ixd(void)    { BIT_M(IN,IXD);  }
static void bit_ind_rg(void)    { BIT_M(IND,RG);  }
static void bit_ind_rgd(void)   { BIT_M(IND,RGD); }
static void bit_ind_in(void)    { BIT_M(IND,IN);  }
static void bit_ind_ind(void)   { BIT_M(IND,IND); }
static void bit_ind_de(void)    { BIT_M(IND,DE);  }
static void bit_ind_ded(void)   { BIT_M(IND,DED); }
static void bit_ind_ix(void)    { BIT_M(IND,IX);  }
static void bit_ind_ixd(void)   { BIT_M(IND,IXD); }
static void bit_de_rg(void)     { BIT_M(DE,RG);   }
static void bit_de_rgd(void)    { BIT_M(DE,RGD);  }
static void bit_de_in(void)     { BIT_M(DE,IN);   }
static void bit_de_ind(void)    { BIT_M(DE,IND);  }
static void bit_de_de(void)     { BIT_M(DE,DE);   }
static void bit_de_ded(void)    { BIT_M(DE,DED);  }
static void bit_de_ix(void)     { BIT_M(DE,IX);   }
static void bit_de_ixd(void)    { BIT_M(DE,IXD);  }
static void bit_ded_rg(void)    { BIT_M(DED,RG);  }
static void bit_ded_rgd(void)   { BIT_M(DED,RGD); }
static void bit_ded_in(void)    { BIT_M(DED,IN);  }
static void bit_ded_ind(void)   { BIT_M(DED,IND); }
static void bit_ded_de(void)    { BIT_M(DED,DE);  }
static void bit_ded_ded(void)   { BIT_M(DED,DED); }
static void bit_ded_ix(void)    { BIT_M(DED,IX);  }
static void bit_ded_ixd(void)   { BIT_M(DED,IXD); }
static void bit_ix_rg(void)     { BIT_M(IX,RG);   }
static void bit_ix_rgd(void)    { BIT_M(IX,RGD);  }
static void bit_ix_in(void)     { BIT_M(IX,IN);   }
static void bit_ix_ind(void)    { BIT_M(IX,IND);  }
static void bit_ix_de(void)     { BIT_M(IX,DE);   }
static void bit_ix_ded(void)    { BIT_M(IX,DED);  }
static void bit_ix_ix(void)     { BIT_M(IX,IX);   }
static void bit_ix_ixd(void)    { BIT_M(IX,IXD);  }
static void bit_ixd_rg(void)    { BIT_M(IXD,RG);  }
static void bit_ixd_rgd(void)   { BIT_M(IXD,RGD); }
static void bit_ixd_in(void)    { BIT_M(IXD,IN);  }
static void bit_ixd_ind(void)   { BIT_M(IXD,IND); }
static void bit_ixd_de(void)    { BIT_M(IXD,DE);  }
static void bit_ixd_ded(void)   { BIT_M(IXD,DED); }
static void bit_ixd_ix(void)    { BIT_M(IXD,IX);  }
static void bit_ixd_ixd(void)   { BIT_M(IXD,IXD); }

static void bic_rg_rg(void)     { BIC_R(RG,RG);   }
static void bic_rg_rgd(void)    { BIC_M(RG,RGD);  }
static void bic_rg_in(void)     { BIC_M(RG,IN);   }
static void bic_rg_ind(void)    { BIC_M(RG,IND);  }
static void bic_rg_de(void)     { BIC_M(RG,DE);   }
static void bic_rg_ded(void)    { BIC_M(RG,DED);  }
static void bic_rg_ix(void)     { BIC_M(RG,IX);   }
static void bic_rg_ixd(void)    { BIC_M(RG,IXD);  }
static void bic_rgd_rg(void)    { BIC_X(RGD,RG);  }
static void bic_rgd_rgd(void)   { BIC_M(RGD,RGD); }
static void bic_rgd_in(void)    { BIC_M(RGD,IN);  }
static void bic_rgd_ind(void)   { BIC_M(RGD,IND); }
static void bic_rgd_de(void)    { BIC_M(RGD,DE);  }
static void bic_rgd_ded(void)   { BIC_M(RGD,DED); }
static void bic_rgd_ix(void)    { BIC_M(RGD,IX);  }
static void bic_rgd_ixd(void)   { BIC_M(RGD,IXD); }
static void bic_in_rg(void)     { BIC_X(IN,RG);   }
static void bic_in_rgd(void)    { BIC_M(IN,RGD);  }
static void bic_in_in(void)     { BIC_M(IN,IN);   }
static void bic_in_ind(void)    { BIC_M(IN,IND);  }
static void bic_in_de(void)     { BIC_M(IN,DE);   }
static void bic_in_ded(void)    { BIC_M(IN,DED);  }
static void bic_in_ix(void)     { BIC_M(IN,IX);   }
static void bic_in_ixd(void)    { BIC_M(IN,IXD);  }
static void bic_ind_rg(void)    { BIC_X(IND,RG);  }
static void bic_ind_rgd(void)   { BIC_M(IND,RGD); }
static void bic_ind_in(void)    { BIC_M(IND,IN);  }
static void bic_ind_ind(void)   { BIC_M(IND,IND); }
static void bic_ind_de(void)    { BIC_M(IND,DE);  }
static void bic_ind_ded(void)   { BIC_M(IND,DED); }
static void bic_ind_ix(void)    { BIC_M(IND,IX);  }
static void bic_ind_ixd(void)   { BIC_M(IND,IXD); }
static void bic_de_rg(void)     { BIC_X(DE,RG);   }
static void bic_de_rgd(void)    { BIC_M(DE,RGD);  }
static void bic_de_in(void)     { BIC_M(DE,IN);   }
static void bic_de_ind(void)    { BIC_M(DE,IND);  }
static void bic_de_de(void)     { BIC_M(DE,DE);   }
static void bic_de_ded(void)    { BIC_M(DE,DED);  }
static void bic_de_ix(void)     { BIC_M(DE,IX);   }
static void bic_de_ixd(void)    { BIC_M(DE,IXD);  }
static void bic_ded_rg(void)    { BIC_X(DED,RG);  }
static void bic_ded_rgd(void)   { BIC_M(DED,RGD); }
static void bic_ded_in(void)    { BIC_M(DED,IN);  }
static void bic_ded_ind(void)   { BIC_M(DED,IND); }
static void bic_ded_de(void)    { BIC_M(DED,DE);  }
static void bic_ded_ded(void)   { BIC_M(DED,DED); }
static void bic_ded_ix(void)    { BIC_M(DED,IX);  }
static void bic_ded_ixd(void)   { BIC_M(DED,IXD); }
static void bic_ix_rg(void)     { BIC_X(IX,RG);   }
static void bic_ix_rgd(void)    { BIC_M(IX,RGD);  }
static void bic_ix_in(void)     { BIC_M(IX,IN);   }
static void bic_ix_ind(void)    { BIC_M(IX,IND);  }
static void bic_ix_de(void)     { BIC_M(IX,DE);   }
static void bic_ix_ded(void)    { BIC_M(IX,DED);  }
static void bic_ix_ix(void)     { BIC_M(IX,IX);   }
static void bic_ix_ixd(void)    { BIC_M(IX,IXD);  }
static void bic_ixd_rg(void)    { BIC_X(IXD,RG);  }
static void bic_ixd_rgd(void)   { BIC_M(IXD,RGD); }
static void bic_ixd_in(void)    { BIC_M(IXD,IN);  }
static void bic_ixd_ind(void)   { BIC_M(IXD,IND); }
static void bic_ixd_de(void)    { BIC_M(IXD,DE);  }
static void bic_ixd_ded(void)   { BIC_M(IXD,DED); }
static void bic_ixd_ix(void)    { BIC_M(IXD,IX);  }
static void bic_ixd_ixd(void)   { BIC_M(IXD,IXD); }

static void bis_rg_rg(void)     { BIS_R(RG,RG);   }
static void bis_rg_rgd(void)    { BIS_M(RG,RGD);  }
static void bis_rg_in(void)     { BIS_M(RG,IN);   }
static void bis_rg_ind(void)    { BIS_M(RG,IND);  }
static void bis_rg_de(void)     { BIS_M(RG,DE);   }
static void bis_rg_ded(void)    { BIS_M(RG,DED);  }
static void bis_rg_ix(void)     { BIS_M(RG,IX);   }
static void bis_rg_ixd(void)    { BIS_M(RG,IXD);  }