zz80.c

DGen源码最后版本

			Bit(m_regH, 3);
			return 8;
		
		case 0x5D: // bit_3_l
			Bit(m_regL, 3);
			return 8;
		
		case 0x5E: // bit_3_xhl
			Bit(MemReadByte(m_regHL), 3);
			return 12;
		
		case 0x5F: // bit_3_a
			Bit(m_regA, 3);
			return 8;

		case 0x60: // bit_4_b
			Bit(m_regB, 4);
			return 8;
		
		case 0x61: // bit_4_c
			Bit(m_regC, 4);
			return 8;
		
		case 0x62: // bit_4_d
			Bit(m_regD, 4);
			return 8;
		
		case 0x63: // bit_4_e
			Bit(m_regE, 4);
			return 8;
		
		case 0x64: // bit_4_h
			Bit(m_regH, 4);
			return 8;
		
		case 0x65: // bit_4_l
			Bit(m_regL, 4);
			return 8;
		
		case 0x66: // bit_4_xhl
			Bit(MemReadByte(m_regHL), 4);
			return 12;
		
		case 0x67: // bit_4_a
			Bit(m_regA, 4);
			return 8;

		case 0x68: // bit_5_b
			Bit(m_regB, 5);
			return 8;
		
		case 0x69: // bit_5_c
			Bit(m_regC, 5);
			return 8;
		
		case 0x6A: // bit_5_d
			Bit(m_regD, 5);
			return 8;
		
		case 0x6B: // bit_5_e
			Bit(m_regE, 5);
			return 8;
		
		case 0x6C: // bit_5_h
			Bit(m_regH, 5);
			return 8;
		
		case 0x6D: // bit_5_l
			Bit(m_regL, 5);
			return 8;
		
		case 0x6E: // bit_5_xhl
			Bit(MemReadByte(m_regHL), 5);
			return 12;
		
		case 0x6F: // bit_5_a
			Bit(m_regA, 5);
			return 8;

		case 0x70: // bit_6_b
			Bit(m_regB, 6);
			return 8;
		
		case 0x71: // bit_6_c
			Bit(m_regC, 6);
			return 8;
		
		case 0x72: // bit_6_d
			Bit(m_regD, 6);
			return 8;
		
		case 0x73: // bit_6_e
			Bit(m_regE, 6);
			return 8;
		
		case 0x74: // bit_6_h
			Bit(m_regH, 6);
			return 8;
		
		case 0x75: // bit_6_l
			Bit(m_regL, 6);
			return 8;
		
		case 0x76: // bit_6_xhl
			Bit(MemReadByte(m_regHL), 6);
			return 12;
		
		case 0x77: // bit_6_a
			Bit(m_regA, 6);
			return 8;

		case 0x78: // bit_7_b
			Bit(m_regB, 7);
			return 8;
		
		case 0x79: // bit_7_c
			Bit(m_regC, 7);
			return 8;
		
		case 0x7A: // bit_7_d
			Bit(m_regD, 7);
			return 8;
		
		case 0x7B: // bit_7_e
			Bit(m_regE, 7);
			return 8;
		
		case 0x7C: // bit_7_h
			Bit(m_regH, 7);
			return 8;
		
		case 0x7D: // bit_7_l
			Bit(m_regL, 7);
			return 8;
		
		case 0x7E: // bit_7_xhl
			Bit(MemReadByte(m_regHL), 7);
			return 12;
		
		case 0x7F: // bit_7_a
			Bit(m_regA, 7);
			return 8;

		case 0x80: // res_0_b
			m_regB = Res(m_regB, 0);
			return 8;
		
		case 0x81: // res_0_c
			m_regC = Res(m_regC, 0);
			return 8;
		
		case 0x82: // res_0_d
			m_regD = Res(m_regD, 0);
			return 8;
		
		case 0x83: // res_0_e
			m_regE = Res(m_regE, 0);
			return 8;
		
		case 0x84: // res_0_h
			m_regH = Res(m_regH, 0);
			return 8;
		
		case 0x85: // res_0_l
			m_regL = Res(m_regL, 0);
			return 8;
		
		case 0x86: // res_0_xhl
			MemWriteByte(m_regHL, Res(MemReadByte(m_regHL), 0));
			return 15;
		
		case 0x87: // res_0_a
			m_regA = Res(m_regA, 0);
			return 8;

		case 0x88: // res_1_b
			m_regB = Res(m_regB ,1);
			return 8;
		
		case 0x89: // res_1_c
			m_regC = Res(m_regC, 1);
			return 8;
		
		case 0x8A: // res_1_d
			m_regD = Res(m_regD, 1);
			return 8;
		
		case 0x8B: // res_1_e
			m_regE = Res(m_regE, 1);
			return 8;
		
		case 0x8C: // res_1_h
			m_regH = Res(m_regH, 1);
			return 8;
		
		case 0x8D: // res_1_l
			m_regL = Res(m_regL, 1);
			return 8;
		
		case 0x8E: // res_1_xhl
			MemWriteByte(m_regHL, Res(MemReadByte(m_regHL), 1));
			return 15;
		
		case 0x8F: // res_1_a
			m_regA = Res(m_regA, 1);
			return 8;

		case 0x90: // res_2_b
			m_regB = Res(m_regB ,2);
			return 8;
		
		case 0x91: // res_2_c
			m_regC = Res(m_regC, 2);
			return 8;
		
		case 0x92: // res_2_d
			m_regD = Res(m_regD, 2);
			return 8;
		
		case 0x93: // res_2_e
			m_regE = Res(m_regE, 2);
			return 8;
		
		case 0x94: // res_2_h
			m_regH = Res(m_regH, 2);
			return 8;
		
		case 0x95: // res_2_l
			m_regL = Res(m_regL, 2);
			return 8;
		
		case 0x96: // res_2_xhl
			MemWriteByte(m_regHL, Res(MemReadByte(m_regHL), 2));
			return 15;
		
		case 0x97: // res_2_a
			m_regA = Res(m_regA, 2);
			return 8;

		case 0x98: // res_3_b
			m_regB = Res(m_regB ,3);
			return 8;
		
		case 0x99: // res_3_c
			m_regC = Res(m_regC, 3);
			return 8;
		
		case 0x9A: // res_3_d
			m_regD = Res(m_regD, 3);
			return 8;
		
		case 0x9B: // res_3_e
			m_regE = Res(m_regE, 3);
			return 8;
		
		case 0x9C: // res_3_h
			m_regH = Res(m_regH, 3);
			return 8;
		
		case 0x9D: // res_3_l
			m_regL = Res(m_regL, 3);
			return 8;
		
		case 0x9E: // res_3_xhl
			MemWriteByte(m_regHL, Res(MemReadByte(m_regHL), 3));
			return 15;
		
		case 0x9F: // res_3_a
			m_regA = Res(m_regA, 3);
			return 8;

		case 0xA0: // res_4_b
			m_regB = Res(m_regB ,4);
			return 8;
		
		case 0xA1: // res_4_c
			m_regC = Res(m_regC, 4);
			return 8;
		
		case 0xA2: // res_4_d
			m_regD = Res(m_regD, 4);
			return 8;
		
		case 0xA3: // res_4_e
			m_regE = Res(m_regE, 4);
			return 8;
		
		case 0xA4: // res_4_h
			m_regH = Res(m_regH, 4);
			return 8;
		
		case 0xA5: // res_4_l
			m_regL = Res(m_regL, 4);
			return 8;
		
		case 0xA6: // res_4_xhl
			MemWriteByte(m_regHL, Res(MemReadByte(m_regHL), 4));
			return 15;
		
		case 0xA7: // res_4_a
			m_regA = Res(m_regA, 4);
			return 8;

		case 0xA8: // res_5_b
			m_regB = Res(m_regB ,5);
			return 8;
		
		case 0xA9: // res_5_c
			m_regC = Res(m_regC, 5);
			return 8;
		
		case 0xAA: // res_5_d
			m_regD = Res(m_regD, 5);
			return 8;
		
		case 0xAB: // res_5_e
			m_regE = Res(m_regE, 5);
			return 8;
		
		case 0xAC: // res_5_h
			m_regH = Res(m_regH, 5);
			return 8;
		
		case 0xAD: // res_5_l
			m_regL = Res(m_regL, 5);
			return 8;
		
		case 0xAE: // res_5_xhl
			MemWriteByte(m_regHL, Res(MemReadByte(m_regHL), 5));
			return 15;
		
		case 0xAF: // res_5_a
			m_regA = Res(m_regA, 5);
			return 8;

		case 0xB0: // res_6_b
			m_regB = Res(m_regB ,6);
			return 8;
		
		case 0xB1: // res_6_c
			m_regC = Res(m_regC, 6);
			return 8;
		
		case 0xB2: // res_6_d
			m_regD = Res(m_regD, 6);
			return 8;
		
		case 0xB3: // res_6_e
			m_regE = Res(m_regE, 6);
			return 8;
		
		case 0xB4: // res_6_h
			m_regH = Res(m_regH, 6);
			return 8;
		
		case 0xB5: // res_6_l
			m_regL = Res(m_regL, 6);
			return 8;
		
		case 0xB6: // res_6_xhl
			MemWriteByte(m_regHL, Res(MemReadByte(m_regHL), 6));
			return 15;
		
		case 0xB7: // res_6_a
			m_regA = Res(m_regA, 6);
			return 8;

		case 0xB8: // res_7_b
			m_regB = Res(m_regB ,7);
			return 8;
		
		case 0xB9: // res_7_c
			m_regC = Res(m_regC, 7);
			return 8;
		
		case 0xBA: // res_7_d
			m_regD = Res(m_regD, 7);
			return 8;
		
		case 0xBB: // res_7_e
			m_regE = Res(m_regE, 7);
			return 8;
		
		case 0xBC: // res_7_h
			m_regH = Res(m_regH, 7);
			return 8;
		
		case 0xBD: // res_7_l
			m_regL = Res(m_regL, 7);
			return 8;
		
		case 0xBE: // res_7_xhl
			MemWriteByte(m_regHL, Res(MemReadByte(m_regHL), 7));
			return 15;
		
		case 0xBF: // res_7_a
			m_regA = Res(m_regA, 7);
			return 8;

		case 0xC0: // set_0_b
			m_regB = Set(m_regB ,0);
			return 8;
		
		case 0xC1: // set_0_c
			m_regC = Set(m_regC, 0);
			return 8;
		
		case 0xC2: // set_0_d
			m_regD = Set(m_regD, 0);
			return 8;
		
		case 0xC3: // set_0_e
			m_regE = Set(m_regE, 0);
			return 8;
		
		case 0xC4: // set_0_h
			m_regH = Set(m_regH, 0);
			return 8;
		
		case 0xC5: // set_0_l
			m_regL = Set(m_regL, 0);
			return 8;
		
		case 0xC6: // set_0_xhl
			MemWriteByte(m_regHL, Set(MemReadByte(m_regHL), 0));
			return 15;
		
		case 0xC7: // set_0_a
			m_regA = Set(m_regA, 0);
			return 8;

		case 0xC8: // set_1_b
			m_regB = Set(m_regB ,1);
			return 8;
		
		case 0xC9: // set_1_c
			m_regC = Set(m_regC, 1);
			return 8;
		
		case 0xCA: // set_1_d
			m_regD = Set(m_regD, 1);
			return 8;
		
		case 0xCB: // set_1_e
			m_regE = Set(m_regE, 1);
			return 8;
		
		case 0xCC: // set_1_h
			m_regH = Set(m_regH, 1);
			return 8;
		
		case 0xCD: // set_1_l
			m_regL = Set(m_regL, 1);
			return 8;
		
		case 0xCE: // set_1_xhl
			MemWriteByte(m_regHL, Set(MemReadByte(m_regHL), 1));
			return 15;
		
		case 0xCF: // set_1_a
			m_regA = Set(m_regA, 1);
			return 8;

		case 0xD0: // set_2_b
			m_regB = Set(m_regB ,2);
			return 8;
		
		case 0xD1: // set_2_c
			m_regC = Set(m_regC, 2);
			return 8;
		
		case 0xD2: // set_2_d
			m_regD = Set(m_regD, 2);
			return 8;
		
		case 0xD3: // set_2_e
			m_regE = Set(m_regE, 2);
			return 8;
		
		case 0xD4: // set_2_h
			m_regH = Set(m_regH, 2);
			return 8;
		
		case 0xD5: // set_2_l
			m_regL = Set(m_regL, 2);
			return 8;
		
		case 0xD6: // set_2_xhl
			MemWriteByte(m_regHL, Set(MemReadByte(m_regHL), 2));
			return 15;
		
		case 0xD7: // set_2_a
			m_regA = Set(m_regA, 2);
			return 8;

		case 0xD8: // set_3_b
			m_regB = Set(m_regB ,3);
			return 8;
		
		case 0xD9: // set_3_c
			m_regC = Set(m_regC, 3);
			return 8;
		
		case 0xDA: // set_3_d
			m_regD = Set(m_regD, 3);
			return 8;
		
		case 0xDB: // set_3_e
			m_regE = Set(m_regE, 3);
			return 8;
		
		case 0xDC: // set_3_h
			m_regH = Set(m_regH, 3);
			return 8;
		
		case 0xDD: // set_3_l
			m_regL = Set(m_regL, 3);
			return 8;
		
		case 0xDE: // set_3_xhl
			MemWriteByte(m_regHL, Set(MemReadByte(m_regHL), 3));
			return 15;
		
		case 0xDF: // set_3_a
			m_regA = Set(m_regA, 3);
			return 8;

		case 0xE0: // set_4_b
			m_regB = Set(m_regB ,4);
			return 8;
		
		case 0xE1: // set_4_c
			m_regC = Set(m_regC, 4);
			return 8;
		
		case 0xE2: // set_4_d
			m_regD = Set(m_regD, 4);
			return 8;
		
		case 0xE3: // set_4_e
			m_regE = Set(m_regE, 4);
			return 8;
		
		case 0xE4: // set_4_h
			m_regH = Set(m_regH, 4);
			return 8;
		
		case 0xE5: // set_4_l
			m_regL = Set(m_regL, 4);
			return 8;
		
		case 0xE6: // set_4_xhl
			MemWriteByte(m_regHL, Set(MemReadByte(m_regHL), 4));
			return 15;
		
		case 0xE7: // set_4_a
			m_regA = Set(m_regA, 4);
			return 8;

		case 0xE8: // set_5_b
			m_regB = Set(m_regB ,5);
			return 8;
		
		case 0xE9: // set_5_c
			m_regC = Set(m_regC, 5);
			return 8;
		
		case 0xEA: // set_5_d
			m_regD = Set(m_regD, 5);
			return 8;
		
		case 0xEB: // set_5_e
			m_regE = Set(m_regE, 5);
			return 8;
		
		case 0xEC: // set_5_h
			m_regH = Set(m_regH, 5);
			return 8;
		
		case 0xED: // set_5_l
			m_regL = Set(m_regL, 5);
			return 8;
		
		case 0xEE: // set_5_xhl
			MemWriteByte(m_regHL, Set(MemReadByte(m_regHL), 5));
			return 15;
		
		case 0xEF: // set_5_a
			m_regA = Set(m_regA, 5);
			return 8;

		case 0xF0: // set_6_b
			m_regB = Set(m_regB ,6);
			return 8;
		
		case 0xF1: // set_6_c
			m_regC = Set(m_regC, 6);
			return 8;
		
		case 0xF2: // set_6_d
			m_regD = Set(m_regD, 6);
			return 8;
		
		case 0xF3: // set_6_e
			m_regE = Set(m_regE, 6);
			return 8;
		
		case 0xF4: // set_6_h
			m_regH = Set(m_regH, 6);
			return 8;
		
		case 0xF5: // set_6_l
			m_regL = Set(m_regL, 6);
			return 8;
		
		case 0xF6: // set_6_xhl
			MemWriteByte(m_regHL, Set(MemReadByte(m_regHL), 6));
			return 15;
		
		case 0xF7: // set_6_a
			m_regA = Set(m_regA, 6);
			return 8;

		case 0xF8: // set_7_b
			m_regB = Set(m_regB ,7);
			return 8;
		
		case 0xF9: // set_7_c
			m_regC = Set(m_regC, 7);
			return 8;
		
		case 0xFA: // set_7_d
			m_regD = Set(m_regD, 7);
			return 8;
		
		case 0xFB: // set_7_e
			m_regE = Set(m_regE, 7);
			return 8;
		
		case 0xFC: // set_7_h
			m_regH = Set(m_regH, 7);
			return 8;
		
		case 0xFD: // set_7_l
			m_regL = Set(m_regL, 7);
			return 8;
		
		case 0xFE: // set_7_xhl
			MemWriteByte(m_regHL, Set(MemReadByte(m_regHL), 7));
			return 15;
		
		case 0xFF: // set_7_a
			m_regA = Set(m_regA, 7);
			return 8;

		default:
			_ASSERT(FALSE);
			return 0;
	}
}

void Exx() {
	swap(m_regBC, m_regBC2);
	swap(m_regDE, m_regDE2);
	swap(m_regHL, m_regHL2);
}

/* ***************************************************************************
 * DD prefixed opcodes
 * ***************************************************************************
 */
/* inline */ WORD IndirectIX() {
	return m_regIX + (signed char)ImmedByte();
}

int HandleDD() {
	WORD wAddr;
	WORD wTemp;

	const BYTE bOpcode = ImmedByte();

	m_regR++;

	switch (bOpcode)
	{
		case 0x00: // no_op   
			SetPC(GetPC() - 1);
			return 0;
		
		case 0x01: // no_op     
			SetPC(GetPC() - 1);
			return 0;
		
		case 0x02: // no_op      
			SetPC(GetPC() - 1);
			return 0;
		
		case 0x03: // no_op    
			SetPC(GetPC() - 1);
			return 0;
		
		case 0x04: // no_op    
			SetPC(GetPC() - 1);
			return 0;
		
		case 0x05: // no_op    
			SetPC(GetPC() - 1);
			return 0;
		
		case 0x06: // no_op      
			SetPC(GetPC() - 1);
			return 0;
		
		case 0x07: // no_op   
			SetPC(Get