irobot.c

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

        if (!(mbops[irmb_oldPC].flags & FL_DIV) && !irmb_nflag) irmb_CI = 1;
	}


	/* Do the function */
    irmb_cflag=0;
	switch ((fu & 0x38) >> 3) {
		case 0:
            result = R + S + irmb_CI;
			break;
		case 1:
            result = (R ^ 0xFFFF) + S + irmb_CI;
			break;
		case 2:
            result = R + (S ^ 0xFFFF) + irmb_CI;
			break;
		case 3:
            result = R | S;
			break;
		case 4:
            result = R & S;
			break;
		case 5:
            result = (R ^ 0xFFFF) & S;
			break;
		case 6:
            result = R ^ S;
			break;
		case 7:
            result = (R ^ S) ^ 0xFFFF;
			break;
	}

    F = result & 0xFFFF;

    /* Evaluate flags */
    if (F == 0)
        irmb_zflag = 1;
	else
        irmb_zflag = 0;

	if (F & 0x8000)
        irmb_nflag = 1;
	else
        irmb_nflag = 0;

    if (result > 0xFFFF)
        irmb_cflag = 1;
    else
        irmb_cflag = 0;

    R = R & 0x8000;
    S = S & 0x8000;
    result = result & 0x8000;
    irmb_vflag = !((R ^ S) & (R ^ result));

    /* Do destination */
	switch ((fu & 0x1C0) >> 6) {
		case 0:
            irmb_Q = F;
            irmb_Y = F;
			break;
		case 1:
            irmb_Y = F;
			break;
		case 2:
            irmb_regs[mbops[irmb_PC].breg] = F;
            irmb_Y = irmb_regs[mbops[irmb_PC].areg];
			break;
		case 3:
            irmb_regs[mbops[irmb_PC].breg] = F;
            irmb_Y = F;
			break;
		case 4:
            irmb_regs[mbops[irmb_PC].breg] = F >> 1;
            irmb_Q = irmb_Q >> 1;
            if (mbops[irmb_PC].flags & FL_shift) {
                irmb_Q |= ((F & 0x01) << 15);
                irmb_regs[mbops[irmb_PC].breg] |= ((irmb_nflag ^ irmb_vflag) << 15);
			}
			else {
                irmb_Q |= ((mbops[irmb_PC].flags & 0x20) << 10);
                irmb_regs[mbops[irmb_PC].breg] |= ((mbops[irmb_PC].flags & 0x20) << 10);
			}

            irmb_Y = F;
			break;
		case 5:
            irmb_regs[mbops[irmb_PC].breg] = F >> 1;
            if (mbops[irmb_PC].flags & FL_shift) {
                irmb_regs[mbops[irmb_PC].breg] |= ((irmb_nflag ^ irmb_vflag) << 15);
			}
			else {
                irmb_regs[mbops[irmb_PC].breg] |= ((mbops[irmb_PC].flags & 0x20) << 10);
			}
            irmb_Y = F;
			break;
		case 6:
            irmb_regs[mbops[irmb_PC].breg] = F << 1;
            if (mbops[irmb_PC].flags & FL_shift) {
                irmb_regs[mbops[irmb_PC].breg] |= ((irmb_Q & 0x8000) >> 15);
			}
            irmb_Q = irmb_Q << 1;
            if (mbops[irmb_PC].flags & FL_shift) {
                irmb_Q |= (!irmb_nflag);
			}
            irmb_Y = F;
			break;
		case 7:
            irmb_regs[mbops[irmb_PC].breg] = F << 1;
            if (mbops[irmb_PC].flags & FL_shift) {
                irmb_regs[mbops[irmb_PC].breg] |= ((irmb_Q & 0x8000) >> 15);
			}
            irmb_Y = F;
			break;
	}

	/* Do write */
    if (!(mbops[irmb_PC].flags & FL_MBRW)) {
        irmb_dout(irmb_Y);
	}

	/* ADDEN */
    if (!(mbops[irmb_PC].flags & FL_ADDEN)) {
        if (mbops[irmb_PC].flags & FL_MBRW)
            MDB = irmb_din();
		else
            MDB = irmb_Y;

        irmb_pmadd = MDB & 0x07;
        irmb_latch = MDB & 0xFFF8;
	}

    irmb_oldPC=irmb_PC;
	/* handle jump */
    switch (mbops[irmb_PC].jtype) {
		case 1:
            if (irmb_cflag)
				do_jump();
			else
                irmb_PC=irmb_PC+1;
			break;
		case 2:
            if (irmb_zflag)
				do_jump();
			else
                irmb_PC=irmb_PC+1;
			break;
		case 3:
            if (!irmb_nflag)
				do_jump();
			else
                irmb_PC=irmb_PC+1;
			break;
		case 4:
            if (irmb_nflag)
				do_jump();
			else
                irmb_PC=irmb_PC+1;
			break;
		case 5:
			do_jump();
			break;
		case 6:
            irmb_stack[irmb_sp] = irmb_PC + 1;
            irmb_sp++;
            if (irmb_sp > 15) irmb_sp=0;
			do_jump();
			break;
		case 7:
            if (irmb_sp == 0)
                irmb_sp = 15;
			else
                irmb_sp--;
            irmb_PC = irmb_stack[irmb_sp];
			break;
		default:
            irmb_PC=irmb_PC+1;
	}

	return 0;
}



