mirror of
https://github.com/holub/mame
synced 2025-05-03 21:13:18 +03:00
Fix build break from last checkin.
Also replace timer_get_time() with machine->time() 1. Main conversion timer_get_time( *)\( *([^)]+) *\) \2->time\1() 2. Cleanup #1 &machine->time machine.time 3. Cleanup #2 &m_machine->time m_machine.time
This commit is contained in:
Aaron Giles
parent
4526f1b3a9
commit
ae5dfca0bf
@ -1906,9 +1906,9 @@ void device_debug::instruction_hook(offs_t curpc)
|
||||
if (global->execution_state != EXECUTION_STATE_STOPPED && (m_flags & (DEBUG_FLAG_STOP_TIME | DEBUG_FLAG_STOP_PC | DEBUG_FLAG_LIVE_BP)) != 0)
|
||||
{
|
||||
// see if we hit a target time
|
||||
if ((m_flags & DEBUG_FLAG_STOP_TIME) != 0 && timer_get_time(&machine) >= m_stoptime)
|
||||
if ((m_flags & DEBUG_FLAG_STOP_TIME) != 0 && machine.time() >= m_stoptime)
|
||||
{
|
||||
debug_console_printf(&machine, "Stopped at time interval %.1g\n", timer_get_time(&machine).as_double());
|
||||
debug_console_printf(&machine, "Stopped at time interval %.1g\n", machine.time().as_double());
|
||||
global->execution_state = EXECUTION_STATE_STOPPED;
|
||||
}
|
||||
|
||||
@ -2222,7 +2222,7 @@ void device_debug::go_milliseconds(UINT64 milliseconds)
|
||||
|
||||
assert(m_exec != NULL);
|
||||
|
||||
m_stoptime = timer_get_time(m_device.machine) + attotime::from_msec(milliseconds);
|
||||
m_stoptime = m_device.machine->time() + attotime::from_msec(milliseconds);
|
||||
m_flags |= DEBUG_FLAG_STOP_TIME;
|
||||
global->execution_state = EXECUTION_STATE_RUNNING;
|
||||
}
|
||||
|
||||
@ -500,7 +500,7 @@ done:
|
||||
}
|
||||
else {
|
||||
/* do we need to reset the CPU? only schedule it if load/create is successful */
|
||||
if (timer_get_time(device().machine) > attotime::zero && m_image_config.is_reset_on_load())
|
||||
if (device().machine->time() > attotime::zero && m_image_config.is_reset_on_load())
|
||||
device().machine->schedule_hard_reset();
|
||||
else
|
||||
{
|
||||
|
||||
@ -453,7 +453,7 @@ void bitbanger_output(device_t *device, int value)
|
||||
timer_adjust_periodic(bi->bitbanger_output_timer, one_point_five_baud, 0, bi->current_baud);
|
||||
}
|
||||
|
||||
//fprintf(stderr,"%s, %d\n", timer_get_time(device->machine).as_string(9), value);
|
||||
//fprintf(stderr,"%s, %d\n", device->machine->time().as_string(9), value);
|
||||
bi->output_value = value;
|
||||
}
|
||||
|
||||
|
||||
@ -71,7 +71,7 @@ INLINE int cassette_is_motor_on(device_t *device)
|
||||
static void cassette_update(device_t *device)
|
||||
{
|
||||
dev_cassette_t *cassette = get_safe_token( device );
|
||||
double cur_time = timer_get_time(device->machine).as_double();
|
||||
double cur_time = device->machine->time().as_double();
|
||||
|
||||
if (cassette_is_motor_on(device))
|
||||
{
|
||||
@ -187,7 +187,7 @@ double cassette_get_position(device_t *device)
|
||||
position = cassette->position;
|
||||
|
||||
if (cassette_is_motor_on(device))
|
||||
position += timer_get_time(device->machine).as_double() - cassette->position_time;
|
||||
position += device->machine->time().as_double() - cassette->position_time;
|
||||
return position;
|
||||
}
|
||||
|
||||
@ -302,7 +302,7 @@ static DEVICE_IMAGE_LOAD( cassette )
|
||||
|
||||
/* reset the position */
|
||||
cassette->position = 0.0;
|
||||
cassette->position_time = timer_get_time(device->machine).as_double();
|
||||
cassette->position_time = device->machine->time().as_double();
|
||||
|
||||
return IMAGE_INIT_PASS;
|
||||
|
||||
|
||||
@ -1536,7 +1536,7 @@ input_port_value input_port_read_direct(const input_port_config *port)
|
||||
/* interpolate if appropriate and if time has passed since the last update */
|
||||
if (analog->interpolate && !(analog->field->flags & ANALOG_FLAG_RESET) && portdata->last_delta_nsec != 0)
|
||||
{
|
||||
attoseconds_t nsec_since_last = (timer_get_time(port->machine) - portdata->last_frame_time).as_attoseconds() / ATTOSECONDS_PER_NANOSECOND;
|
||||
attoseconds_t nsec_since_last = (port->machine->time() - portdata->last_frame_time).as_attoseconds() / ATTOSECONDS_PER_NANOSECOND;
|
||||
value = analog->previous + ((INT64)(analog->accum - analog->previous) * nsec_since_last / portdata->last_delta_nsec);
|
||||
}
|
||||
|
||||
@ -2465,7 +2465,7 @@ static void frame_update(running_machine *machine)
|
||||
input_port_private *portdata = machine->input_port_data;
|
||||
const input_field_config *mouse_field = NULL;
|
||||
int ui_visible = ui_is_menu_active();
|
||||
attotime curtime = timer_get_time(machine);
|
||||
attotime curtime = machine->time();
|
||||
const input_port_config *port;
|
||||
render_target *mouse_target;
|
||||
INT32 mouse_target_x;
|
||||
|
||||
@ -154,14 +154,10 @@ running_machine::running_machine(const machine_config &_config, osd_interface &o
|
||||
sample_rate(options_get_int(&options, OPTION_SAMPLERATE)),
|
||||
debug_flags(0),
|
||||
ui_active(false),
|
||||
mame_data(NULL),
|
||||
timer_data(NULL),
|
||||
state_data(NULL),
|
||||
memory_data(NULL),
|
||||
palette_data(NULL),
|
||||
tilemap_data(NULL),
|
||||
streams_data(NULL),
|
||||
devices_data(NULL),
|
||||
romload_data(NULL),
|
||||
input_data(NULL),
|
||||
input_port_data(NULL),
|
||||
@ -466,7 +462,7 @@ void running_machine::schedule_exit()
|
||||
m_scheduler.eat_all_cycles();
|
||||
|
||||
// if we're autosaving on exit, schedule a save as well
|
||||
if (options_get_bool(&m_options, OPTION_AUTOSAVE) && (m_game.flags & GAME_SUPPORTS_SAVE) && timer_get_time(this) > attotime::zero)
|
||||
if (options_get_bool(&m_options, OPTION_AUTOSAVE) && (m_game.flags & GAME_SUPPORTS_SAVE) && this->time() > attotime::zero)
|
||||
schedule_save("auto");
|
||||
}
|
||||
|
||||
@ -550,7 +546,7 @@ void running_machine::schedule_save(const char *filename)
|
||||
|
||||
// note the start time and set a timer for the next timeslice to actually schedule it
|
||||
m_saveload_schedule = SLS_SAVE;
|
||||
m_saveload_schedule_time = timer_get_time(this);
|
||||
m_saveload_schedule_time = this->time();
|
||||
|
||||
// we can't be paused since we need to clear out anonymous timers
|
||||
resume();
|
||||
@ -569,7 +565,7 @@ void running_machine::schedule_load(const char *filename)
|
||||
|
||||
// note the start time and set a timer for the next timeslice to actually schedule it
|
||||
m_saveload_schedule = SLS_LOAD;
|
||||
m_saveload_schedule_time = timer_get_time(this);
|
||||
m_saveload_schedule_time = this->time();
|
||||
|
||||
// we can't be paused since we need to clear out anonymous timers
|
||||
resume();
|
||||
@ -735,7 +731,7 @@ void running_machine::base_datetime(system_time &systime)
|
||||
|
||||
void running_machine::current_datetime(system_time &systime)
|
||||
{
|
||||
systime.set(m_base_time + timer_get_time(this).seconds);
|
||||
systime.set(m_base_time + this->time().seconds);
|
||||
}
|
||||
|
||||
|
||||
@ -786,7 +782,7 @@ void running_machine::handle_saveload()
|
||||
if (m_scheduler.can_save())
|
||||
{
|
||||
// if more than a second has passed, we're probably screwed
|
||||
if ((timer_get_time(this) - m_saveload_schedule_time) > attotime::from_seconds(1))
|
||||
if ((this->time() - m_saveload_schedule_time) > attotime::from_seconds(1))
|
||||
{
|
||||
popmessage("Unable to %s due to pending anonymous timers. See error.log for details.", opname);
|
||||
goto cancel;
|
||||
|
||||
@ -169,7 +169,7 @@ UINT16 via6522_device::get_counter1_value()
|
||||
}
|
||||
else
|
||||
{
|
||||
val = 0xffff - time_to_cycles(timer_get_time(&m_machine) - m_time1);
|
||||
val = 0xffff - time_to_cycles(m_machine.time() - m_time1);
|
||||
}
|
||||
|
||||
return val;
|
||||
@ -217,7 +217,7 @@ void via6522_device::device_start()
|
||||
m_t1lh = 0xb5; /* ports are not written by kernel! */
|
||||
m_t2ll = 0xff; /* taken from vice */
|
||||
m_t2lh = 0xff;
|
||||
m_time2 = m_time1 = timer_get_time(&m_machine);
|
||||
m_time2 = m_time1 = m_machine.time();
|
||||
m_t1 = timer_alloc(TIMER_T1);
|
||||
m_t2 = timer_alloc(TIMER_T2);
|
||||
m_shift_timer = timer_alloc(TIMER_SHIFT);
|
||||
@ -441,7 +441,7 @@ void via6522_device::device_timer(emu_timer &timer, device_timer_id id, int para
|
||||
m_out_b |= 0x80;
|
||||
}
|
||||
m_t1_active = 0;
|
||||
m_time1 = timer_get_time(&m_machine);
|
||||
m_time1 = m_machine.time();
|
||||
}
|
||||
if (m_ddr_b)
|
||||
{
|
||||
@ -458,7 +458,7 @@ void via6522_device::device_timer(emu_timer &timer, device_timer_id id, int para
|
||||
// t2 timeout
|
||||
case TIMER_T2:
|
||||
m_t2_active = 0;
|
||||
m_time2 = timer_get_time(&m_machine);
|
||||
m_time2 = m_machine.time();
|
||||
|
||||
if (!(m_ifr & INT_T2))
|
||||
{
|
||||
@ -605,7 +605,7 @@ READ8_MEMBER( via6522_device::read )
|
||||
}
|
||||
else
|
||||
{
|
||||
val = (0x10000 - (time_to_cycles(timer_get_time(&m_machine) - m_time2) & 0xffff) - 1) & 0xff;
|
||||
val = (0x10000 - (time_to_cycles(m_machine.time() - m_time2) & 0xffff) - 1) & 0xff;
|
||||
}
|
||||
}
|
||||
break;
|
||||
@ -623,7 +623,7 @@ READ8_MEMBER( via6522_device::read )
|
||||
}
|
||||
else
|
||||
{
|
||||
val = (0x10000 - (time_to_cycles(timer_get_time(&m_machine) - m_time2) & 0xffff) - 1) >> 8;
|
||||
val = (0x10000 - (time_to_cycles(m_machine.time() - m_time2) & 0xffff) - 1) >> 8;
|
||||
}
|
||||
}
|
||||
break;
|
||||
@ -825,7 +825,7 @@ WRITE8_MEMBER( via6522_device::write )
|
||||
{
|
||||
timer_adjust_oneshot(m_t2, cycles_to_time(TIMER2_VALUE), 0);
|
||||
m_t2_active = 1;
|
||||
m_time2 = timer_get_time(&m_machine);
|
||||
m_time2 = m_machine.time();
|
||||
}
|
||||
break;
|
||||
|
||||
|
||||
@ -238,7 +238,7 @@ void riot6532_device::reg_w(UINT8 offset, UINT8 data)
|
||||
if ((offset & 0x14) == 0x14)
|
||||
{
|
||||
static const UINT8 timershift[4] = { 0, 3, 6, 10 };
|
||||
attotime curtime = timer_get_time(&m_machine);
|
||||
attotime curtime = m_machine.time();
|
||||
INT64 target;
|
||||
|
||||
/* A0-A1 contain the timer divisor */
|
||||
|
||||
@ -621,7 +621,7 @@ void generic_pulse_irq_line(device_t *device, int irqline)
|
||||
|
||||
cpu_device *cpudevice = downcast<cpu_device *>(device);
|
||||
attotime target_time = cpudevice->local_time() + cpudevice->cycles_to_attotime(cpudevice->min_cycles());
|
||||
device->machine->scheduler().timer_set(target_time - timer_get_time(device->machine), FUNC(irq_pulse_clear), irqline, (void *)device);
|
||||
device->machine->scheduler().timer_set(target_time - device->machine->time(), FUNC(irq_pulse_clear), irqline, (void *)device);
|
||||
}
|
||||
|
||||
|
||||
@ -638,7 +638,7 @@ void generic_pulse_irq_line_and_vector(device_t *device, int irqline, int vector
|
||||
|
||||
cpu_device *cpudevice = downcast<cpu_device *>(device);
|
||||
attotime target_time = cpudevice->local_time() + cpudevice->cycles_to_attotime(cpudevice->min_cycles());
|
||||
device->machine->scheduler().timer_set(target_time - timer_get_time(device->machine), FUNC(irq_pulse_clear), irqline, (void *)device);
|
||||
device->machine->scheduler().timer_set(target_time - device->machine->time(), FUNC(irq_pulse_clear), irqline, (void *)device);
|
||||
}
|
||||
|
||||
|
||||
|
||||
@ -434,7 +434,7 @@ READ8_DEVICE_HANDLER( ins8250_r )
|
||||
case 5:
|
||||
|
||||
#if 0
|
||||
if (ins8250->send.active && (timer_get_time(machine)-ins8250->send.time>uart_byte_time(n)))
|
||||
if (ins8250->send.active && (machine->time()-ins8250->send.time>uart_byte_time(n)))
|
||||
{
|
||||
// currently polling is enough for pc1512
|
||||
ins8250->lsr |= 0x40; /* set TSRE */
|
||||
|
||||
@ -292,7 +292,7 @@ static void vblank_state_changed(screen_device &screen, void *param, bool vblank
|
||||
device_t *device = (device_t *)param;
|
||||
laserdisc_state *ld = get_safe_token(device);
|
||||
ldcore_data *ldcore = ld->core;
|
||||
attotime curtime = timer_get_time(screen.machine);
|
||||
attotime curtime = screen.machine->time();
|
||||
|
||||
/* update current track based on slider speed */
|
||||
update_slider_pos(ldcore, curtime);
|
||||
@ -319,7 +319,7 @@ static TIMER_CALLBACK( perform_player_update )
|
||||
{
|
||||
laserdisc_state *ld = (laserdisc_state *)ptr;
|
||||
ldcore_data *ldcore = ld->core;
|
||||
attotime curtime = timer_get_time(machine);
|
||||
attotime curtime = machine->time();
|
||||
|
||||
/* wait for previous read and decode to finish */
|
||||
process_track_data(ld->device);
|
||||
@ -554,7 +554,7 @@ void ldcore_set_slider_speed(laserdisc_state *ld, INT32 tracks_per_vsync)
|
||||
ldcore_data *ldcore = ld->core;
|
||||
attotime vsyncperiod = ld->screen->frame_period();
|
||||
|
||||
update_slider_pos(ldcore, timer_get_time(ld->device->machine));
|
||||
update_slider_pos(ldcore, ld->device->machine->time());
|
||||
|
||||
/* if 0, set the time to 0 */
|
||||
if (tracks_per_vsync == 0)
|
||||
@ -582,7 +582,7 @@ void ldcore_advance_slider(laserdisc_state *ld, INT32 numtracks)
|
||||
{
|
||||
ldcore_data *ldcore = ld->core;
|
||||
|
||||
update_slider_pos(ldcore, timer_get_time(ld->device->machine));
|
||||
update_slider_pos(ldcore, ld->device->machine->time());
|
||||
add_and_clamp_track(ldcore, numtracks);
|
||||
if (LOG_SLIDER)
|
||||
printf("Advance by %d\n", numtracks);
|
||||
@ -599,7 +599,7 @@ slider_position ldcore_get_slider_position(laserdisc_state *ld)
|
||||
ldcore_data *ldcore = ld->core;
|
||||
|
||||
/* update the slider position first */
|
||||
update_slider_pos(ldcore, timer_get_time(ld->device->machine));
|
||||
update_slider_pos(ldcore, ld->device->machine->time());
|
||||
|
||||
/* return the status */
|
||||
if (ldcore->curtrack == 1)
|
||||
@ -1549,7 +1549,7 @@ static DEVICE_STOP( laserdisc )
|
||||
static DEVICE_RESET( laserdisc )
|
||||
{
|
||||
laserdisc_state *ld = get_safe_token(device);
|
||||
attotime curtime = timer_get_time(device->machine);
|
||||
attotime curtime = device->machine->time();
|
||||
ldcore_data *ldcore = ld->core;
|
||||
int pltype, line;
|
||||
|
||||
|
||||
@ -340,7 +340,7 @@ const ldplayer_interface pr8210_interface =
|
||||
static void pr8210_init(laserdisc_state *ld)
|
||||
{
|
||||
astring tempstring;
|
||||
attotime curtime = timer_get_time(ld->device->machine);
|
||||
attotime curtime = ld->device->machine->time();
|
||||
ldplayer_data *player = ld->player;
|
||||
|
||||
/* reset our state */
|
||||
@ -451,7 +451,7 @@ static void pr8210_control_w(laserdisc_state *ld, UINT8 prev, UINT8 data)
|
||||
/* handle rising edge */
|
||||
if (prev != ASSERT_LINE && data == ASSERT_LINE)
|
||||
{
|
||||
attotime curtime = timer_get_time(ld->device->machine);
|
||||
attotime curtime = ld->device->machine->time();
|
||||
attotime delta, overalldelta;
|
||||
int longpulse;
|
||||
|
||||
@ -840,7 +840,7 @@ static WRITE8_HANDLER( pr8210_port2_w )
|
||||
|
||||
/* on the falling edge of bit 5, start the slow timer */
|
||||
if (!(data & 0x20) && (prev & 0x20))
|
||||
player->slowtrg = timer_get_time(space->machine);
|
||||
player->slowtrg = space->machine->time();
|
||||
|
||||
/* bit 6 when low triggers an IRQ on the MCU */
|
||||
if (player->cpu != NULL)
|
||||
|
||||
@ -183,7 +183,7 @@ mc146818_device::mc146818_device(running_machine &_machine, const mc146818_devic
|
||||
|
||||
void mc146818_device::device_start()
|
||||
{
|
||||
m_last_refresh = timer_get_time(&m_machine);
|
||||
m_last_refresh = m_machine.time();
|
||||
emu_timer *timer = timer_alloc();
|
||||
if (m_config.m_type == mc146818_device_config::MC146818_UTC) {
|
||||
// hack: for apollo we increase the update frequency to stay in sync with real time
|
||||
@ -327,7 +327,7 @@ void mc146818_device::device_timer(emu_timer &timer, device_timer_id id, int par
|
||||
}
|
||||
|
||||
m_updated = true; /* clock has been updated */
|
||||
m_last_refresh = timer_get_time(&m_machine);
|
||||
m_last_refresh = m_machine.time();
|
||||
}
|
||||
|
||||
|
||||
@ -436,7 +436,7 @@ READ8_MEMBER( mc146818_device::read )
|
||||
switch (m_index % MC146818_DATA_SIZE) {
|
||||
case 0xa:
|
||||
data = m_data[m_index % MC146818_DATA_SIZE];
|
||||
if ((timer_get_time(space.machine) - m_last_refresh) < attotime::from_hz(32768))
|
||||
if ((space.machine->time() - m_last_refresh) < attotime::from_hz(32768))
|
||||
data |= 0x80;
|
||||
#if 0
|
||||
/* for pc1512 bios realtime clock test */
|
||||
|
||||
@ -614,7 +614,7 @@ static void simulate2(device_t *device, struct pit8253_timer *timer, INT64 elaps
|
||||
{
|
||||
attotime next_fire_time = timer->last_updated + cycles_to_output * attotime::from_hz( timer->clockin );
|
||||
|
||||
timer_adjust_oneshot(timer->updatetimer, next_fire_time - timer_get_time(device->machine), timer->index );
|
||||
timer_adjust_oneshot(timer->updatetimer, next_fire_time - device->machine->time(), timer->index );
|
||||
}
|
||||
|
||||
LOG2(("pit8253: simulate2(): simulating %d cycles for %d in mode %d, bcd = %d, phase = %d, gate = %d, output %d, value = 0x%04x, cycles_to_output = %04x\n",
|
||||
@ -654,7 +654,7 @@ static void update(device_t *device, struct pit8253_timer *timer)
|
||||
{
|
||||
/* With the 82C54's maximum clockin of 10MHz, 64 bits is nearly 60,000
|
||||
years of time. Should be enough for now. */
|
||||
attotime now = timer_get_time(device->machine);
|
||||
attotime now = device->machine->time();
|
||||
attotime elapsed_time = now - timer->last_updated;
|
||||
INT64 elapsed_cycles = elapsed_time.as_double() * timer->clockin;
|
||||
|
||||
@ -916,7 +916,7 @@ WRITE8_DEVICE_HANDLER( pit8253_w )
|
||||
|
||||
update(device, timer);
|
||||
|
||||
if ( timer_get_time(device->machine) > timer->last_updated && timer->clockin != 0 )
|
||||
if ( device->machine->time() > timer->last_updated && timer->clockin != 0 )
|
||||
{
|
||||
middle_of_a_cycle = 1;
|
||||
}
|
||||
@ -1149,7 +1149,7 @@ static DEVICE_RESET( pit8253 ) {
|
||||
timer->null_count = 1;
|
||||
timer->cycles_to_output = CYCLES_NEVER;
|
||||
|
||||
timer->last_updated = timer_get_time(device->machine);
|
||||
timer->last_updated = device->machine->time();
|
||||
|
||||
update(device, timer);
|
||||
}
|
||||
|
||||
@ -942,13 +942,6 @@ void device_scheduler::add_scheduling_quantum(attotime quantum, attotime duratio
|
||||
}
|
||||
|
||||
|
||||
|
||||
|
||||
|
||||
attotime timer_get_time(running_machine *machine) { return machine->time(); }
|
||||
|
||||
|
||||
|
||||
/***************************************************************************
|
||||
// DEBUGGING
|
||||
***************************************************************************/
|
||||
|
||||
@ -247,8 +247,6 @@ private:
|
||||
|
||||
|
||||
// temporary stuff
|
||||
attotime timer_get_time(running_machine *machine);
|
||||
|
||||
inline void timer_adjust_oneshot(emu_timer *which, attotime duration, INT32 param) { which->adjust(duration, param); }
|
||||
inline void timer_adjust_periodic(emu_timer *which, attotime start_delay, INT32 param, attotime period) { which->adjust(start_delay, param, period); }
|
||||
|
||||
|
||||
@ -467,7 +467,7 @@ void screen_device::configure(int width, int height, const rectangle &visarea, a
|
||||
void screen_device::reset_origin(int beamy, int beamx)
|
||||
{
|
||||
// compute the effective VBLANK start/end times
|
||||
attotime curtime = timer_get_time(machine);
|
||||
attotime curtime = machine->time();
|
||||
m_vblank_end_time = curtime - attotime(0, beamy * m_scantime + beamx * m_pixeltime);
|
||||
m_vblank_start_time = m_vblank_end_time - attotime(0, m_vblank_period);
|
||||
|
||||
@ -667,7 +667,7 @@ void screen_device::update_now()
|
||||
|
||||
int screen_device::vpos() const
|
||||
{
|
||||
attoseconds_t delta = (timer_get_time(machine) - m_vblank_start_time).as_attoseconds();
|
||||
attoseconds_t delta = (machine->time() - m_vblank_start_time).as_attoseconds();
|
||||
int vpos;
|
||||
|
||||
// round to the nearest pixel
|
||||
@ -688,7 +688,7 @@ int screen_device::vpos() const
|
||||
|
||||
int screen_device::hpos() const
|
||||
{
|
||||
attoseconds_t delta = (timer_get_time(machine) - m_vblank_start_time).as_attoseconds();
|
||||
attoseconds_t delta = (machine->time() - m_vblank_start_time).as_attoseconds();
|
||||
|
||||
// round to the nearest pixel
|
||||
delta += m_pixeltime / 2;
|
||||
@ -724,7 +724,7 @@ attotime screen_device::time_until_pos(int vpos, int hpos) const
|
||||
attoseconds_t targetdelta = (attoseconds_t)vpos * m_scantime + (attoseconds_t)hpos * m_pixeltime;
|
||||
|
||||
// if we're past that time (within 1/2 of a pixel), head to the next frame
|
||||
attoseconds_t curdelta = (timer_get_time(machine) - m_vblank_start_time).as_attoseconds();
|
||||
attoseconds_t curdelta = (machine->time() - m_vblank_start_time).as_attoseconds();
|
||||
if (targetdelta <= curdelta + m_pixeltime / 2)
|
||||
targetdelta += m_frame_period;
|
||||
while (targetdelta <= curdelta)
|
||||
@ -748,7 +748,7 @@ attotime screen_device::time_until_vblank_end() const
|
||||
attotime target_time = m_vblank_end_time;
|
||||
if (!vblank())
|
||||
target_time += attotime(0, m_frame_period);
|
||||
return target_time - timer_get_time(machine);
|
||||
return target_time - machine->time();
|
||||
}
|
||||
|
||||
|
||||
@ -787,7 +787,7 @@ void screen_device::register_vblank_callback(vblank_state_changed_func vblank_ca
|
||||
void screen_device::vblank_begin_callback()
|
||||
{
|
||||
// reset the starting VBLANK time
|
||||
m_vblank_start_time = timer_get_time(machine);
|
||||
m_vblank_start_time = machine->time();
|
||||
m_vblank_end_time = m_vblank_start_time + attotime(0, m_vblank_period);
|
||||
|
||||
// call the screen specific callbacks
|
||||
|
||||
@ -166,7 +166,7 @@ public:
|
||||
// beam positioning and state
|
||||
int vpos() const;
|
||||
int hpos() const;
|
||||
bool vblank() const { return (timer_get_time(machine) < m_vblank_end_time); }
|
||||
bool vblank() const { return (machine->time() < m_vblank_end_time); }
|
||||
bool hblank() const { int curpos = hpos(); return (curpos < m_visarea.min_x || curpos > m_visarea.max_x); }
|
||||
|
||||
// timing
|
||||
|
||||
@ -258,7 +258,7 @@ void sound_stream::set_input(int index, sound_stream *input_stream, int output_i
|
||||
void sound_stream::update()
|
||||
{
|
||||
// determine the number of samples since the start of this second
|
||||
attotime time = timer_get_time(m_device.machine);
|
||||
attotime time = m_device.machine->time();
|
||||
INT32 update_sampindex = INT32(time.attoseconds / m_attoseconds_per_sample);
|
||||
|
||||
// if we're ahead of the last update, then adjust upwards
|
||||
@ -1045,7 +1045,7 @@ void sound_manager::update()
|
||||
}
|
||||
|
||||
// see if we ticked over to the next second
|
||||
attotime curtime = timer_get_time(&m_machine);
|
||||
attotime curtime = m_machine.time();
|
||||
bool second_tick = false;
|
||||
if (curtime.seconds != m_last_update.seconds)
|
||||
{
|
||||
|
||||
@ -42,7 +42,7 @@ struct _ssg_callbacks
|
||||
#if FM_BUSY_FLAG_SUPPORT
|
||||
#define TIME_TYPE attotime
|
||||
#define UNDEFINED_TIME attotime::zero
|
||||
#define FM_GET_TIME_NOW(machine) timer_get_time(machine)
|
||||
#define FM_GET_TIME_NOW(machine) machine->time()
|
||||
#define ADD_TIMES(t1, t2) ((t1) + (t2))
|
||||
#define COMPARE_TIMES(t1, t2) (((t1) == (t2)) ? 0 : ((t1) < (t2)) ? -1 : 1)
|
||||
#define MULTIPLY_TIME_BY_INT(t,i) ((t) * (i))
|
||||
|
||||
@ -145,7 +145,7 @@ INLINE const mos6560_interface *get_interface( device_t *device )
|
||||
if(VERBOSE_LEVEL >= N) \
|
||||
{ \
|
||||
if( M ) \
|
||||
logerror("%11.6f: %-24s", timer_get_time(device->machine).as_double(), (char*) M ); \
|
||||
logerror("%11.6f: %-24s", device->machine->time().as_double(), (char*) M ); \
|
||||
logerror A; \
|
||||
} \
|
||||
} while (0)
|
||||
@ -460,7 +460,7 @@ READ8_DEVICE_HANDLER( mos6560_port_r )
|
||||
break;
|
||||
case 6: /*lightpen horizontal */
|
||||
case 7: /*lightpen vertical */
|
||||
if (LIGHTPEN_BUTTON && ((timer_get_time(device->machine).as_double() - mos6560->lightpenreadtime) * MOS656X_VRETRACERATE >= 1))
|
||||
if (LIGHTPEN_BUTTON && ((device->machine->time().as_double() - mos6560->lightpenreadtime) * MOS656X_VRETRACERATE >= 1))
|
||||
{
|
||||
/* only 1 update each frame */
|
||||
/* and diode must recognize light */
|
||||
@ -469,7 +469,7 @@ READ8_DEVICE_HANDLER( mos6560_port_r )
|
||||
mos6560->reg[6] = MOS656X_X_VALUE;
|
||||
mos6560->reg[7] = MOS656X_Y_VALUE;
|
||||
}
|
||||
mos6560->lightpenreadtime = timer_get_time(device->machine).as_double();
|
||||
mos6560->lightpenreadtime = device->machine->time().as_double();
|
||||
}
|
||||
val = mos6560->reg[offset];
|
||||
break;
|
||||
|
||||
@ -159,7 +159,7 @@ static DEVICE_START( speaker )
|
||||
for (i = 0; i < FILTER_LENGTH; i++)
|
||||
sp->composed_volume[i] = 0;
|
||||
sp->composed_sample_index = 0;
|
||||
sp->last_update_time = timer_get_time(device->machine);
|
||||
sp->last_update_time = device->machine->time();
|
||||
sp->channel_sample_period = HZ_TO_ATTOSECONDS(device->machine->sample_rate);
|
||||
sp->channel_sample_period_secfrac = ATTOSECONDS_TO_DOUBLE(sp->channel_sample_period);
|
||||
sp->interm_sample_period = sp->channel_sample_period / RATE_MULTIPLIER;
|
||||
@ -275,7 +275,7 @@ void speaker_level_w(device_t *device, int new_level)
|
||||
new_level = sp->num_levels - 1;
|
||||
|
||||
volume = sp->levels[sp->level];
|
||||
time = timer_get_time(device->machine);
|
||||
time = device->machine->time();
|
||||
|
||||
if (time < sp->channel_next_sample_time)
|
||||
{
|
||||
|
||||
@ -2438,7 +2438,7 @@ static void menu_bookkeeping(running_machine *machine, ui_menu *menu, void *para
|
||||
prevtime = (attotime *)state;
|
||||
|
||||
/* if the time has rolled over another second, regenerate */
|
||||
curtime = timer_get_time(machine);
|
||||
curtime = machine->time();
|
||||
if (prevtime->seconds != curtime.seconds)
|
||||
{
|
||||
ui_menu_reset(menu, UI_MENU_RESET_SELECT_FIRST);
|
||||
|
||||
@ -240,7 +240,7 @@ void video_manager::frame_update(bool debug)
|
||||
debugint_update_during_game(&m_machine);
|
||||
|
||||
// if we're throttling, synchronize before rendering
|
||||
attotime current_time = timer_get_time(&m_machine);
|
||||
attotime current_time = m_machine.time();
|
||||
if (!debug && !skipped_it && effective_throttle())
|
||||
update_throttle(current_time);
|
||||
|
||||
@ -403,7 +403,7 @@ void video_manager::begin_recording(const char *name, movie_format format)
|
||||
|
||||
// reset the state
|
||||
m_movie_frame = 0;
|
||||
m_movie_next_frame_time = timer_get_time(&m_machine);
|
||||
m_movie_next_frame_time = m_machine.time();
|
||||
|
||||
// start up an AVI recording
|
||||
if (format == MF_AVI)
|
||||
@ -576,7 +576,7 @@ TIMER_CALLBACK( video_manager::screenless_update_callback )
|
||||
|
||||
void video_manager::postload()
|
||||
{
|
||||
m_movie_next_frame_time = timer_get_time(&m_machine);
|
||||
m_movie_next_frame_time = m_machine.time();
|
||||
}
|
||||
|
||||
|
||||
@ -1229,7 +1229,7 @@ void video_manager::record_frame()
|
||||
|
||||
// start the profiler and get the current time
|
||||
g_profiler.start(PROFILER_MOVIE_REC);
|
||||
attotime curtime = timer_get_time(&m_machine);
|
||||
attotime curtime = m_machine.time();
|
||||
|
||||
// create the bitmap
|
||||
create_snapshot_bitmap(NULL);
|
||||
|
||||
@ -781,7 +781,7 @@ static READ8_HANDLER(vga_crtc_r)
|
||||
int clock=vga.monitor.get_clock();
|
||||
int lines=vga.monitor.get_lines();
|
||||
int columns=vga.monitor.get_columns();
|
||||
int diff = (((timer_get_time(space->machine) - vga.monitor.start_time) * clock).seconds)
|
||||
int diff = (((space->machine->time() - vga.monitor.start_time) * clock).seconds)
|
||||
%(lines*columns);
|
||||
if (diff<columns*vga.monitor.get_sync_lines()) data|=8;
|
||||
diff=diff/lines;
|
||||
@ -791,7 +791,7 @@ static READ8_HANDLER(vga_crtc_r)
|
||||
if (vga.monitor.retrace)
|
||||
{
|
||||
data |= 1;
|
||||
if ((timer_get_time(space->machine) - vga.monitor.start_time) > attotime::from_usec(300))
|
||||
if ((space->machine->time() - vga.monitor.start_time) > attotime::from_usec(300))
|
||||
{
|
||||
data |= 8;
|
||||
vga.monitor.retrace=0;
|
||||
@ -799,9 +799,9 @@ static READ8_HANDLER(vga_crtc_r)
|
||||
}
|
||||
else
|
||||
{
|
||||
if ((timer_get_time(space->machine) - vga.monitor.start_time) > attotime::from_msec(15))
|
||||
if ((space->machine->time() - vga.monitor.start_time) > attotime::from_msec(15))
|
||||
vga.monitor.retrace=1;
|
||||
vga.monitor.start_time=timer_get_time(space->machine);
|
||||
vga.monitor.start_time=space->machine->time();
|
||||
}
|
||||
#else
|
||||
// not working with ps2m30
|
||||
@ -1056,7 +1056,7 @@ WRITE8_HANDLER(vga_port_03c0_w)
|
||||
vga_cpu_interface(space->machine);
|
||||
|
||||
if (vga.sequencer.index == 0)
|
||||
vga.monitor.start_time = timer_get_time(space->machine);
|
||||
vga.monitor.start_time = space->machine->time();
|
||||
}
|
||||
break;
|
||||
case 6:
|
||||
|
||||
@ -911,13 +911,13 @@ static void swap_buffers(voodoo_state *v)
|
||||
/* reset the last_op_time to now and start processing the next command */
|
||||
if (v->pci.op_pending)
|
||||
{
|
||||
v->pci.op_end_time = timer_get_time(v->device->machine);
|
||||
v->pci.op_end_time = v->device->machine->time();
|
||||
flush_fifos(v, v->pci.op_end_time);
|
||||
}
|
||||
|
||||
/* we may be able to unstall now */
|
||||
if (v->pci.stall_state != NOT_STALLED)
|
||||
check_stalled_cpu(v, timer_get_time(v->device->machine));
|
||||
check_stalled_cpu(v, v->device->machine->time());
|
||||
|
||||
/* periodically log rasterizer info */
|
||||
v->stats.swaps++;
|
||||
@ -1016,7 +1016,7 @@ static TIMER_CALLBACK( vblank_callback )
|
||||
if (v->pci.op_pending)
|
||||
{
|
||||
if (LOG_VBLANK_SWAP) logerror("---- vblank flush begin\n");
|
||||
flush_fifos(v, timer_get_time(machine));
|
||||
flush_fifos(v, machine->time());
|
||||
if (LOG_VBLANK_SWAP) logerror("---- vblank flush end\n");
|
||||
}
|
||||
|
||||
@ -2003,10 +2003,10 @@ static void cmdfifo_w(voodoo_state *v, cmdfifo_info *f, offs_t offset, UINT32 da
|
||||
if (cycles > 0)
|
||||
{
|
||||
v->pci.op_pending = TRUE;
|
||||
v->pci.op_end_time = timer_get_time(v->device->machine) + attotime(0, (attoseconds_t)cycles * v->attoseconds_per_cycle);
|
||||
v->pci.op_end_time = v->device->machine->time() + attotime(0, (attoseconds_t)cycles * v->attoseconds_per_cycle);
|
||||
|
||||
if (LOG_FIFO_VERBOSE) logerror("VOODOO.%d.FIFO:direct write start at %d.%08X%08X end at %d.%08X%08X\n", v->index,
|
||||
timer_get_time(v->device->machine).seconds, (UINT32)(timer_get_time(v->device->machine).attoseconds >> 32), (UINT32)timer_get_time(v->device->machine).attoseconds,
|
||||
v->device->machine->time().seconds, (UINT32)(v->device->machine->time().attoseconds >> 32), (UINT32)v->device->machine->time().attoseconds,
|
||||
v->pci.op_end_time.seconds, (UINT32)(v->pci.op_end_time.attoseconds >> 32), (UINT32)v->pci.op_end_time.attoseconds);
|
||||
}
|
||||
}
|
||||
@ -2023,7 +2023,7 @@ static void cmdfifo_w(voodoo_state *v, cmdfifo_info *f, offs_t offset, UINT32 da
|
||||
|
||||
static TIMER_CALLBACK( stall_cpu_callback )
|
||||
{
|
||||
check_stalled_cpu((voodoo_state *)ptr, timer_get_time(machine));
|
||||
check_stalled_cpu((voodoo_state *)ptr, machine->time());
|
||||
}
|
||||
|
||||
|
||||
@ -3464,7 +3464,7 @@ WRITE32_DEVICE_HANDLER( voodoo_w )
|
||||
|
||||
/* if we have something pending, flush the FIFOs up to the current time */
|
||||
if (v->pci.op_pending)
|
||||
flush_fifos(v, timer_get_time(device->machine));
|
||||
flush_fifos(v, device->machine->time());
|
||||
|
||||
/* special handling for registers */
|
||||
if ((offset & 0xc00000/4) == 0)
|
||||
@ -3544,10 +3544,10 @@ WRITE32_DEVICE_HANDLER( voodoo_w )
|
||||
if (cycles)
|
||||
{
|
||||
v->pci.op_pending = TRUE;
|
||||
v->pci.op_end_time = timer_get_time(device->machine) + attotime(0, (attoseconds_t)cycles * v->attoseconds_per_cycle);
|
||||
v->pci.op_end_time = device->machine->time() + attotime(0, (attoseconds_t)cycles * v->attoseconds_per_cycle);
|
||||
|
||||
if (LOG_FIFO_VERBOSE) logerror("VOODOO.%d.FIFO:direct write start at %d.%08X%08X end at %d.%08X%08X\n", v->index,
|
||||
timer_get_time(device->machine).seconds, (UINT32)(timer_get_time(device->machine).attoseconds >> 32), (UINT32)timer_get_time(device->machine).attoseconds,
|
||||
device->machine->time().seconds, (UINT32)(device->machine->time().attoseconds >> 32), (UINT32)device->machine->time().attoseconds,
|
||||
v->pci.op_end_time.seconds, (UINT32)(v->pci.op_end_time.attoseconds >> 32), (UINT32)v->pci.op_end_time.attoseconds);
|
||||
}
|
||||
g_profiler.stop();
|
||||
@ -3597,7 +3597,7 @@ WRITE32_DEVICE_HANDLER( voodoo_w )
|
||||
fifo_items(&v->fbi.fifo) >= 2 * 32 * FBIINIT0_MEMORY_FIFO_HWM(v->reg[fbiInit0].u))
|
||||
{
|
||||
if (LOG_FIFO) logerror("VOODOO.%d.FIFO:voodoo_w hit memory FIFO HWM -- stalling\n", v->index);
|
||||
stall_cpu(v, STALLED_UNTIL_FIFO_LWM, timer_get_time(device->machine));
|
||||
stall_cpu(v, STALLED_UNTIL_FIFO_LWM, device->machine->time());
|
||||
}
|
||||
}
|
||||
|
||||
@ -3606,14 +3606,14 @@ WRITE32_DEVICE_HANDLER( voodoo_w )
|
||||
fifo_space(&v->pci.fifo) <= 2 * FBIINIT0_PCI_FIFO_LWM(v->reg[fbiInit0].u))
|
||||
{
|
||||
if (LOG_FIFO) logerror("VOODOO.%d.FIFO:voodoo_w hit PCI FIFO free LWM -- stalling\n", v->index);
|
||||
stall_cpu(v, STALLED_UNTIL_FIFO_LWM, timer_get_time(device->machine));
|
||||
stall_cpu(v, STALLED_UNTIL_FIFO_LWM, device->machine->time());
|
||||
}
|
||||
|
||||
/* if we weren't ready, and this is a non-FIFO access, stall until the FIFOs are clear */
|
||||
if (stall)
|
||||
{
|
||||
if (LOG_FIFO_VERBOSE) logerror("VOODOO.%d.FIFO:voodoo_w wrote non-FIFO register -- stalling until clear\n", v->index);
|
||||
stall_cpu(v, STALLED_UNTIL_FIFO_EMPTY, timer_get_time(device->machine));
|
||||
stall_cpu(v, STALLED_UNTIL_FIFO_EMPTY, device->machine->time());
|
||||
}
|
||||
|
||||
g_profiler.stop();
|
||||
@ -3891,7 +3891,7 @@ READ32_DEVICE_HANDLER( voodoo_r )
|
||||
|
||||
/* if we have something pending, flush the FIFOs up to the current time */
|
||||
if (v->pci.op_pending)
|
||||
flush_fifos(v, timer_get_time(device->machine));
|
||||
flush_fifos(v, device->machine->time());
|
||||
|
||||
/* target the appropriate location */
|
||||
if (!(offset & (0xc00000/4)))
|
||||
@ -3979,7 +3979,7 @@ READ32_DEVICE_HANDLER( banshee_r )
|
||||
|
||||
/* if we have something pending, flush the FIFOs up to the current time */
|
||||
if (v->pci.op_pending)
|
||||
flush_fifos(v, timer_get_time(device->machine));
|
||||
flush_fifos(v, device->machine->time());
|
||||
|
||||
if (offset < 0x80000/4)
|
||||
result = banshee_io_r(device, offset, mem_mask);
|
||||
@ -4013,7 +4013,7 @@ READ32_DEVICE_HANDLER( banshee_fb_r )
|
||||
|
||||
/* if we have something pending, flush the FIFOs up to the current time */
|
||||
if (v->pci.op_pending)
|
||||
flush_fifos(v, timer_get_time(device->machine));
|
||||
flush_fifos(v, device->machine->time());
|
||||
|
||||
if (offset < v->fbi.lfb_base)
|
||||
{
|
||||
@ -4274,7 +4274,7 @@ WRITE32_DEVICE_HANDLER( banshee_w )
|
||||
|
||||
/* if we have something pending, flush the FIFOs up to the current time */
|
||||
if (v->pci.op_pending)
|
||||
flush_fifos(v, timer_get_time(device->machine));
|
||||
flush_fifos(v, device->machine->time());
|
||||
|
||||
if (offset < 0x80000/4)
|
||||
banshee_io_w(device, offset, data, mem_mask);
|
||||
@ -4307,7 +4307,7 @@ WRITE32_DEVICE_HANDLER( banshee_fb_w )
|
||||
|
||||
/* if we have something pending, flush the FIFOs up to the current time */
|
||||
if (v->pci.op_pending)
|
||||
flush_fifos(v, timer_get_time(device->machine));
|
||||
flush_fifos(v, device->machine->time());
|
||||
|
||||
if (offset < v->fbi.lfb_base)
|
||||
{
|
||||
|
||||
@ -495,7 +495,7 @@ static WRITE8_DEVICE_HANDLER( r6532_porta_w )
|
||||
|
||||
if (state->tms != NULL)
|
||||
{
|
||||
logerror("(%f)%s:TMS5220 data write = %02X\n", timer_get_time(device->machine).as_double(), cpuexec_describe_context(device->machine), riot6532_porta_out_get(state->riot));
|
||||
logerror("(%f)%s:TMS5220 data write = %02X\n", device->machine->time().as_double(), cpuexec_describe_context(device->machine), riot6532_porta_out_get(state->riot));
|
||||
tms5220_data_w(state->tms, 0, data);
|
||||
}
|
||||
}
|
||||
@ -505,7 +505,7 @@ static READ8_DEVICE_HANDLER( r6532_porta_r )
|
||||
exidy_sound_state *state = get_safe_token(device);
|
||||
if (state->tms != NULL)
|
||||
{
|
||||
logerror("(%f)%s:TMS5220 status read = %02X\n", timer_get_time(device->machine).as_double(), cpuexec_describe_context(device->machine), tms5220_status_r(state->tms, 0));
|
||||
logerror("(%f)%s:TMS5220 status read = %02X\n", device->machine->time().as_double(), cpuexec_describe_context(device->machine), tms5220_status_r(state->tms, 0));
|
||||
return tms5220_status_r(state->tms, 0);
|
||||
}
|
||||
else
|
||||
|
||||
@ -694,7 +694,7 @@ static DEVICE_RESET( leland_80186_sound )
|
||||
static IRQ_CALLBACK( int_callback )
|
||||
{
|
||||
leland_sound_state *state = get_safe_token(device->machine->device("custom"));
|
||||
if (LOG_INTERRUPTS) logerror("(%f) **** Acknowledged interrupt vector %02X\n", timer_get_time(device->machine).as_double(), state->i80186.intr.poll_status & 0x1f);
|
||||
if (LOG_INTERRUPTS) logerror("(%f) **** Acknowledged interrupt vector %02X\n", device->machine->time().as_double(), state->i80186.intr.poll_status & 0x1f);
|
||||
|
||||
/* clear the interrupt */
|
||||
cpu_set_input_line(state->i80186.cpu, 0, CLEAR_LINE);
|
||||
@ -809,7 +809,7 @@ generate_int:
|
||||
if (!state->i80186.intr.pending)
|
||||
cputag_set_input_line(machine, "audiocpu", 0, ASSERT_LINE);
|
||||
state->i80186.intr.pending = 1;
|
||||
if (LOG_INTERRUPTS) logerror("(%f) **** Requesting interrupt vector %02X\n", timer_get_time(machine).as_double(), new_vector);
|
||||
if (LOG_INTERRUPTS) logerror("(%f) **** Requesting interrupt vector %02X\n", machine->time().as_double(), new_vector);
|
||||
}
|
||||
|
||||
|
||||
@ -836,7 +836,7 @@ static void handle_eoi(device_t *device, int data)
|
||||
case 0x0f: state->i80186.intr.in_service &= ~0x80; break;
|
||||
default: logerror("%s:ERROR - 80186 EOI with unknown vector %02X\n", cpuexec_describe_context(machine), data & 0x1f);
|
||||
}
|
||||
if (LOG_INTERRUPTS) logerror("(%f) **** Got EOI for vector %02X\n", timer_get_time(machine).as_double(), data & 0x1f);
|
||||
if (LOG_INTERRUPTS) logerror("(%f) **** Got EOI for vector %02X\n", machine->time().as_double(), data & 0x1f);
|
||||
}
|
||||
|
||||
/* non-specific case */
|
||||
@ -849,7 +849,7 @@ static void handle_eoi(device_t *device, int data)
|
||||
if ((state->i80186.intr.timer & 7) == i && (state->i80186.intr.in_service & 0x01))
|
||||
{
|
||||
state->i80186.intr.in_service &= ~0x01;
|
||||
if (LOG_INTERRUPTS) logerror("(%f) **** Got EOI for timer\n", timer_get_time(machine).as_double());
|
||||
if (LOG_INTERRUPTS) logerror("(%f) **** Got EOI for timer\n", machine->time().as_double());
|
||||
return;
|
||||
}
|
||||
|
||||
@ -858,7 +858,7 @@ static void handle_eoi(device_t *device, int data)
|
||||
if ((state->i80186.intr.dma[j] & 7) == i && (state->i80186.intr.in_service & (0x04 << j)))
|
||||
{
|
||||
state->i80186.intr.in_service &= ~(0x04 << j);
|
||||
if (LOG_INTERRUPTS) logerror("(%f) **** Got EOI for DMA%d\n", timer_get_time(machine).as_double(), j);
|
||||
if (LOG_INTERRUPTS) logerror("(%f) **** Got EOI for DMA%d\n", machine->time().as_double(), j);
|
||||
return;
|
||||
}
|
||||
|
||||
@ -867,7 +867,7 @@ static void handle_eoi(device_t *device, int data)
|
||||
if ((state->i80186.intr.ext[j] & 7) == i && (state->i80186.intr.in_service & (0x10 << j)))
|
||||
{
|
||||
state->i80186.intr.in_service &= ~(0x10 << j);
|
||||
if (LOG_INTERRUPTS) logerror("(%f) **** Got EOI for INT%d\n", timer_get_time(machine).as_double(), j);
|
||||
if (LOG_INTERRUPTS) logerror("(%f) **** Got EOI for INT%d\n", machine->time().as_double(), j);
|
||||
return;
|
||||
}
|
||||
}
|
||||
|
||||
@ -431,7 +431,7 @@ static WRITE8_HANDLER( helifire_sound_ctrl_w )
|
||||
state->helifire_dac_timing = DECAY_RATE * log(state->helifire_dac_volume);
|
||||
}
|
||||
|
||||
state->helifire_dac_timing += timer_get_time(space->machine).as_double();
|
||||
state->helifire_dac_timing += space->machine->time().as_double();
|
||||
}
|
||||
|
||||
|
||||
@ -453,7 +453,7 @@ static TIMER_DEVICE_CALLBACK( spacefev_vco_voltage_timer )
|
||||
static TIMER_DEVICE_CALLBACK( helifire_dac_volume_timer )
|
||||
{
|
||||
n8080_state *state = timer.machine->driver_data<n8080_state>();
|
||||
double t = state->helifire_dac_timing - timer_get_time(timer.machine).as_double();
|
||||
double t = state->helifire_dac_timing - timer.machine->time().as_double();
|
||||
|
||||
if (state->helifire_dac_phase)
|
||||
{
|
||||
|
||||
@ -138,7 +138,7 @@ static UINT8 read_port_and_t0( running_machine *machine, int port )
|
||||
static const char *const portnames[] = { "IN0", "IN1", "IN2", "IN3" };
|
||||
|
||||
UINT8 val = input_port_read(machine, portnames[port]);
|
||||
if (timer_get_time(machine) > state->timeout_time)
|
||||
if (machine->time() > state->timeout_time)
|
||||
val ^= 0x80;
|
||||
return val;
|
||||
}
|
||||
@ -196,7 +196,7 @@ static WRITE8_DEVICE_HANDLER( output_port_0_w )
|
||||
UINT8 raw_game_speed = input_port_read(device->machine, "R3");
|
||||
double resistance = raw_game_speed * 25000 / 100;
|
||||
attotime duration = attotime(0, ATTOSECONDS_PER_SECOND * 0.45 * 6.8e-6 * resistance * (data + 1));
|
||||
state->timeout_time = timer_get_time(device->machine) + duration;
|
||||
state->timeout_time = device->machine->time() + duration;
|
||||
|
||||
discrete_sound_w(device, HITME_DOWNCOUNT_VAL, data);
|
||||
discrete_sound_w(device, HITME_OUT0, 1);
|
||||
|
||||
@ -520,7 +520,7 @@ static READ32_HANDLER( trackball32_4bit_r )
|
||||
static int effx, effy;
|
||||
static int lastresult;
|
||||
static attotime lasttime;
|
||||
attotime curtime = timer_get_time(space->machine);
|
||||
attotime curtime = space->machine->time();
|
||||
|
||||
if ((curtime - lasttime) > space->machine->primary_screen->scan_period())
|
||||
{
|
||||
@ -559,7 +559,7 @@ static READ32_HANDLER( trackball32_4bit_p2_r )
|
||||
static int effx, effy;
|
||||
static int lastresult;
|
||||
static attotime lasttime;
|
||||
attotime curtime = timer_get_time(space->machine);
|
||||
attotime curtime = space->machine->time();
|
||||
|
||||
if ((curtime - lasttime) > space->machine->primary_screen->scan_period())
|
||||
{
|
||||
|
||||
@ -92,13 +92,13 @@ static void update_plunger( running_machine *machine )
|
||||
{
|
||||
if (val == 0)
|
||||
{
|
||||
state->time_released = timer_get_time(machine);
|
||||
state->time_released = machine->time();
|
||||
|
||||
if (!state->mask)
|
||||
cpu_set_input_line(state->maincpu, INPUT_LINE_NMI, PULSE_LINE);
|
||||
}
|
||||
else
|
||||
state->time_pushed = timer_get_time(machine);
|
||||
state->time_pushed = machine->time();
|
||||
|
||||
state->prev = val;
|
||||
}
|
||||
@ -126,7 +126,7 @@ static TIMER_CALLBACK( interrupt_callback )
|
||||
static double calc_plunger_pos(running_machine *machine)
|
||||
{
|
||||
mgolf_state *state = machine->driver_data<mgolf_state>();
|
||||
return (timer_get_time(machine).as_double() - state->time_released.as_double()) * (state->time_released.as_double() - state->time_pushed.as_double() + 0.2);
|
||||
return (machine->time().as_double() - state->time_released.as_double()) * (state->time_released.as_double() - state->time_pushed.as_double() + 0.2);
|
||||
}
|
||||
|
||||
|
||||
|
||||
@ -155,7 +155,7 @@ static CUSTOM_INPUT( vicdual_get_composite_blank_comp )
|
||||
static CUSTOM_INPUT( vicdual_get_timer_value )
|
||||
{
|
||||
/* return the state of the timer (old code claims "4MHz square wave", but it was toggled once every 2msec, or 500Hz) */
|
||||
return timer_get_time(field->port->machine).as_ticks(500) & 1;
|
||||
return field->port->machine->time().as_ticks(500) & 1;
|
||||
}
|
||||
|
||||
|
||||
|
||||
@ -31,13 +31,13 @@ static void update_plunger(running_machine *machine)
|
||||
{
|
||||
if (val == 0)
|
||||
{
|
||||
state->time_released = timer_get_time(machine);
|
||||
state->time_released = machine->time();
|
||||
|
||||
if (!state->mask)
|
||||
cputag_set_input_line(machine, "maincpu", INPUT_LINE_NMI, ASSERT_LINE);
|
||||
}
|
||||
else
|
||||
state->time_pushed = timer_get_time(machine);
|
||||
state->time_pushed = machine->time();
|
||||
|
||||
state->prev = val;
|
||||
}
|
||||
@ -77,7 +77,7 @@ static MACHINE_RESET( videopin )
|
||||
static double calc_plunger_pos(running_machine *machine)
|
||||
{
|
||||
videopin_state *state = machine->driver_data<videopin_state>();
|
||||
return (timer_get_time(machine).as_double() - state->time_released.as_double()) * (state->time_released.as_double() - state->time_pushed.as_double() + 0.2);
|
||||
return (machine->time().as_double() - state->time_released.as_double()) * (state->time_released.as_double() - state->time_pushed.as_double() + 0.2);
|
||||
}
|
||||
|
||||
|
||||
|
||||
@ -208,7 +208,7 @@ READ8_HANDLER( decocass_input_r )
|
||||
WRITE8_HANDLER( decocass_reset_w )
|
||||
{
|
||||
decocass_state *state = space->machine->driver_data<decocass_state>();
|
||||
LOG(1,("%10s 6502-PC: %04x decocass_reset_w(%02x): $%02x\n", timer_get_time(space->machine).as_string(6), cpu_get_previouspc(space->cpu), offset, data));
|
||||
LOG(1,("%10s 6502-PC: %04x decocass_reset_w(%02x): $%02x\n", space->machine->time().as_string(6), cpu_get_previouspc(space->cpu), offset, data));
|
||||
state->decocass_reset = data;
|
||||
|
||||
/* CPU #1 active high reset */
|
||||
@ -288,7 +288,7 @@ static READ8_HANDLER( decocass_type1_latch_26_pass_3_inv_2_r )
|
||||
|
||||
data = (BIT(data, 0) << 0) | (BIT(data, 1) << 1) | 0x7c;
|
||||
LOG(4,("%10s 6502-PC: %04x decocass_type1_latch_26_pass_3_inv_2_r(%02x): $%02x <- (%s %s)\n",
|
||||
timer_get_time(space->machine).as_string(6), cpu_get_previouspc(space->cpu), offset, data,
|
||||
space->machine->time().as_string(6), cpu_get_previouspc(space->cpu), offset, data,
|
||||
(data & 1) ? "OBF" : "-",
|
||||
(data & 2) ? "IBF" : "-"));
|
||||
}
|
||||
@ -336,7 +336,7 @@ static READ8_HANDLER( decocass_type1_latch_26_pass_3_inv_2_r )
|
||||
(((prom[promaddr] >> 4) & 1) << MAP7(state->type1_outmap));
|
||||
|
||||
LOG(3,("%10s 6502-PC: %04x decocass_type1_latch_26_pass_3_inv_2_r(%02x): $%02x\n",
|
||||
timer_get_time(space->machine).as_string(6), cpu_get_previouspc(space->cpu), offset, data));
|
||||
space->machine->time().as_string(6), cpu_get_previouspc(space->cpu), offset, data));
|
||||
|
||||
state->latch1 = save; /* latch the data for the next A0 == 0 read */
|
||||
}
|
||||
@ -368,7 +368,7 @@ static READ8_HANDLER( decocass_type1_pass_136_r )
|
||||
|
||||
data = (BIT(data, 0) << 0) | (BIT(data, 1) << 1) | 0x7c;
|
||||
LOG(4,("%10s 6502-PC: %04x decocass_type1_pass_136_r(%02x): $%02x <- (%s %s)\n",
|
||||
timer_get_time(space->machine).as_string(6), cpu_get_previouspc(space->cpu), offset, data,
|
||||
space->machine->time().as_string(6), cpu_get_previouspc(space->cpu), offset, data,
|
||||
(data & 1) ? "OBF" : "-",
|
||||
(data & 2) ? "IBF" : "-"));
|
||||
}
|
||||
@ -416,7 +416,7 @@ static READ8_HANDLER( decocass_type1_pass_136_r )
|
||||
(((prom[promaddr] >> 4) & 1) << MAP7(state->type1_outmap));
|
||||
|
||||
LOG(3,("%10s 6502-PC: %04x decocass_type1_pass_136_r(%02x): $%02x\n",
|
||||
timer_get_time(space->machine).as_string(6), cpu_get_previouspc(space->cpu), offset, data));
|
||||
space->machine->time().as_string(6), cpu_get_previouspc(space->cpu), offset, data));
|
||||
|
||||
state->latch1 = save; /* latch the data for the next A0 == 0 read */
|
||||
}
|
||||
@ -448,7 +448,7 @@ static READ8_HANDLER( decocass_type1_latch_27_pass_3_inv_2_r )
|
||||
|
||||
data = (BIT(data, 0) << 0) | (BIT(data, 1) << 1) | 0x7c;
|
||||
LOG(4,("%10s 6502-PC: %04x decocass_type1_latch_27_pass_3_inv_2_r(%02x): $%02x <- (%s %s)\n",
|
||||
timer_get_time(space->machine).as_string(6), cpu_get_previouspc(space->cpu), offset, data,
|
||||
space->machine->time().as_string(6), cpu_get_previouspc(space->cpu), offset, data,
|
||||
(data & 1) ? "OBF" : "-",
|
||||
(data & 2) ? "IBF" : "-"));
|
||||
}
|
||||
@ -496,7 +496,7 @@ static READ8_HANDLER( decocass_type1_latch_27_pass_3_inv_2_r )
|
||||
(((state->latch1 >> MAP7(state->type1_inmap)) & 1) << MAP7(state->type1_outmap));
|
||||
|
||||
LOG(3,("%10s 6502-PC: %04x decocass_type1_latch_27_pass_3_inv_2_r(%02x): $%02x\n",
|
||||
timer_get_time(space->machine).as_string(6), cpu_get_previouspc(space->cpu), offset, data));
|
||||
space->machine->time().as_string(6), cpu_get_previouspc(space->cpu), offset, data));
|
||||
|
||||
state->latch1 = save; /* latch the data for the next A0 == 0 read */
|
||||
}
|
||||
@ -528,7 +528,7 @@ static READ8_HANDLER( decocass_type1_latch_26_pass_5_inv_2_r )
|
||||
|
||||
data = (BIT(data, 0) << 0) | (BIT(data, 1) << 1) | 0x7c;
|
||||
LOG(4,("%10s 6502-PC: %04x decocass_type1_latch_26_pass_5_inv_2_r(%02x): $%02x <- (%s %s)\n",
|
||||
timer_get_time(space->machine).as_string(6), cpu_get_previouspc(space->cpu), offset, data,
|
||||
space->machine->time().as_string(6), cpu_get_previouspc(space->cpu), offset, data,
|
||||
(data & 1) ? "OBF" : "-",
|
||||
(data & 2) ? "IBF" : "-"));
|
||||
}
|
||||
@ -576,7 +576,7 @@ static READ8_HANDLER( decocass_type1_latch_26_pass_5_inv_2_r )
|
||||
(((prom[promaddr] >> 4) & 1) << MAP7(state->type1_outmap));
|
||||
|
||||
LOG(3,("%10s 6502-PC: %04x decocass_type1_latch_26_pass_5_inv_2_r(%02x): $%02x\n",
|
||||
timer_get_time(space->machine).as_string(6), cpu_get_previouspc(space->cpu), offset, data));
|
||||
space->machine->time().as_string(6), cpu_get_previouspc(space->cpu), offset, data));
|
||||
|
||||
state->latch1 = save; /* latch the data for the next A0 == 0 read */
|
||||
}
|
||||
@ -610,7 +610,7 @@ static READ8_HANDLER( decocass_type1_latch_16_pass_3_inv_1_r )
|
||||
|
||||
data = (BIT(data, 0) << 0) | (BIT(data, 1) << 1) | 0x7c;
|
||||
LOG(4,("%10s 6502-PC: %04x decocass_type1_latch_16_pass_3_inv_1_r(%02x): $%02x <- (%s %s)\n",
|
||||
timer_get_time(space->machine).as_string(6), cpu_get_previouspc(space->cpu), offset, data,
|
||||
space->machine->time().as_string(6), cpu_get_previouspc(space->cpu), offset, data,
|
||||
(data & 1) ? "OBF" : "-",
|
||||
(data & 2) ? "IBF" : "-"));
|
||||
}
|
||||
@ -658,7 +658,7 @@ static READ8_HANDLER( decocass_type1_latch_16_pass_3_inv_1_r )
|
||||
(((prom[promaddr] >> 4) & 1) << MAP7(state->type1_outmap));
|
||||
|
||||
LOG(3,("%10s 6502-PC: %04x decocass_type1_latch_16_pass_3_inv_1_r(%02x): $%02x\n",
|
||||
timer_get_time(space->machine).as_string(6), cpu_get_previouspc(space->cpu), offset, data));
|
||||
space->machine->time().as_string(6), cpu_get_previouspc(space->cpu), offset, data));
|
||||
|
||||
state->latch1 = save; /* latch the data for the next A0 == 0 read */
|
||||
}
|
||||
@ -688,7 +688,7 @@ static READ8_HANDLER( decocass_type2_r )
|
||||
{
|
||||
UINT8 *prom = space->machine->region("dongle")->base();
|
||||
data = prom[256 * state->type2_d2_latch + state->type2_promaddr];
|
||||
LOG(3,("%10s 6502-PC: %04x decocass_type2_r(%02x): $%02x <- prom[%03x]\n", timer_get_time(space->machine).as_string(6), cpu_get_previouspc(space->cpu), offset, data, 256 * state->type2_d2_latch + state->type2_promaddr));
|
||||
LOG(3,("%10s 6502-PC: %04x decocass_type2_r(%02x): $%02x <- prom[%03x]\n", space->machine->time().as_string(6), cpu_get_previouspc(space->cpu), offset, data, 256 * state->type2_d2_latch + state->type2_promaddr));
|
||||
}
|
||||
else
|
||||
{
|
||||
@ -702,7 +702,7 @@ static READ8_HANDLER( decocass_type2_r )
|
||||
else
|
||||
data = offset & 0xff;
|
||||
|
||||
LOG(3,("%10s 6502-PC: %04x decocass_type2_r(%02x): $%02x <- 8041-%s\n", timer_get_time(space->machine).as_string(6), cpu_get_previouspc(space->cpu), offset, data, offset & 1 ? "STATUS" : "DATA"));
|
||||
LOG(3,("%10s 6502-PC: %04x decocass_type2_r(%02x): $%02x <- 8041-%s\n", space->machine->time().as_string(6), cpu_get_previouspc(space->cpu), offset, data, offset & 1 ? "STATUS" : "DATA"));
|
||||
}
|
||||
return data;
|
||||
}
|
||||
@ -714,18 +714,18 @@ static WRITE8_HANDLER( decocass_type2_w )
|
||||
{
|
||||
if (1 == (offset & 1))
|
||||
{
|
||||
LOG(4,("%10s 6502-PC: %04x decocass_e5xx_w(%02x): $%02x -> set PROM+D2 latch", timer_get_time(space->machine).as_string(6), cpu_get_previouspc(space->cpu), offset, data));
|
||||
LOG(4,("%10s 6502-PC: %04x decocass_e5xx_w(%02x): $%02x -> set PROM+D2 latch", space->machine->time().as_string(6), cpu_get_previouspc(space->cpu), offset, data));
|
||||
}
|
||||
else
|
||||
{
|
||||
state->type2_promaddr = data;
|
||||
LOG(3,("%10s 6502-PC: %04x decocass_e5xx_w(%02x): $%02x -> set PROM addr $%02x\n", timer_get_time(space->machine).as_string(6), cpu_get_previouspc(space->cpu), offset, data, state->type2_promaddr));
|
||||
LOG(3,("%10s 6502-PC: %04x decocass_e5xx_w(%02x): $%02x -> set PROM addr $%02x\n", space->machine->time().as_string(6), cpu_get_previouspc(space->cpu), offset, data, state->type2_promaddr));
|
||||
return;
|
||||
}
|
||||
}
|
||||
else
|
||||
{
|
||||
LOG(3,("%10s 6502-PC: %04x decocass_e5xx_w(%02x): $%02x -> %s ", timer_get_time(space->machine).as_string(6), cpu_get_previouspc(space->cpu), offset, data, offset & 1 ? "8041-CMND" : "8041 DATA"));
|
||||
LOG(3,("%10s 6502-PC: %04x decocass_e5xx_w(%02x): $%02x -> %s ", space->machine->time().as_string(6), cpu_get_previouspc(space->cpu), offset, data, offset & 1 ? "8041-CMND" : "8041 DATA"));
|
||||
}
|
||||
if (1 == (offset & 1))
|
||||
{
|
||||
@ -770,7 +770,7 @@ static READ8_HANDLER( decocass_type3_r )
|
||||
{
|
||||
UINT8 *prom = space->machine->region("dongle")->base();
|
||||
data = prom[state->type3_ctrs];
|
||||
LOG(3,("%10s 6502-PC: %04x decocass_type3_r(%02x): $%02x <- prom[$%03x]\n", timer_get_time(space->machine).as_string(6), cpu_get_previouspc(space->cpu), offset, data, state->type3_ctrs));
|
||||
LOG(3,("%10s 6502-PC: %04x decocass_type3_r(%02x): $%02x <- prom[$%03x]\n", space->machine->time().as_string(6), cpu_get_previouspc(space->cpu), offset, data, state->type3_ctrs));
|
||||
if (++state->type3_ctrs == 4096)
|
||||
state->type3_ctrs = 0;
|
||||
}
|
||||
@ -779,12 +779,12 @@ static READ8_HANDLER( decocass_type3_r )
|
||||
if (0 == (offset & E5XX_MASK))
|
||||
{
|
||||
data = upi41_master_r(state->mcu, 1);
|
||||
LOG(4,("%10s 6502-PC: %04x decocass_type3_r(%02x): $%02x <- 8041 STATUS\n", timer_get_time(space->machine).as_string(6), cpu_get_previouspc(space->cpu), offset, data));
|
||||
LOG(4,("%10s 6502-PC: %04x decocass_type3_r(%02x): $%02x <- 8041 STATUS\n", space->machine->time().as_string(6), cpu_get_previouspc(space->cpu), offset, data));
|
||||
}
|
||||
else
|
||||
{
|
||||
data = 0xff; /* open data bus? */
|
||||
LOG(4,("%10s 6502-PC: %04x decocass_type3_r(%02x): $%02x <- open bus\n", timer_get_time(space->machine).as_string(6), cpu_get_previouspc(space->cpu), offset, data));
|
||||
LOG(4,("%10s 6502-PC: %04x decocass_type3_r(%02x): $%02x <- open bus\n", space->machine->time().as_string(6), cpu_get_previouspc(space->cpu), offset, data));
|
||||
}
|
||||
}
|
||||
}
|
||||
@ -793,7 +793,7 @@ static READ8_HANDLER( decocass_type3_r )
|
||||
if (1 == state->type3_pal_19)
|
||||
{
|
||||
save = data = 0xff; /* open data bus? */
|
||||
LOG(3,("%10s 6502-PC: %04x decocass_type3_r(%02x): $%02x <- open bus", timer_get_time(space->machine).as_string(6), cpu_get_previouspc(space->cpu), offset, data));
|
||||
LOG(3,("%10s 6502-PC: %04x decocass_type3_r(%02x): $%02x <- open bus", space->machine->time().as_string(6), cpu_get_previouspc(space->cpu), offset, data));
|
||||
}
|
||||
else
|
||||
{
|
||||
@ -924,7 +924,7 @@ static READ8_HANDLER( decocass_type3_r )
|
||||
(BIT(save, 7) << 7);
|
||||
}
|
||||
state->type3_d0_latch = save & 1;
|
||||
LOG(3,("%10s 6502-PC: %04x decocass_type3_r(%02x): $%02x '%c' <- 8041-DATA\n", timer_get_time(space->machine).as_string(6), cpu_get_previouspc(space->cpu), offset, data, (data >= 32) ? data : '.'));
|
||||
LOG(3,("%10s 6502-PC: %04x decocass_type3_r(%02x): $%02x '%c' <- 8041-DATA\n", space->machine->time().as_string(6), cpu_get_previouspc(space->cpu), offset, data, (data >= 32) ? data : '.'));
|
||||
}
|
||||
else
|
||||
{
|
||||
@ -938,7 +938,7 @@ static READ8_HANDLER( decocass_type3_r )
|
||||
(BIT(save, 5) << 5) |
|
||||
(BIT(save, 6) << 7) |
|
||||
(BIT(save, 7) << 6);
|
||||
LOG(3,("%10s 6502-PC: %04x decocass_type3_r(%02x): $%02x '%c' <- open bus (D0 replaced with latch)\n", timer_get_time(space->machine).as_string(6), cpu_get_previouspc(space->cpu), offset, data, (data >= 32) ? data : '.'));
|
||||
LOG(3,("%10s 6502-PC: %04x decocass_type3_r(%02x): $%02x '%c' <- open bus (D0 replaced with latch)\n", space->machine->time().as_string(6), cpu_get_previouspc(space->cpu), offset, data, (data >= 32) ? data : '.'));
|
||||
state->type3_d0_latch = save & 1;
|
||||
}
|
||||
}
|
||||
@ -955,7 +955,7 @@ static WRITE8_HANDLER( decocass_type3_w )
|
||||
if (1 == state->type3_pal_19)
|
||||
{
|
||||
state->type3_ctrs = data << 4;
|
||||
LOG(3,("%10s 6502-PC: %04x decocass_e5xx_w(%02x): $%02x -> %s\n", timer_get_time(space->machine).as_string(6), cpu_get_previouspc(space->cpu), offset, data, "LDCTRS"));
|
||||
LOG(3,("%10s 6502-PC: %04x decocass_e5xx_w(%02x): $%02x -> %s\n", space->machine->time().as_string(6), cpu_get_previouspc(space->cpu), offset, data, "LDCTRS"));
|
||||
return;
|
||||
}
|
||||
else
|
||||
@ -967,11 +967,11 @@ static WRITE8_HANDLER( decocass_type3_w )
|
||||
if (1 == state->type3_pal_19)
|
||||
{
|
||||
/* write nowhere?? */
|
||||
LOG(3,("%10s 6502-PC: %04x decocass_e5xx_w(%02x): $%02x -> %s\n", timer_get_time(space->machine).as_string(6), cpu_get_previouspc(space->cpu), offset, data, "nowhere?"));
|
||||
LOG(3,("%10s 6502-PC: %04x decocass_e5xx_w(%02x): $%02x -> %s\n", space->machine->time().as_string(6), cpu_get_previouspc(space->cpu), offset, data, "nowhere?"));
|
||||
return;
|
||||
}
|
||||
}
|
||||
LOG(3,("%10s 6502-PC: %04x decocass_e5xx_w(%02x): $%02x -> %s\n", timer_get_time(space->machine).as_string(6), cpu_get_previouspc(space->cpu), offset, data, offset & 1 ? "8041-CMND" : "8041-DATA"));
|
||||
LOG(3,("%10s 6502-PC: %04x decocass_e5xx_w(%02x): $%02x -> %s\n", space->machine->time().as_string(6), cpu_get_previouspc(space->cpu), offset, data, offset & 1 ? "8041-CMND" : "8041-DATA"));
|
||||
upi41_master_w(state->mcu, offset, data);
|
||||
}
|
||||
|
||||
@ -997,12 +997,12 @@ static READ8_HANDLER( decocass_type4_r )
|
||||
if (0 == (offset & E5XX_MASK))
|
||||
{
|
||||
data = upi41_master_r(state->mcu, 1);
|
||||
LOG(4,("%10s 6502-PC: %04x decocass_type4_r(%02x): $%02x <- 8041 STATUS\n", timer_get_time(space->machine).as_string(6), cpu_get_previouspc(space->cpu), offset, data));
|
||||
LOG(4,("%10s 6502-PC: %04x decocass_type4_r(%02x): $%02x <- 8041 STATUS\n", space->machine->time().as_string(6), cpu_get_previouspc(space->cpu), offset, data));
|
||||
}
|
||||
else
|
||||
{
|
||||
data = 0xff; /* open data bus? */
|
||||
LOG(4,("%10s 6502-PC: %04x decocass_type4_r(%02x): $%02x <- open bus\n", timer_get_time(space->machine).as_string(6), cpu_get_previouspc(space->cpu), offset, data));
|
||||
LOG(4,("%10s 6502-PC: %04x decocass_type4_r(%02x): $%02x <- open bus\n", space->machine->time().as_string(6), cpu_get_previouspc(space->cpu), offset, data));
|
||||
}
|
||||
}
|
||||
else
|
||||
@ -1012,7 +1012,7 @@ static READ8_HANDLER( decocass_type4_r )
|
||||
UINT8 *prom = space->machine->region("dongle")->base();
|
||||
|
||||
data = prom[state->type4_ctrs];
|
||||
LOG(3,("%10s 6502-PC: %04x decocass_type4_r(%02x): $%02x '%c' <- PROM[%04x]\n", timer_get_time(space->machine).as_string(6), cpu_get_previouspc(space->cpu), offset, data, (data >= 32) ? data : '.', state->type4_ctrs));
|
||||
LOG(3,("%10s 6502-PC: %04x decocass_type4_r(%02x): $%02x '%c' <- PROM[%04x]\n", space->machine->time().as_string(6), cpu_get_previouspc(space->cpu), offset, data, (data >= 32) ? data : '.', state->type4_ctrs));
|
||||
state->type4_ctrs = (state->type4_ctrs + 1) & 0x7fff;
|
||||
}
|
||||
else
|
||||
@ -1020,12 +1020,12 @@ static READ8_HANDLER( decocass_type4_r )
|
||||
if (0 == (offset & E5XX_MASK))
|
||||
{
|
||||
data = upi41_master_r(state->mcu, 0);
|
||||
LOG(3,("%10s 6502-PC: %04x decocass_type4_r(%02x): $%02x '%c' <- open bus (D0 replaced with latch)\n", timer_get_time(space->machine).as_string(6), cpu_get_previouspc(space->cpu), offset, data, (data >= 32) ? data : '.'));
|
||||
LOG(3,("%10s 6502-PC: %04x decocass_type4_r(%02x): $%02x '%c' <- open bus (D0 replaced with latch)\n", space->machine->time().as_string(6), cpu_get_previouspc(space->cpu), offset, data, (data >= 32) ? data : '.'));
|
||||
}
|
||||
else
|
||||
{
|
||||
data = 0xff; /* open data bus? */
|
||||
LOG(4,("%10s 6502-PC: %04x decocass_type4_r(%02x): $%02x <- open bus\n", timer_get_time(space->machine).as_string(6), cpu_get_previouspc(space->cpu), offset, data));
|
||||
LOG(4,("%10s 6502-PC: %04x decocass_type4_r(%02x): $%02x <- open bus\n", space->machine->time().as_string(6), cpu_get_previouspc(space->cpu), offset, data));
|
||||
}
|
||||
}
|
||||
}
|
||||
@ -1041,7 +1041,7 @@ static WRITE8_HANDLER( decocass_type4_w )
|
||||
if (1 == state->type4_latch)
|
||||
{
|
||||
state->type4_ctrs = (state->type4_ctrs & 0x00ff) | ((data & 0x7f) << 8);
|
||||
LOG(3,("%10s 6502-PC: %04x decocass_e5xx_w(%02x): $%02x -> CTRS MSB (%04x)\n", timer_get_time(space->machine).as_string(6), cpu_get_previouspc(space->cpu), offset, data, state->type4_ctrs));
|
||||
LOG(3,("%10s 6502-PC: %04x decocass_e5xx_w(%02x): $%02x -> CTRS MSB (%04x)\n", space->machine->time().as_string(6), cpu_get_previouspc(space->cpu), offset, data, state->type4_ctrs));
|
||||
return;
|
||||
}
|
||||
else
|
||||
@ -1055,11 +1055,11 @@ static WRITE8_HANDLER( decocass_type4_w )
|
||||
if (state->type4_latch)
|
||||
{
|
||||
state->type4_ctrs = (state->type4_ctrs & 0xff00) | data;
|
||||
LOG(3,("%10s 6502-PC: %04x decocass_e5xx_w(%02x): $%02x -> CTRS LSB (%04x)\n", timer_get_time(space->machine).as_string(6), cpu_get_previouspc(space->cpu), offset, data, state->type4_ctrs));
|
||||
LOG(3,("%10s 6502-PC: %04x decocass_e5xx_w(%02x): $%02x -> CTRS LSB (%04x)\n", space->machine->time().as_string(6), cpu_get_previouspc(space->cpu), offset, data, state->type4_ctrs));
|
||||
return;
|
||||
}
|
||||
}
|
||||
LOG(3,("%10s 6502-PC: %04x decocass_e5xx_w(%02x): $%02x -> %s\n", timer_get_time(space->machine).as_string(6), cpu_get_previouspc(space->cpu), offset, data, offset & 1 ? "8041-CMND" : "8041-DATA"));
|
||||
LOG(3,("%10s 6502-PC: %04x decocass_e5xx_w(%02x): $%02x -> %s\n", space->machine->time().as_string(6), cpu_get_previouspc(space->cpu), offset, data, offset & 1 ? "8041-CMND" : "8041-DATA"));
|
||||
upi41_master_w(state->mcu, offset, data);
|
||||
}
|
||||
|
||||
@ -1082,12 +1082,12 @@ static READ8_HANDLER( decocass_type5_r )
|
||||
if (0 == (offset & E5XX_MASK))
|
||||
{
|
||||
data = upi41_master_r(state->mcu, 1);
|
||||
LOG(4,("%10s 6502-PC: %04x decocass_type5_r(%02x): $%02x <- 8041 STATUS\n", timer_get_time(space->machine).as_string(6), cpu_get_previouspc(space->cpu), offset, data));
|
||||
LOG(4,("%10s 6502-PC: %04x decocass_type5_r(%02x): $%02x <- 8041 STATUS\n", space->machine->time().as_string(6), cpu_get_previouspc(space->cpu), offset, data));
|
||||
}
|
||||
else
|
||||
{
|
||||
data = 0xff; /* open data bus? */
|
||||
LOG(4,("%10s 6502-PC: %04x decocass_type5_r(%02x): $%02x <- open bus\n", timer_get_time(space->machine).as_string(6), cpu_get_previouspc(space->cpu), offset, data));
|
||||
LOG(4,("%10s 6502-PC: %04x decocass_type5_r(%02x): $%02x <- open bus\n", space->machine->time().as_string(6), cpu_get_previouspc(space->cpu), offset, data));
|
||||
}
|
||||
}
|
||||
else
|
||||
@ -1095,19 +1095,19 @@ static READ8_HANDLER( decocass_type5_r )
|
||||
if (state->type5_latch)
|
||||
{
|
||||
data = 0x55; /* Only a fixed value? It looks like this is all we need to do */
|
||||
LOG(3,("%10s 6502-PC: %04x decocass_type5_r(%02x): $%02x '%c' <- fixed value???\n", timer_get_time(space->machine).as_string(6), cpu_get_previouspc(space->cpu), offset, data, (data >= 32) ? data : '.'));
|
||||
LOG(3,("%10s 6502-PC: %04x decocass_type5_r(%02x): $%02x '%c' <- fixed value???\n", space->machine->time().as_string(6), cpu_get_previouspc(space->cpu), offset, data, (data >= 32) ? data : '.'));
|
||||
}
|
||||
else
|
||||
{
|
||||
if (0 == (offset & E5XX_MASK))
|
||||
{
|
||||
data = upi41_master_r(state->mcu, 0);
|
||||
LOG(3,("%10s 6502-PC: %04x decocass_type5_r(%02x): $%02x '%c' <- open bus (D0 replaced with latch)\n", timer_get_time(space->machine).as_string(6), cpu_get_previouspc(space->cpu), offset, data, (data >= 32) ? data : '.'));
|
||||
LOG(3,("%10s 6502-PC: %04x decocass_type5_r(%02x): $%02x '%c' <- open bus (D0 replaced with latch)\n", space->machine->time().as_string(6), cpu_get_previouspc(space->cpu), offset, data, (data >= 32) ? data : '.'));
|
||||
}
|
||||
else
|
||||
{
|
||||
data = 0xff; /* open data bus? */
|
||||
LOG(4,("%10s 6502-PC: %04x decocass_type5_r(%02x): $%02x <- open bus\n", timer_get_time(space->machine).as_string(6), cpu_get_previouspc(space->cpu), offset, data));
|
||||
LOG(4,("%10s 6502-PC: %04x decocass_type5_r(%02x): $%02x <- open bus\n", space->machine->time().as_string(6), cpu_get_previouspc(space->cpu), offset, data));
|
||||
}
|
||||
}
|
||||
}
|
||||
@ -1122,7 +1122,7 @@ static WRITE8_HANDLER( decocass_type5_w )
|
||||
{
|
||||
if (1 == state->type5_latch)
|
||||
{
|
||||
LOG(3,("%10s 6502-PC: %04x decocass_e5xx_w(%02x): $%02x -> %s\n", timer_get_time(space->machine).as_string(6), cpu_get_previouspc(space->cpu), offset, data, "latch #2??"));
|
||||
LOG(3,("%10s 6502-PC: %04x decocass_e5xx_w(%02x): $%02x -> %s\n", space->machine->time().as_string(6), cpu_get_previouspc(space->cpu), offset, data, "latch #2??"));
|
||||
return;
|
||||
}
|
||||
else
|
||||
@ -1134,11 +1134,11 @@ static WRITE8_HANDLER( decocass_type5_w )
|
||||
if (state->type5_latch)
|
||||
{
|
||||
/* write nowhere?? */
|
||||
LOG(3,("%10s 6502-PC: %04x decocass_e5xx_w(%02x): $%02x -> %s\n", timer_get_time(space->machine).as_string(6), cpu_get_previouspc(space->cpu), offset, data, "nowhere?"));
|
||||
LOG(3,("%10s 6502-PC: %04x decocass_e5xx_w(%02x): $%02x -> %s\n", space->machine->time().as_string(6), cpu_get_previouspc(space->cpu), offset, data, "nowhere?"));
|
||||
return;
|
||||
}
|
||||
}
|
||||
LOG(3,("%10s 6502-PC: %04x decocass_e5xx_w(%02x): $%02x -> %s\n", timer_get_time(space->machine).as_string(6), cpu_get_previouspc(space->cpu), offset, data, offset & 1 ? "8041-CMND" : "8041-DATA"));
|
||||
LOG(3,("%10s 6502-PC: %04x decocass_e5xx_w(%02x): $%02x -> %s\n", space->machine->time().as_string(6), cpu_get_previouspc(space->cpu), offset, data, offset & 1 ? "8041-CMND" : "8041-DATA"));
|
||||
upi41_master_w(state->mcu, offset, data);
|
||||
}
|
||||
|
||||
@ -1160,12 +1160,12 @@ static READ8_HANDLER( decocass_nodong_r )
|
||||
if (0 == (offset & E5XX_MASK))
|
||||
{
|
||||
data = upi41_master_r(state->mcu, 1);
|
||||
LOG(4,("%10s 6502-PC: %04x decocass_nodong_r(%02x): $%02x <- 8041 STATUS\n", timer_get_time(space->machine).as_string(6), cpu_get_previouspc(space->cpu), offset, data));
|
||||
LOG(4,("%10s 6502-PC: %04x decocass_nodong_r(%02x): $%02x <- 8041 STATUS\n", space->machine->time().as_string(6), cpu_get_previouspc(space->cpu), offset, data));
|
||||
}
|
||||
else
|
||||
{
|
||||
data = 0xff; /* open data bus? */
|
||||
LOG(4,("%10s 6502-PC: %04x decocass_nodong_r(%02x): $%02x <- open bus\n", timer_get_time(space->machine).as_string(6), cpu_get_previouspc(space->cpu), offset, data));
|
||||
LOG(4,("%10s 6502-PC: %04x decocass_nodong_r(%02x): $%02x <- open bus\n", space->machine->time().as_string(6), cpu_get_previouspc(space->cpu), offset, data));
|
||||
}
|
||||
}
|
||||
else
|
||||
@ -1173,12 +1173,12 @@ static READ8_HANDLER( decocass_nodong_r )
|
||||
if (0 == (offset & E5XX_MASK))
|
||||
{
|
||||
data = upi41_master_r(state->mcu, 0);
|
||||
LOG(3,("%10s 6502-PC: %04x decocass_nodong_r(%02x): $%02x '%c' <- open bus (D0 replaced with latch)\n", timer_get_time(space->machine).as_string(6), cpu_get_previouspc(space->cpu), offset, data, (data >= 32) ? data : '.'));
|
||||
LOG(3,("%10s 6502-PC: %04x decocass_nodong_r(%02x): $%02x '%c' <- open bus (D0 replaced with latch)\n", space->machine->time().as_string(6), cpu_get_previouspc(space->cpu), offset, data, (data >= 32) ? data : '.'));
|
||||
}
|
||||
else
|
||||
{
|
||||
data = 0xff; /* open data bus? */
|
||||
LOG(4,("%10s 6502-PC: %04x decocass_nodong_r(%02x): $%02x <- open bus\n", timer_get_time(space->machine).as_string(6), cpu_get_previouspc(space->cpu), offset, data));
|
||||
LOG(4,("%10s 6502-PC: %04x decocass_nodong_r(%02x): $%02x <- open bus\n", space->machine->time().as_string(6), cpu_get_previouspc(space->cpu), offset, data));
|
||||
}
|
||||
}
|
||||
|
||||
@ -1212,7 +1212,7 @@ READ8_HANDLER( decocass_e5xx_r )
|
||||
(!tape_is_present(state->cassette) << 7); /* D7 = cassette present */
|
||||
|
||||
LOG(4,("%10s 6502-PC: %04x decocass_e5xx_r(%02x): $%02x <- STATUS (%s%s%s%s%s%s%s%s)\n",
|
||||
timer_get_time(space->machine).as_string(6),
|
||||
space->machine->time().as_string(6),
|
||||
cpu_get_previouspc(space->cpu),
|
||||
offset, data,
|
||||
data & 0x01 ? "" : "REQ/",
|
||||
@ -1245,7 +1245,7 @@ WRITE8_HANDLER( decocass_e5xx_w )
|
||||
|
||||
if (0 == (offset & E5XX_MASK))
|
||||
{
|
||||
LOG(3,("%10s 6502-PC: %04x decocass_e5xx_w(%02x): $%02x -> %s\n", timer_get_time(space->machine).as_string(6), cpu_get_previouspc(space->cpu), offset, data, offset & 1 ? "8041-CMND" : "8041-DATA"));
|
||||
LOG(3,("%10s 6502-PC: %04x decocass_e5xx_w(%02x): $%02x -> %s\n", space->machine->time().as_string(6), cpu_get_previouspc(space->cpu), offset, data, offset & 1 ? "8041-CMND" : "8041-DATA"));
|
||||
upi41_master_w(state->mcu, offset & 1, data);
|
||||
#ifdef MAME_DEBUG
|
||||
decocass_fno(space->machine, offset, data);
|
||||
@ -1253,7 +1253,7 @@ WRITE8_HANDLER( decocass_e5xx_w )
|
||||
}
|
||||
else
|
||||
{
|
||||
LOG(3,("%10s 6502-PC: %04x decocass_e5xx_w(%02x): $%02x -> dongle\n", timer_get_time(space->machine).as_string(6), cpu_get_previouspc(space->cpu), offset, data));
|
||||
LOG(3,("%10s 6502-PC: %04x decocass_e5xx_w(%02x): $%02x -> dongle\n", space->machine->time().as_string(6), cpu_get_previouspc(space->cpu), offset, data));
|
||||
}
|
||||
}
|
||||
|
||||
@ -1702,7 +1702,7 @@ WRITE8_HANDLER( i8041_p1_w )
|
||||
if (data != state->i8041_p1_write_latch)
|
||||
{
|
||||
LOG(4,("%10s 8041-PC: %03x i8041_p1_w: $%02x (%s%s%s%s%s%s%s%s)\n",
|
||||
timer_get_time(space->machine).as_string(6),
|
||||
space->machine->time().as_string(6),
|
||||
cpu_get_previouspc(space->cpu),
|
||||
data,
|
||||
data & 0x01 ? "" : "DATA-WRT",
|
||||
@ -1739,7 +1739,7 @@ READ8_HANDLER( i8041_p1_r )
|
||||
if (data != state->i8041_p1_read_latch)
|
||||
{
|
||||
LOG(4,("%10s 8041-PC: %03x i8041_p1_r: $%02x (%s%s%s%s%s%s%s%s)\n",
|
||||
timer_get_time(space->machine).as_string(6),
|
||||
space->machine->time().as_string(6),
|
||||
cpu_get_previouspc(space->cpu),
|
||||
data,
|
||||
data & 0x01 ? "" : "DATA-WRT",
|
||||
@ -1761,7 +1761,7 @@ WRITE8_HANDLER( i8041_p2_w )
|
||||
if (data != state->i8041_p2_write_latch)
|
||||
{
|
||||
LOG(4,("%10s 8041-PC: %03x i8041_p2_w: $%02x (%s%s%s%s%s%s%s%s)\n",
|
||||
timer_get_time(space->machine).as_string(6),
|
||||
space->machine->time().as_string(6),
|
||||
cpu_get_previouspc(space->cpu),
|
||||
data,
|
||||
data & 0x01 ? "" : "FNO/",
|
||||
@ -1787,7 +1787,7 @@ READ8_HANDLER( i8041_p2_r )
|
||||
if (data != state->i8041_p2_read_latch)
|
||||
{
|
||||
LOG(4,("%10s 8041-PC: %03x i8041_p2_r: $%02x (%s%s%s%s%s%s%s%s)\n",
|
||||
timer_get_time(space->machine).as_string(6),
|
||||
space->machine->time().as_string(6),
|
||||
cpu_get_previouspc(space->cpu),
|
||||
data,
|
||||
data & 0x01 ? "" : "FNO/",
|
||||
|
||||
@ -300,7 +300,7 @@ UINT8 midway_serial_pic2_status_r(address_space *space)
|
||||
/* if we're still holding the data ready bit high, do it */
|
||||
if (pic.latch & 0xf00)
|
||||
{
|
||||
if (timer_get_time(space->machine) > pic.latch_expire_time)
|
||||
if (space->machine->time() > pic.latch_expire_time)
|
||||
pic.latch &= 0xff;
|
||||
else
|
||||
pic.latch -= 0x100;
|
||||
@ -347,7 +347,7 @@ void midway_serial_pic2_w(address_space *space, UINT8 data)
|
||||
|
||||
/* store in the latch, along with a bit to indicate we have data */
|
||||
pic.latch = (data & 0x00f) | 0x480;
|
||||
pic.latch_expire_time = timer_get_time(machine) + attotime::from_msec(1);
|
||||
pic.latch_expire_time = machine->time() + attotime::from_msec(1);
|
||||
if (data & 0x10)
|
||||
{
|
||||
int cmd = pic.state ? (pic.state & 0x0f) : (pic.latch & 0x0f);
|
||||
|
||||
@ -1156,7 +1156,7 @@ READ32_HANDLER( n64_ai_reg_r )
|
||||
}
|
||||
else if (ai_status & 0x40000000)
|
||||
{
|
||||
double secs_left = (timer_firetime(audio_timer) - timer_get_time(space->machine)).as_double();
|
||||
double secs_left = (timer_firetime(audio_timer) - space->machine->time()).as_double();
|
||||
unsigned int samples_left = secs_left * DACRATE_NTSC / (ai_dacrate + 1);
|
||||
return samples_left * 4;
|
||||
}
|
||||
|
||||
@ -31,11 +31,11 @@
|
||||
|
||||
#define VERBOSE_DBG 0 /* general debug messages */
|
||||
#define DBG_LOG(N,M,A) \
|
||||
if(VERBOSE_DBG>=N){ if( M )logerror("%11.6f: %-24s",timer_get_time(pc_keyb.machine).as_double(),(char*)M ); logerror A; }
|
||||
if(VERBOSE_DBG>=N){ if( M )logerror("%11.6f: %-24s",pc_keyb.machine->time().as_double(),(char*)M ); logerror A; }
|
||||
|
||||
#define VERBOSE_JOY 0 /* JOY (joystick port) */
|
||||
#define JOY_LOG(N,M,A) \
|
||||
if(VERBOSE_JOY>=N){ if( M )logerror("%11.6f: %-24s",timer_get_time(pc_keyb.machine).as_double(),(char*)M ); logerror A; }
|
||||
if(VERBOSE_JOY>=N){ if( M )logerror("%11.6f: %-24s",pc_keyb.machine->time().as_double(),(char*)M ); logerror A; }
|
||||
|
||||
|
||||
static TIMER_CALLBACK( pc_keyb_timer );
|
||||
|
||||
@ -1143,7 +1143,7 @@ static void slapstic_log(running_machine *machine, offs_t offset)
|
||||
slapsticlog = fopen("slapstic.log", "w");
|
||||
if (slapsticlog)
|
||||
{
|
||||
attotime time = timer_get_time(machine);
|
||||
attotime time = machine->time();
|
||||
|
||||
if ((time - last_time) > attotime::from_seconds(1))
|
||||
fprintf(slapsticlog, "------------------------------------\n");
|
||||
|
||||
@ -415,7 +415,7 @@ static void compute_sensors(running_machine *machine)
|
||||
inters_to_words(inter1, inter2, inter3, &beams, &word1, &word2, &word3);
|
||||
words_to_sensors(word1, word2, word3, beams, &sensor0, &sensor1, &sensor2, &sensor3);
|
||||
|
||||
logerror("%15f: Sensor values: %04x %04x %04x %04x\n", timer_get_time(machine).as_double(), sensor0, sensor1, sensor2, sensor3);
|
||||
logerror("%15f: Sensor values: %04x %04x %04x %04x\n", machine->time().as_double(), sensor0, sensor1, sensor2, sensor3);
|
||||
}
|
||||
|
||||
|
||||
|
||||
@ -95,8 +95,8 @@ static void update_irq_encoder(running_machine *machine, int line, int state)
|
||||
static WRITE_LINE_DEVICE_HANDLER( v_irq4_w )
|
||||
{
|
||||
update_irq_encoder(device->machine, INPUT_LINE_IRQ4, state);
|
||||
vertigo_vproc(device->machine->device<cpu_device>("maincpu")->attotime_to_cycles(timer_get_time(device->machine) - irq4_time), state);
|
||||
irq4_time = timer_get_time(device->machine);
|
||||
vertigo_vproc(device->machine->device<cpu_device>("maincpu")->attotime_to_cycles(device->machine->time() - irq4_time), state);
|
||||
irq4_time = device->machine->time();
|
||||
}
|
||||
|
||||
|
||||
@ -229,7 +229,7 @@ MACHINE_RESET( vertigo )
|
||||
ttl74148_update(ttl74148);
|
||||
vertigo_vproc_reset(machine);
|
||||
|
||||
irq4_time = timer_get_time(machine);
|
||||
irq4_time = machine->time();
|
||||
irq_state = 7;
|
||||
}
|
||||
|
||||
|
||||
@ -308,7 +308,7 @@ static void execute_blit(running_machine *machine)
|
||||
g_profiler.stop();
|
||||
|
||||
#if (!INSTANT_BLIT)
|
||||
blitter_busy_until = timer_get_time(machine) + attotime::from_nsec(w*h*20);
|
||||
blitter_busy_until = machine->time() + attotime::from_nsec(w*h*20);
|
||||
#endif
|
||||
}
|
||||
|
||||
@ -322,7 +322,7 @@ READ16_HANDLER( artmagic_blitter_r )
|
||||
*/
|
||||
UINT16 result = 0xffef | (blitter_page << 4);
|
||||
#if (!INSTANT_BLIT)
|
||||
if (timer_get_time(space->machine) < blitter_busy_until)
|
||||
if (space->machine->time() < blitter_busy_until)
|
||||
result ^= 6;
|
||||
#endif
|
||||
return result;
|
||||
|
||||
@ -179,7 +179,7 @@ void mini_osd_interface::update(bool skip_redraw)
|
||||
primlist.release_lock();
|
||||
|
||||
// after 5 seconds, exit
|
||||
if (timer_get_time(&machine()) > attotime::from_seconds(5))
|
||||
if (machine().time() > attotime::from_seconds(5))
|
||||
machine().schedule_exit();
|
||||
}
|
||||
|
||||
|
||||
Loading…
Reference in New Issue
Block a user