⭐ 欢迎来到虫虫下载站！ | 📦 资源下载 📁 资源专辑 ℹ️ 关于我们
⭐ 虫虫下载站
📤 上传资源

📄 t11ops.c

📁 这个是延伸mame的在wince平台下的游戏模拟器的代码
💻 C
📖 第 1 页 / 共 5 页
字号:
🔍
12345 
/* SWAB: dst = (dst >> 8) + (dst << 8) */
#define SWAB_R(d)   int dreg, dest, result;     GET_DW_##d; CLR_NZVC; result = ((dest >> 8) & 0xff) + (dest << 8); SETB_NZ; PUT_DW_DREG(result)
#define SWAB_M(d)   int dreg, dest, result, ea; GET_DW_##d; CLR_NZVC; result = ((dest >> 8) & 0xff) + (dest << 8); SETB_NZ; PUT_DW_EA(result)
/* SXT: dst = sign-extend dst */
#define SXT_R(d)    int dreg, result;     CLR_ZV; if (GET_N) result = -1; else { result = 0; SET_Z; } PUT_DW_##d(result)
#define SXT_M(d)    int dreg, result, ea; CLR_ZV; if (GET_N) result = -1; else { result = 0; SET_Z; } PUT_DW_##d(result)
/* TST: dst = ~dst */
#define TST_R(d)    int dreg, dest, result;     GET_DW_##d; CLR_NZVC; result = dest; SETW_NZ;
#define TST_M(d)    int dreg, dest, result, ea; GET_DW_##d; CLR_NZVC; result = dest; SETW_NZ;
#define TSTB_R(d)   int dreg, dest, result;     GET_DB_##d; CLR_NZVC; result = dest; SETB_NZ;
#define TSTB_M(d)   int dreg, dest, result, ea; GET_DB_##d; CLR_NZVC; result = dest; SETB_NZ;
/* XOR: dst ^= src */
#define XOR_R(d)    int sreg, dreg, source, dest, result;     GET_SREG; source = REGW(sreg); GET_DW_##d; CLR_NZV; result = dest ^ source; SETW_NZ; PUT_DW_DREG(result)
#define XOR_M(d)    int sreg, dreg, source, dest, result, ea; GET_SREG; source = REGW(sreg); GET_DW_##d; CLR_NZV; result = dest ^ source; SETW_NZ; PUT_DW_EA(result)



static void op_0000(void)
{
	switch (state.op & 0x3f)
	{
		case 0x00:	/* HALT  */ t11_ICount = 0; break;
		case 0x01:	/* WAIT  */ state.pending_interrupts |= T11_WAIT; t11_ICount = 0; break;
		case 0x02:	/* RTI   */ PC = POP(); PSW = POP(); break;
		case 0x03:	/* BPT   */ PUSH(PSW); PUSH(PC); PC = RWORD (0x0c); PSW = RWORD (0x0e); break;
		case 0x04:	/* IOT   */ PUSH(PSW); PUSH(PC); PC = RWORD (0x10); PSW = RWORD (0x12); break;
		case 0x05:	/* RESET */ break;
		case 0x06:	/* RTT   */ PC = POP(); PSW = POP(); break;
		default: 	illegal (); break;
	}
}

static void illegal(void)
{
	PUSH(PSW);
	PUSH(PC);
	PC = RWORD(0x08);
	PSW = RWORD(0x0a);
PC = 0;
}

static void jmp_rgd(void)       { JMP(RGD); }
static void jmp_in(void)        { JMP(IN);  }
static void jmp_ind(void)       { JMP(IND); }
static void jmp_de(void)        { JMP(DE);  }
static void jmp_ded(void)       { JMP(DED); }
static void jmp_ix(void)        { JMP(IX);  }
static void jmp_ixd(void)       { JMP(IXD); }

static void rts(void)
{
	int dreg; 
	GET_DREG; 
	PC = REGD(dreg); 
	REGW(dreg) = POP(); 
}

static void ccc(void)           { PSW &= ~(state.op & 15); }
static void scc(void)           { PSW |=  (state.op & 15); }

static void swab_rg(void)       { SWAB_R(RG); }
static void swab_rgd(void)      { SWAB_M(RGD); }
static void swab_in(void)       { SWAB_M(IN); }
static void swab_ind(void)      { SWAB_M(IND); }
static void swab_de(void)       { SWAB_M(DE); }
static void swab_ded(void)      { SWAB_M(DED); }
static void swab_ix(void)       { SWAB_M(IX); }
static void swab_ixd(void)      { SWAB_M(IXD); }