/***********************************************************************/

void irobot_nvram_w(int offset,int data)
{
    irobot_nvRAM[offset] = data & 0x0F;
}


int irobot_sharedmem_r(int offset) {

    if (irobot_outx == 3) {
        return mbRAM[offset];
    }

    if (irobot_outx == 2) {
        if (irobot_comswap)
            return comRAM2[offset & 0xFFF];
        else
            return comRAM1[offset & 0xFFF];
    }

    if (irobot_outx == 0) {
        if (!(irobot_mpage & 0x01))
            return mbROM[offset];
        else
            return mbROM[0x2000 + offset];
    }
    if (irobot_outx == 1) {
        switch (irobot_mpage) {
            case 0x00:
                return mbROM[0x4000 + offset];
            case 0x01:
                return mbROM[0x6000 + offset];
            case 0x02:
                return mbROM[0x8000 + offset];
            case 0x03:
                return mbROM[0xA000 + offset];
        }
    }
    return 0xFF;
}

/* Comment out the mbRAM =, comRAM2 = or comRAM1 = and it will start working */
void irobot_sharedmem_w(int offset,int data) {

    if (irobot_outx == 3) {
          mbRAM[offset] = (unsigned char)data;
    }

    if (irobot_outx == 2) {
          if (irobot_comswap) {
             comRAM2[offset & 0xFFF] = (unsigned char)data;
          }
          else {
             comRAM1[offset & 0xFFF] = (unsigned char)data;
          }
    }
}

void irobot_statwr_w(int offset, int data) {
    irobot_comswap = data & 0x80;
    irobot_bufsel = data & 0x02;
    if ((data & 0x04) && !(irobot_statwr & 0x04)) {
        run_video();
        irvg_running=1;
    }
    if (!(data & 0x01)) irobot_poly_clear();
    if ((data & 0x10) && !(irobot_statwr & 0x10)) {

/**** Comment out the next line to see the gameplay mode ****/
        irmb_run();
        irmb_running=1;
    }
    irobot_statwr = data;

}

void irobot_out0_w(int offset, int data)
{
	unsigned char *RAM = Machine->memory_region[Machine->drv->cpu[0].memory_region];


    irobot_out0 = data;
    switch (data & 0x60) {
        case 0:
            cpu_setbank(2, &RAM[0x1C000]);
            break;
        case 0x20:
            cpu_setbank(2, &RAM[0x1C800]);
            break;
        case 0x40:
            cpu_setbank(2, &RAM[0x1D000]);
            break;
    }
    irobot_outx = (data & 0x18) >> 3;
    irobot_mpage = (data & 0x06) >> 1;
    irobot_alphamap = (data & 0x80);
}

void irobot_rom_banksel( int offset, int data)
{
	unsigned char *RAM = Machine->memory_region[Machine->drv->cpu[0].memory_region];

    switch ((data & 0x0E) >> 1) {
        case 0:
            cpu_setbank(1, &RAM[0x10000]);
            break;
        case 1:
            cpu_setbank(1, &RAM[0x12000]);
            break;
        case 2:
            cpu_setbank(1, &RAM[0x14000]);
            break;
        case 3:
            cpu_setbank(1, &RAM[0x16000]);
            break;
        case 4:
            cpu_setbank(1, &RAM[0x18000]);
            break;
        case 5:
            cpu_setbank(1, &RAM[0x1A000]);
            break;
    }
    osd_led_w(0,data & 0x10);
    osd_led_w(1,data & 0x20);
}

void irobot_init_machine (void) {
    int i,p;
    unsigned char *MB = Machine->memory_region[2];

    irobot_rom_banksel(0,0);
    irobot_out0_w(0,0);
    irobot_comswap = 0;
    irobot_outx=0;

    /* Convert Mathbox Proms */
    p=0;
    for (i=0; i<16384; i+=2) mbROM[i+1] = MB[p++];
    for (i=0; i<16384; i+=2) mbROM[i] = MB[p++];
    for (i=0; i<32768; i+=2) mbROM[i + 0x4001] = MB[p++];
    for (i=0; i<32768; i+=2) mbROM[i + 0x4000] = MB[p++];
    irmb_init();

}

void irobot_control_w (int offset, int data) {

    irobot_control_num = offset & 0x03;
}

int irobot_control_r (int offset) {

    if (irobot_control_num == 0)
        return readinputport (5);
    else if (irobot_control_num == 1)
        return readinputport (6);
    return 0;

}

/* This still needs work */
int irobot_status_r(int offset)
{
        int d;

        d = (irmb_running * 0x20) | (irvg_running * 0x40);

        irmb_running=irvg_running=0;
        return input_port_2_r(offset) | d;
}