t11ops.c

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

static void tstb_ded(void)      { TSTB_M(DED); }
static void tstb_ix(void)       { TSTB_M(IX);  }
static void tstb_ixd(void)      { TSTB_M(IXD); }

static void rorb_rg(void)       { RORB_R(RG);  }
static void rorb_rgd(void)      { RORB_M(RGD); }
static void rorb_in(void)       { RORB_M(IN);  }
static void rorb_ind(void)      { RORB_M(IND); }
static void rorb_de(void)       { RORB_M(DE);  }
static void rorb_ded(void)      { RORB_M(DED); }
static void rorb_ix(void)       { RORB_M(IX);  }
static void rorb_ixd(void)      { RORB_M(IXD); }

static void rolb_rg(void)       { ROLB_R(RG);  }
static void rolb_rgd(void)      { ROLB_M(RGD); }
static void rolb_in(void)       { ROLB_M(IN);  }
static void rolb_ind(void)      { ROLB_M(IND); }
static void rolb_de(void)       { ROLB_M(DE);  }
static void rolb_ded(void)      { ROLB_M(DED); }
static void rolb_ix(void)       { ROLB_M(IX);  }
static void rolb_ixd(void)      { ROLB_M(IXD); }

static void asrb_rg(void)       { ASRB_R(RG);  }
static void asrb_rgd(void)      { ASRB_M(RGD); }
static void asrb_in(void)       { ASRB_M(IN);  }
static void asrb_ind(void)      { ASRB_M(IND); }
static void asrb_de(void)       { ASRB_M(DE);  }
static void asrb_ded(void)      { ASRB_M(DED); }
static void asrb_ix(void)       { ASRB_M(IX);  }
static void asrb_ixd(void)      { ASRB_M(IXD); }

static void aslb_rg(void)       { ASLB_R(RG);  }
static void aslb_rgd(void)      { ASLB_M(RGD); }
static void aslb_in(void)       { ASLB_M(IN);  }
static void aslb_ind(void)      { ASLB_M(IND); }
static void aslb_de(void)       { ASLB_M(DE);  }
static void aslb_ded(void)      { ASLB_M(DED); }
static void aslb_ix(void)       { ASLB_M(IX);  }
static void aslb_ixd(void)      { ASLB_M(IXD); }

static void mtps_rg(void)       { MTPS_R(RG);  }
static void mtps_rgd(void)      { MTPS_M(RGD); }
static void mtps_in(void)       { MTPS_M(IN);  }
static void mtps_ind(void)      { MTPS_M(IND); }
static void mtps_de(void)       { MTPS_M(DE);  }
static void mtps_ded(void)      { MTPS_M(DED); }
static void mtps_ix(void)       { MTPS_M(IX);  }
static void mtps_ixd(void)      { MTPS_M(IXD); }

static void mfps_rg(void)       { MFPS_R(RG);  }
static void mfps_rgd(void)      { MFPS_M(RGD); }
static void mfps_in(void)       { MFPS_M(IN);  }
static void mfps_ind(void)      { MFPS_M(IND); }
static void mfps_de(void)       { MFPS_M(DE);  }
static void mfps_ded(void)      { MFPS_M(DED); }
static void mfps_ix(void)       { MFPS_M(IX);  }
static void mfps_ixd(void)      { MFPS_M(IXD); }