static void br(void)            { BR(1); }
static void bne(void)           { BR(!GET_Z); }
static void beq(void)           { BR( GET_Z); }
static void bge(void)           { BR(!((GET_N >> 2) ^ GET_V)); }
static void blt(void)           { BR( ((GET_N >> 2) ^ GET_V)); }
static void bgt(void)           { BR(!GET_Z && !((GET_N >> 2) ^ GET_V)); }
static void ble(void)           { BR( GET_Z ||  ((GET_N >> 2) ^ GET_V)); }

static void jsr_rgd(void)       { JSR(RGD); }
static void jsr_in(void)        { JSR(IN);  }
static void jsr_ind(void)       { JSR(IND); }
static void jsr_de(void)        { JSR(DE);  }
static void jsr_ded(void)       { JSR(DED); }
static void jsr_ix(void)        { JSR(IX);  }
static void jsr_ixd(void)       { JSR(IXD); }

static void clr_rg(void)        { CLR_R(RG);  }
static void clr_rgd(void)       { CLR_M(RGD); }
static void clr_in(void)        { CLR_M(IN);  }
static void clr_ind(void)       { CLR_M(IND); }
static void clr_de(void)        { CLR_M(DE);  }
static void clr_ded(void)       { CLR_M(DED); }
static void clr_ix(void)        { CLR_M(IX);  }
static void clr_ixd(void)       { CLR_M(IXD); }

static void com_rg(void)        { COM_R(RG);  }
static void com_rgd(void)       { COM_M(RGD); }
static void com_in(void)        { COM_M(IN);  }
static void com_ind(void)       { COM_M(IND); }
static void com_de(void)        { COM_M(DE);  }
static void com_ded(void)       { COM_M(DED); }
static void com_ix(void)        { COM_M(IX);  }
static void com_ixd(void)       { COM_M(IXD); }

static void inc_rg(void)        { INC_R(RG);  }
static void inc_rgd(void)       { INC_M(RGD); }
static void inc_in(void)        { INC_M(IN);  }
static void inc_ind(void)       { INC_M(IND); }
static void inc_de(void)        { INC_M(DE);  }
static void inc_ded(void)       { INC_M(DED); }
static void inc_ix(void)        { INC_M(IX);  }
static void inc_ixd(void)       { INC_M(IXD); }

static void dec_rg(void)        { DEC_R(RG);  }
static void dec_rgd(void)       { DEC_M(RGD); }
static void dec_in(void)        { DEC_M(IN);  }
static void dec_ind(void)       { DEC_M(IND); }
static void dec_de(void)        { DEC_M(DE);  }
static void dec_ded(void)       { DEC_M(DED); }
static void dec_ix(void)        { DEC_M(IX);  }
static void dec_ixd(void)       { DEC_M(IXD); }

static void neg_rg(void)        { NEG_R(RG);  }
static void neg_rgd(void)       { NEG_M(RGD); }
static void neg_in(void)        { NEG_M(IN);  }
static void neg_ind(void)       { NEG_M(IND); }
static void neg_de(void)        { NEG_M(DE);  }
static void neg_ded(void)       { NEG_M(DED); }
static void neg_ix(void)        { NEG_M(IX);  }
static void neg_ixd(void)       { NEG_M(IXD); }

static void adc_rg(void)        { ADC_R(RG);  }
static void adc_rgd(void)       { ADC_M(RGD); }
static void adc_in(void)        { ADC_M(IN);  }
static void adc_ind(void)       { ADC_M(IND); }
static void adc_de(void)        { ADC_M(DE);  }
static void adc_ded(void)       { ADC_M(DED); }
static void adc_ix(void)        { ADC_M(IX);  }
static void adc_ixd(void)       { ADC_M(IXD); }

static void sbc_rg(void)        { SBC_R(RG);  }
static void sbc_rgd(void)       { SBC_M(RGD); }
static void sbc_in(void)        { SBC_M(IN);  }
static void sbc_ind(void)       { SBC_M(IND); }
static void sbc_de(void)        { SBC_M(DE);  }
static void sbc_ded(void)       { SBC_M(DED); }
static void sbc_ix(void)        { SBC_M(IX);  }
static void sbc_ixd(void)       { SBC_M(IXD); }

static void tst_rg(void)        { TST_R(RG);  }
static void tst_rgd(void)       { TST_M(RGD); }
static void tst_in(void)        { TST_M(IN);  }
static void tst_ind(void)       { TST_M(IND); }
static void tst_de(void)        { TST_M(DE);  }
static void tst_ded(void)       { TST_M(DED); }
static void tst_ix(void)        { TST_M(IX);  }
static void tst_ixd(void)       { TST_M(IXD); }

static void ror_rg(void)        { ROR_R(RG);  }
static void ror_rgd(void)       { ROR_M(RGD); }
static void ror_in(void)        { ROR_M(IN);  }
static void ror_ind(void)       { ROR_M(IND); }
static void ror_de(void)        { ROR_M(DE);  }
static void ror_ded(void)       { ROR_M(DED); }
static void ror_ix(void)        { ROR_M(IX);  }
static void ror_ixd(void)       { ROR_M(IXD); }

