C++ running_machine::time方法代码示例

static void handle_eoi(running_machine &machine,int data)
{
	compis_state *state = machine.driver_data<compis_state>();
	int i, j;

	/* specific case */
	if (!(data & 0x8000))
	{
		/* turn off the appropriate in-service bit */
		switch (data & 0x1f)
		{
			case 0x08:	state->m_i186.intr.in_service &= ~0x01;	break;
			case 0x12:	state->m_i186.intr.in_service &= ~0x01;	break;
			case 0x13:	state->m_i186.intr.in_service &= ~0x01;	break;
			case 0x0a:	state->m_i186.intr.in_service &= ~0x04;	break;
			case 0x0b:	state->m_i186.intr.in_service &= ~0x08;	break;
			case 0x0c:	state->m_i186.intr.in_service &= ~0x10;	break;
			case 0x0d:	state->m_i186.intr.in_service &= ~0x20;	break;
			case 0x0e:	state->m_i186.intr.in_service &= ~0x40;	break;
			case 0x0f:	state->m_i186.intr.in_service &= ~0x80;	break;
			default:	logerror("%05X:ERROR - 80186 EOI with unknown vector %02X\n", cpu_get_pc(machine.device("maincpu")), data & 0x1f);
		}
		if (LOG_INTERRUPTS) logerror("(%f) **** Got EOI for vector %02X\n", machine.time().as_double(), data & 0x1f);
	}

	/* non-specific case */
	else
	{
		/* loop over priorities */
		for (i = 0; i <= 7; i++)
		{
			/* check for in-service timers */
			if ((state->m_i186.intr.timer & 7) == i && (state->m_i186.intr.in_service & 0x01))
			{
				state->m_i186.intr.in_service &= ~0x01;
				if (LOG_INTERRUPTS) logerror("(%f) **** Got EOI for timer\n", machine.time().as_double());
				return;
			}

			/* check for in-service DMA interrupts */
			for (j = 0; j < 2; j++)
				if ((state->m_i186.intr.dma[j] & 7) == i && (state->m_i186.intr.in_service & (0x04 << j)))
				{
					state->m_i186.intr.in_service &= ~(0x04 << j);
					if (LOG_INTERRUPTS) logerror("(%f) **** Got EOI for DMA%d\n", machine.time().as_double(), j);
					return;
				}

			/* check external interrupts */
			for (j = 0; j < 4; j++)
				if ((state->m_i186.intr.ext[j] & 7) == i && (state->m_i186.intr.in_service & (0x10 << j)))
				{
					state->m_i186.intr.in_service &= ~(0x10 << j);
					if (LOG_INTERRUPTS) logerror("(%f) **** Got EOI for INT%d\n", machine.time().as_double(), j);
					return;
				}
		}
	}
}

static void command_end(running_machine &machine)
{
	/* at the end of our test */
	state = STATE_DONE;
	final_time = machine.time();
	machine.schedule_exit();
}

static void ssystem3_playfield_write(running_machine &machine, int reset, int signal)
{
	ssystem3_state *state = machine.driver_data<ssystem3_state>();
  int d=FALSE;

  if (!reset) {
    state->m_playfield.count=0;
    state->m_playfield.bit=0;
    state->m_playfield.started=FALSE;
    state->m_playfield.signal=signal;
    state->m_playfield.time=machine.time();
  }
  if (!signal && state->m_playfield.signal) {
    attotime t=machine.time();
    state->m_playfield.high_time=t - state->m_playfield.time;
    state->m_playfield.time=t;

    //    logerror("%.4x playfield %d lowtime %s hightime %s\n",(int)activecpu_get_pc(), state->m_playfield.count,
    //       state->m_playfield.low_time.as_string(7), state->m_playfield.high_time.as_string(7) );

    if (state->m_playfield.started) {
      // 0 twice as long low
      // 1 twice as long high
      if (state->m_playfield.low_time > state->m_playfield.high_time) d=TRUE;

      state->m_playfield.data&=~(1<<(state->m_playfield.bit^7));
      if (d) state->m_playfield.data|=1<<(state->m_playfield.bit^7);
      state->m_playfield.bit++;
      if (state->m_playfield.bit==8) {
	logerror("%.4x playfield wrote %d %02x\n", (int)cpu_get_pc(machine.device("maincpu")), state->m_playfield.count, state->m_playfield.data);
	state->m_playfield.u.data[state->m_playfield.count]=state->m_playfield.data;
	state->m_playfield.bit=0;
	state->m_playfield.count=(state->m_playfield.count+1)%ARRAY_LENGTH(state->m_playfield.u.data);
	if (state->m_playfield.count==0) state->m_playfield.started=FALSE;
      }
    }

  } else if (signal && !state->m_playfield.signal) {
    attotime t=machine.time();
    state->m_playfield.low_time= t - state->m_playfield.time;
    state->m_playfield.time=t;
    state->m_playfield.started=TRUE;
  }
  state->m_playfield.signal=signal;
}