static void movb_rg_rg(void)     { MOVB_R(RG,RG);   }
static void movb_rg_rgd(void)    { MOVB_M(RG,RGD);  }
static void movb_rg_in(void)     { MOVB_M(RG,IN);   }
static void movb_rg_ind(void)    { MOVB_M(RG,IND);  }
static void movb_rg_de(void)     { MOVB_M(RG,DE);   }
static void movb_rg_ded(void)    { MOVB_M(RG,DED);  }
static void movb_rg_ix(void)     { MOVB_M(RG,IX);   }
static void movb_rg_ixd(void)    { MOVB_M(RG,IXD);  }
static void movb_rgd_rg(void)    { MOVB_X(RGD,RG);  }
static void movb_rgd_rgd(void)   { MOVB_M(RGD,RGD); }
static void movb_rgd_in(void)    { MOVB_M(RGD,IN);  }
static void movb_rgd_ind(void)   { MOVB_M(RGD,IND); }
static void movb_rgd_de(void)    { MOVB_M(RGD,DE);  }
static void movb_rgd_ded(void)   { MOVB_M(RGD,DED); }
static void movb_rgd_ix(void)    { MOVB_M(RGD,IX);  }
static void movb_rgd_ixd(void)   { MOVB_M(RGD,IXD); }
static void movb_in_rg(void)     { MOVB_X(IN,RG);   }
static void movb_in_rgd(void)    { MOVB_M(IN,RGD);  }
static void movb_in_in(void)     { MOVB_M(IN,IN);   }
static void movb_in_ind(void)    { MOVB_M(IN,IND);  }
static void movb_in_de(void)     { MOVB_M(IN,DE);   }
static void movb_in_ded(void)    { MOVB_M(IN,DED);  }
static void movb_in_ix(void)     { MOVB_M(IN,IX);   }
static void movb_in_ixd(void)    { MOVB_M(IN,IXD);  }
static void movb_ind_rg(void)    { MOVB_X(IND,RG);  }
static void movb_ind_rgd(void)   { MOVB_M(IND,RGD); }
static void movb_ind_in(void)    { MOVB_M(IND,IN);  }
static void movb_ind_ind(void)   { MOVB_M(IND,IND); }
static void movb_ind_de(void)    { MOVB_M(IND,DE);  }
static void movb_ind_ded(void)   { MOVB_M(IND,DED); }
static void movb_ind_ix(void)    { MOVB_M(IND,IX);  }
static void movb_ind_ixd(void)   { MOVB_M(IND,IXD); }
static void movb_de_rg(void)     { MOVB_X(DE,RG);   }
static void movb_de_rgd(void)    { MOVB_M(DE,RGD);  }
static void movb_de_in(void)     { MOVB_M(DE,IN);   }
static void movb_de_ind(void)    { MOVB_M(DE,IND);  }
static void movb_de_de(void)     { MOVB_M(DE,DE);   }
static void movb_de_ded(void)    { MOVB_M(DE,DED);  }
static void movb_de_ix(void)     { MOVB_M(DE,IX);   }
static void movb_de_ixd(void)    { MOVB_M(DE,IXD);  }
static void movb_ded_rg(void)    { MOVB_X(DED,RG);  }
static void movb_ded_rgd(void)   { MOVB_M(DED,RGD); }
static void movb_ded_in(void)    { MOVB_M(DED,IN);  }
static void movb_ded_ind(void)   { MOVB_M(DED,IND); }
static void movb_ded_de(void)    { MOVB_M(DED,DE);  }
static void movb_ded_ded(void)   { MOVB_M(DED,DED); }
static void movb_ded_ix(void)    { MOVB_M(DED,IX);  }
static void movb_ded_ixd(void)   { MOVB_M(DED,IXD); }
static void movb_ix_rg(void)     { MOVB_X(IX,RG);   }
static void movb_ix_rgd(void)    { MOVB_M(IX,RGD);  }
static void movb_ix_in(void)     { MOVB_M(IX,IN);   }
static void movb_ix_ind(void)    { MOVB_M(IX,IND);  }
static void movb_ix_de(void)     { MOVB_M(IX,DE);   }
static void movb_ix_ded(void)    { MOVB_M(IX,DED);  }
static void movb_ix_ix(void)     { MOVB_M(IX,IX);   }
static void movb_ix_ixd(void)    { MOVB_M(IX,IXD);  }
static void movb_ixd_rg(void)    { MOVB_X(IXD,RG);  }
static void movb_ixd_rgd(void)   { MOVB_M(IXD,RGD); }
static void movb_ixd_in(void)    { MOVB_M(IXD,IN);  }
static void movb_ixd_ind(void)   { MOVB_M(IXD,IND); }
static void movb_ixd_de(void)    { MOVB_M(IXD,DE);  }
static void movb_ixd_ded(void)   { MOVB_M(IXD,DED); }
static void movb_ixd_ix(void)    { MOVB_M(IXD,IX);  }
static void movb_ixd_ixd(void)   { MOVB_M(IXD,IXD); }