static void rol_rg(void)        { ROL_R(RG);  }
static void rol_rgd(void)       { ROL_M(RGD); }
static void rol_in(void)        { ROL_M(IN);  }
static void rol_ind(void)       { ROL_M(IND); }
static void rol_de(void)        { ROL_M(DE);  }
static void rol_ded(void)       { ROL_M(DED); }
static void rol_ix(void)        { ROL_M(IX);  }
static void rol_ixd(void)       { ROL_M(IXD); }

static void asr_rg(void)        { ASR_R(RG);  }
static void asr_rgd(void)       { ASR_M(RGD); }
static void asr_in(void)        { ASR_M(IN);  }
static void asr_ind(void)       { ASR_M(IND); }
static void asr_de(void)        { ASR_M(DE);  }
static void asr_ded(void)       { ASR_M(DED); }
static void asr_ix(void)        { ASR_M(IX);  }
static void asr_ixd(void)       { ASR_M(IXD); }

static void asl_rg(void)        { ASL_R(RG);  }
static void asl_rgd(void)       { ASL_M(RGD); }
static void asl_in(void)        { ASL_M(IN);  }
static void asl_ind(void)       { ASL_M(IND); }
static void asl_de(void)        { ASL_M(DE);  }
static void asl_ded(void)       { ASL_M(DED); }
static void asl_ix(void)        { ASL_M(IX);  }
static void asl_ixd(void)       { ASL_M(IXD); }

static void sxt_rg(void)        { SXT_R(RG);  }
static void sxt_rgd(void)       { SXT_M(RGD); }
static void sxt_in(void)        { SXT_M(IN);  }
static void sxt_ind(void)       { SXT_M(IND); }
static void sxt_de(void)        { SXT_M(DE);  }
static void sxt_ded(void)       { SXT_M(DED); }
static void sxt_ix(void)        { SXT_M(IX);  }
static void sxt_ixd(void)       { SXT_M(IXD); }

static void mov_rg_rg(void)     { MOV_R(RG,RG);   }
static void mov_rg_rgd(void)    { MOV_M(RG,RGD);  }
static void mov_rg_in(void)     { MOV_M(RG,IN);   }
static void mov_rg_ind(void)    { MOV_M(RG,IND);  }
static void mov_rg_de(void)     { MOV_M(RG,DE);   }
static void mov_rg_ded(void)    { MOV_M(RG,DED);  }
static void mov_rg_ix(void)     { MOV_M(RG,IX);   }
static void mov_rg_ixd(void)    { MOV_M(RG,IXD);  }
static void mov_rgd_rg(void)    { MOV_M(RGD,RG);  }
static void mov_rgd_rgd(void)   { MOV_M(RGD,RGD); }
static void mov_rgd_in(void)    { MOV_M(RGD,IN);  }
static void mov_rgd_ind(void)   { MOV_M(RGD,IND); }
static void mov_rgd_de(void)    { MOV_M(RGD,DE);  }
static void mov_rgd_ded(void)   { MOV_M(RGD,DED); }
static void mov_rgd_ix(void)    { MOV_M(RGD,IX);  }
static void mov_rgd_ixd(void)   { MOV_M(RGD,IXD); }
static void mov_in_rg(void)     { MOV_M(IN,RG);   }
static void mov_in_rgd(void)    { MOV_M(IN,RGD);  }
static void mov_in_in(void)     { MOV_M(IN,IN);   }
static void mov_in_ind(void)    { MOV_M(IN,IND);  }
static void mov_in_de(void)     { MOV_M(IN,DE);   }
static void mov_in_ded(void)    { MOV_M(IN,DED);  }
static void mov_in_ix(void)     { MOV_M(IN,IX);   }
static void mov_in_ixd(void)    { MOV_M(IN,IXD);  }
static void mov_ind_rg(void)    { MOV_M(IND,RG);  }
static void mov_ind_rgd(void)   { MOV_M(IND,RGD); }
static void mov_ind_in(void)    { MOV_M(IND,IN);  }
static void mov_ind_ind(void)   { MOV_M(IND,IND); }
static void mov_ind_de(void)    { MOV_M(IND,DE);  }
static void mov_ind_ded(void)   { MOV_M(IND,DED); }
static void mov_ind_ix(void)    { MOV_M(IND,IX);  }
static void mov_ind_ixd(void)   { MOV_M(IND,IXD); }
static void mov_de_rg(void)     { MOV_M(DE,RG);   }
12345

⌨️ 快捷键说明

复制代码 Ctrl + C
搜索代码 Ctrl + F
全屏模式 F11
切换主题 Ctrl + Shift + D
显示快捷键 ?
增大字号 Ctrl + =
减小字号 Ctrl + -