static UINT8 read_port_and_t0( running_machine &machine, int port )
{
	hitme_state *state = machine.driver_data<hitme_state>();
	static const char *const portnames[] = { "IN0", "IN1", "IN2", "IN3" };

	UINT8 val = machine.root_device().ioport(portnames[port])->read();
	if (machine.time() > state->m_timeout_time)
		val ^= 0x80;
	return val;
}

static void update_plunger( running_machine &machine )
{
    mgolf_state *state = machine.driver_data<mgolf_state>();
    UINT8 val = state->ioport("BUTTON")->read();

    if (state->m_prev != val)
    {
        if (val == 0)
        {
            state->m_time_released = machine.time();

            if (!state->m_mask)
                state->m_maincpu->set_input_line(INPUT_LINE_NMI, PULSE_LINE);
        }
        else
            state->m_time_pushed = machine.time();

        state->m_prev = val;
    }
}

static void update_plunger(running_machine &machine)
{
	videopin_state *state = machine.driver_data<videopin_state>();
	UINT8 val = input_port_read(machine, "IN2");

	if (state->m_prev != val)
	{
		if (val == 0)
		{
			state->m_time_released = machine.time();

			if (!state->m_mask)
				cputag_set_input_line(machine, "maincpu", INPUT_LINE_NMI, ASSERT_LINE);
		}
		else
			state->m_time_pushed = machine.time();

		state->m_prev = val;
	}
}

static void command_rawinput(running_machine &machine)
{
	//int parts;
	attotime current_time = machine.time();
	static const char *position;
#if 0
	int i;
	double rate = attotime::from_seconds(1);
	const char *s;
	char buf[256];
#endif

	if (state == STATE_READY)
	{
		/* beginning of a raw input command */
		//parts = 1;
		position = current_command->u.input_args.input_chars;
		wait_target = current_time;
		state = STATE_INCOMMAND;
	}
	else if (current_time > wait_target)
	{
#if 0
		do
		{
			/* process the next command */
			while(!isspace(*position))
				position++;

			/* look up the input to trigger */
			for (i = 0; input_keywords[i].name; i++)
			{
				if (!strncmp(position, input_keywords[i].name, strlen(input_keywords[i].name)))
					break;
			}

			/* go to next command */
			position = strchr(position, ',');
			if (position)
				position++;
		}
		while(position && !input_keywords[i].name);

		current_fake_input = input_keywords[i].name ? &input_keywords[i] : NULL;
		if (position)
			wait_target = current_time + rate;
		else
			state = STATE_READY;
#endif
	}
}

static void command_wait(running_machine &machine)
{
	attotime current_time = machine.time();

	if (state == STATE_READY)
	{
		/* beginning a wait command */
		wait_target = current_time + attotime::from_msec(current_command->u.wait_time);
		state = STATE_INCOMMAND;
	}
	else
	{
		/* during a wait command */
		state = (current_time >= wait_target) ? STATE_READY : STATE_INCOMMAND;
	}
}

static double calc_plunger_pos(running_machine &machine)
{
    mgolf_state *state = machine.driver_data<mgolf_state>();
    return (machine.time().as_double() - state->m_time_released.as_double()) * (state->m_time_released.as_double() - state->m_time_pushed.as_double() + 0.2);
}