static void cmpb_rg_rg(void)     { CMPB_R(RG,RG);   }
static void cmpb_rg_rgd(void)    { CMPB_M(RG,RGD);  }
static void cmpb_rg_in(void)     { CMPB_M(RG,IN);   }
static void cmpb_rg_ind(void)    { CMPB_M(RG,IND);  }
static void cmpb_rg_de(void)     { CMPB_M(RG,DE);   }
static void cmpb_rg_ded(void)    { CMPB_M(RG,DED);  }
static void cmpb_rg_ix(void)     { CMPB_M(RG,IX);   }
static void cmpb_rg_ixd(void)    { CMPB_M(RG,IXD);  }
static void cmpb_rgd_rg(void)    { CMPB_M(RGD,RG);  }
static void cmpb_rgd_rgd(void)   { CMPB_M(RGD,RGD); }
static void cmpb_rgd_in(void)    { CMPB_M(RGD,IN);  }
static void cmpb_rgd_ind(void)   { CMPB_M(RGD,IND); }
static void cmpb_rgd_de(void)    { CMPB_M(RGD,DE);  }
static void cmpb_rgd_ded(void)   { CMPB_M(RGD,DED); }
static void cmpb_rgd_ix(void)    { CMPB_M(RGD,IX);  }
static void cmpb_rgd_ixd(void)   { CMPB_M(RGD,IXD); }
static void cmpb_in_rg(void)     { CMPB_M(IN,RG);   }
static void cmpb_in_rgd(void)    { CMPB_M(IN,RGD);  }
static void cmpb_in_in(void)     { CMPB_M(IN,IN);   }
static void cmpb_in_ind(void)    { CMPB_M(IN,IND);  }
static void cmpb_in_de(void)     { CMPB_M(IN,DE);   }
static void cmpb_in_ded(void)    { CMPB_M(IN,DED);  }
static void cmpb_in_ix(void)     { CMPB_M(IN,IX);   }
static void cmpb_in_ixd(void)    { CMPB_M(IN,IXD);  }
static void cmpb_ind_rg(void)    { CMPB_M(IND,RG);  }
static void cmpb_ind_rgd(void)   { CMPB_M(IND,RGD); }
static void cmpb_ind_in(void)    { CMPB_M(IND,IN);  }
static void cmpb_ind_ind(void)   { CMPB_M(IND,IND); }
static void cmpb_ind_de(void)    { CMPB_M(IND,DE);  }
static void cmpb_ind_ded(void)   { CMPB_M(IND,DED); }
static void cmpb_ind_ix(void)    { CMPB_M(IND,IX);  }
static void cmpb_ind_ixd(void)   { CMPB_M(IND,IXD); }
static void cmpb_de_rg(void)     { CMPB_M(DE,RG);   }
static void cmpb_de_rgd(void)    { CMPB_M(DE,RGD);  }
static void cmpb_de_in(void)     { CMPB_M(DE,IN);   }
static void cmpb_de_ind(void)    { CMPB_M(DE,IND);  }
static void cmpb_de_de(void)     { CMPB_M(DE,DE);   }
static void cmpb_de_ded(void)    { CMPB_M(DE,DED);  }
static void cmpb_de_ix(void)     { CMPB_M(DE,IX);   }
static void cmpb_de_ixd(void)    { CMPB_M(DE,IXD);  }
static void cmpb_ded_rg(void)    { CMPB_M(DED,RG);  }
static void cmpb_ded_rgd(void)   { CMPB_M(DED,RGD); }
static void cmpb_ded_in(void)    { CMPB_M(DED,IN);  }
static void cmpb_ded_ind(void)   { CMPB_M(DED,IND); }
static void cmpb_ded_de(void)    { CMPB_M(DED,DE);  }
static void cmpb_ded_ded(void)   { CMPB_M(DED,DED); }
static void cmpb_ded_ix(void)    { CMPB_M(DED,IX);  }
static void cmpb_ded_ixd(void)   { CMPB_M(DED,IXD); }
static void cmpb_ix_rg(void)     { CMPB_M(IX,RG);   }
static void cmpb_ix_rgd(void)    { CMPB_M(IX,RGD);  }
static void cmpb_ix_in(void)     { CMPB_M(IX,IN);   }
static void cmpb_ix_ind(void)    { CMPB_M(IX,IND);  }
static void cmpb_ix_de(void)     { CMPB_M(IX,DE);   }
static void cmpb_ix_ded(void)    { CMPB_M(IX,DED);  }
static void cmpb_ix_ix(void)     { CMPB_M(IX,IX);   }
static void cmpb_ix_ixd(void)    { CMPB_M(IX,IXD);  }
static void cmpb_ixd_rg(void)    { CMPB_M(IXD,RG);  }
static void cmpb_ixd_rgd(void)   { CMPB_M(IXD,RGD); }
static void cmpb_ixd_in(void)    { CMPB_M(IXD,IN);  }
static void cmpb_ixd_ind(void)   { CMPB_M(IXD,IND); }
static void cmpb_ixd_de(void)    { CMPB_M(IXD,DE);  }
static void cmpb_ixd_ded(void)   { CMPB_M(IXD,DED); }
static void cmpb_ixd_ix(void)    { CMPB_M(IXD,IX);  }
static void cmpb_ixd_ixd(void)   { CMPB_M(IXD,IXD); }

static void bitb_rg_rg(void)     { BITB_R(RG,RG);   }
static void bitb_rg_rgd(void)    { BITB_M(RG,RGD);  }
static void bitb_rg_in(void)     { BITB_M(RG,IN);   }
static void bitb_rg_ind(void)    { BITB_M(RG,IND);  }
static void bitb_rg_de(void)     { BITB_M(RG,DE);   }
static void bitb_rg_ded(void)    { BITB_M(RG,DED);  }
static void bitb_rg_ix(void)     { BITB_M(RG,IX);   }
static void bitb_rg_ixd(void)    { BITB_M(RG,IXD);  }
static void bitb_rgd_rg(void)    { BITB_M(RGD,RG);  }
static void bitb_rgd_rgd(void)   { BITB_M(RGD,RGD); }
static void bitb_rgd_in(void)    { BITB_M(RGD,IN);  }
static void bitb_rgd_ind(void)   { BITB_M(RGD,IND); }
static void bitb_rgd_de(void)    { BITB_M(RGD,DE);  }
static void bitb_rgd_ded(void)   { BITB_M(RGD,DED); }
static void bitb_rgd_ix(void)    { BITB_M(RGD,IX);  }
static void bitb_rgd_ixd(void)   { BITB_M(RGD,IXD); }
static void bitb_in_rg(void)     { BITB_M(IN,RG);   }
static void bitb_in_rgd(void)    { BITB_M(IN,RGD);  }
static void bitb_in_in(void)     { BITB_M(IN,IN);   }
static void bitb_in_ind(void)    { BITB_M(IN,IND);  }
static void bitb_in_de(void)     { BITB_M(IN,DE);   }
static void bitb_in_ded(void)    { BITB_M(IN,DED);  }
static void bitb_in_ix(void)     { BITB_M(IN,IX);   }
static void bitb_in_ixd(void)    { BITB_M(IN,IXD);  }
static void bitb_ind_rg(void)    { BITB_M(IND,RG);  }
static void bitb_ind_rgd(void)   { BITB_M(IND,RGD); }
static void bitb_ind_in(void)    { BITB_M(IND,IN);  }
static void bitb_ind_ind(void)   { BITB_M(IND,IND); }
static void bitb_ind_de(void)    { BITB_M(IND,DE);  }
static void bitb_ind_ded(void)   { BITB_M(IND,DED); }
static void bitb_ind_ix(void)    { BITB_M(IND,IX);  }
static void bitb_ind_ixd(void)   { BITB_M(IND,IXD); }
static void bitb_de_rg(void)     { BITB_M(DE,RG);   }
static void bitb_de_rgd(void)    { BITB_M(DE,RGD);  }
static void bitb_de_in(void)     { BITB_M(DE,IN);   }
static void bitb_de_ind(void)    { BITB_M(DE,IND);  }
static void bitb_de_de(void)     { BITB_M(DE,DE);   }
static void bitb_de_ded(void)    { BITB_M(DE,DED);  }
static void bitb_de_ix(void)     { BITB_M(DE,IX);   }
static void bitb_de_ixd(void)    { BITB_M(DE,IXD);  }
static void bitb_ded_rg(void)    { BITB_M(DED,RG);  }
static void bitb_ded_rgd(void)   { BITB_M(DED,RGD); }
static void bitb_ded_in(void)    { BITB_M(DED,IN);  }
static void bitb_ded_ind(void)