void osd_update(running_machine &machine, int skip_redraw)
{
	int i;
	attotime time_limit;
	attotime current_time;

	target->get_primitives();

	/* don't do anything if we are initializing! */
	switch(machine.phase())
	{
		case MACHINE_PHASE_PREINIT:
		case MACHINE_PHASE_INIT:
		case MACHINE_PHASE_RESET:
			return;
		default: break;
	}

	/* if we have already aborted or completed, our work is done */
	if ((state == STATE_ABORTED) || (state == STATE_DONE))
	{
		machine.schedule_exit();
		return;
	}

	/* have we hit the time limit? */
	current_time = machine.time();
	time_limit = (current_testcase.time_limit != attotime::zero) ? current_testcase.time_limit
		: attotime::from_seconds(600);
	if (current_time > time_limit)
	{
		state = STATE_ABORTED;
		report_message(MSG_FAILURE, "Time limit of %s attoseconds exceeded", time_limit.as_string(9));
		return;
	}

	for (i = 0; i < ARRAY_LENGTH(commands); i++)
	{
		if (current_command->command_type == commands[i].command_type)
		{
			commands[i].proc(machine);
			break;
		}
	}

	/* if we are ready for the next command, advance to it */
	if (state == STATE_READY)
	{
		/* if we are at the end, and we are dumping screenshots, and we didn't
         * just dump a screenshot, dump one now
         */
		if ((test_flags & MESSTEST_ALWAYS_DUMP_SCREENSHOT) &&
			(current_command[0].command_type != MESSTEST_COMMAND_SCREENSHOT) &&
			(current_command[1].command_type == MESSTEST_COMMAND_END))
		{
			dump_screenshot(machine, TRUE);
		}

		current_command++;
	}
}

static void update_interrupt_state(running_machine &machine)
{
	compis_state *state = machine.driver_data<compis_state>();
	int i, j, new_vector = 0;

	if (LOG_INTERRUPTS) logerror("update_interrupt_status: req=%02X stat=%02X serv=%02X\n", state->m_i186.intr.request, state->m_i186.intr.status, state->m_i186.intr.in_service);

	/* loop over priorities */
	for (i = 0; i <= state->m_i186.intr.priority_mask; i++)
	{
		/* note: by checking 4 bits, we also verify that the mask is off */
		if ((state->m_i186.intr.timer & 15) == i)
		{
			/* if we're already servicing something at this level, don't generate anything new */
			if (state->m_i186.intr.in_service & 0x01)
				return;

			/* if there's something pending, generate an interrupt */
			if (state->m_i186.intr.status & 0x07)
			{
				if (state->m_i186.intr.status & 1)
					new_vector = 0x08;
				else if (state->m_i186.intr.status & 2)
					new_vector = 0x12;
				else if (state->m_i186.intr.status & 4)
					new_vector = 0x13;
				else
					popmessage("Invalid timer interrupt!");

				/* set the clear mask and generate the int */
				state->m_i186.intr.ack_mask = 0x0001;
				goto generate_int;
			}
		}

		/* check DMA interrupts */
		for (j = 0; j < 2; j++)
			if ((state->m_i186.intr.dma[j] & 15) == i)
			{
				/* if we're already servicing something at this level, don't generate anything new */
				if (state->m_i186.intr.in_service & (0x04 << j))
					return;

				/* if there's something pending, generate an interrupt */
				if (state->m_i186.intr.request & (0x04 << j))
				{
					new_vector = 0x0a + j;

					/* set the clear mask and generate the int */
					state->m_i186.intr.ack_mask = 0x0004 << j;
					goto generate_int;
				}
			}

		/* check external interrupts */
		for (j = 0; j < 4; j++)
			if ((state->m_i186.intr.ext[j] & 15) == i)
			{
				/* if we're already servicing something at this level, don't generate anything new */
				if (state->m_i186.intr.in_service & (0x10 << j))
					return;

				/* if there's something pending, generate an interrupt */
				if (state->m_i186.intr.request & (0x10 << j))
				{
					/* otherwise, generate an interrupt for this request */
					new_vector = 0x0c + j;

					/* set the clear mask and generate the int */
					state->m_i186.intr.ack_mask = 0x0010 << j;
					goto generate_int;
				}
			}
	}
	return;

generate_int:
	/* generate the appropriate interrupt */
	state->m_i186.intr.poll_status = 0x8000 | new_vector;
	if (!state->m_i186.intr.pending)
		cputag_set_input_line(machine, "maincpu", 0, ASSERT_LINE);
	state->m_i186.intr.pending = 1;
	machine.scheduler().trigger(CPU_RESUME_TRIGGER);
	if (LOG_OPTIMIZATION) logerror("  - trigger due to interrupt pending\n");
	if (LOG_INTERRUPTS) logerror("(%f) **** Requesting interrupt vector %02X\n", machine.time().as_double(), new_vector);
}