public void adjust(attotime start_delay, int param, attotime period) //void adjust(attotime start_delay, s32 param = 0, const attotime &periodicity = attotime::never);
{
// if this is the callback timer, mark it modified
device_scheduler scheduler = machine().scheduler();
if (scheduler.callback_timer() == this)
{
scheduler.callback_timer_modified_set(true);
}
// compute the time of the next firing and insert into the list
m_param = param;
m_enabled = true;
// clamp negative times to 0
if (start_delay.seconds() < 0)
{
start_delay = attotime.zero;
}
// set the start and expire times
m_start = scheduler.time();
m_expire = m_start + start_delay;
m_period = period;
// remove and re-insert the timer in its new order
scheduler.timer_list_remove(this);
scheduler.timer_list_insert(this);
// if this was inserted as the head, abort the current timeslice and resync
if (this == scheduler.first_timer())
{
scheduler.abort_timeslice();
}
}
public void Dispose()
{
if (m_scheduler != null)
{
m_scheduler.Dispose();
}
m_scheduler = null;
if (m_debugger != null)
{
m_debugger.Dispose();
}
m_debugger = null;
if (m_tilemap != null)
{
m_tilemap.Dispose();
}
m_tilemap = null;
if (m_render != null)
{
m_render.Dispose();
}
m_render = null;
m_isDisposed = true;
}
//-------------------------------------------------
// schedule_next_period - schedule the next
// period
//-------------------------------------------------
public void schedule_next_period()
{
// advance by one period
m_start = m_expire;
m_expire += m_period;
// remove and re-insert us
device_scheduler scheduler = machine().scheduler();
scheduler.timer_list_remove(this);
scheduler.timer_list_insert(this);
}
string m_string_buffer; //mutable util::ovectorstream m_string_buffer;
// construction/destruction
//-------------------------------------------------
// running_machine - constructor
//-------------------------------------------------
public running_machine(machine_config _config, machine_manager manager)
{
m_side_effects_disabled = 0;
debug_flags = 0;
m_config = _config;
m_system = _config.gamedrv();
m_manager = manager;
m_current_phase = machine_phase.PREINIT;
m_paused = false;
m_hard_reset_pending = false;
m_exit_pending = false;
m_soft_reset_timer = null;
m_rand_seed = 0x9d14abd7;
m_ui_active = _config.options().ui_active();
m_basename = _config.gamedrv().name;
m_sample_rate = _config.options().sample_rate();
m_saveload_schedule = saveload_schedule.NONE;
m_saveload_schedule_time = attotime.zero;
m_saveload_searchpath = null;
m_save = new save_manager(this);
m_memory = new memory_manager(this);
m_ioport = new ioport_manager(this);
m_scheduler = new device_scheduler(this);
m_scheduler.device_scheduler_after_ctor(this);
for (int i = 0; i < m_notifier_list.Length; i++)
{
m_notifier_list[i] = new std.list <notifier_callback_item>();
}
m_base_time = 0;
// set the machine on all devices
device_enumerator iter = new device_enumerator(root_device());
foreach (device_t device in iter)
{
device.set_machine(this);
}
// fetch core options
if (options().debug())
{
debug_flags = (DEBUG_FLAG_ENABLED | DEBUG_FLAG_CALL_HOOK) | (DEBUG_FLAG_OSD_ENABLED);
}
}
public void data_w(offs_t offset, u8 data)
{
if (BIT(offset, 0) != 0)
{
// ZINTRQ
// if jumpered this way, the Z80 write strobe pulses the MCU interrupt line
// should be PULSE_LINE because it's edge sensitive, but diexec only allows PULSE_LINE on reset and NMI
if (int_mode.WRITE == m_int_mode)
{
m_mcu.op0.set_input_line(M68705_IRQ_LINE, HOLD_LINE);
}
}
else
{
// ZLWRITE
device_scheduler sched = machine().scheduler();
sched.synchronize(do_host_write, data);
sched.boost_interleave(attotime.zero, attotime.from_usec(10));
}
}
//-------------------------------------------------
// interface_pre_start - work to be done prior to
// actually starting a device
//-------------------------------------------------
public override void interface_pre_start()
{
m_scheduler = device().machine().scheduler();
// bind delegates
//m_vblank_interrupt.resolve();
//m_timed_interrupt.resolve();
//m_driver_irq.resolve();
// fill in the initial states
int index = new device_enumerator(device().machine().root_device()).indexof(device());
m_suspend = SUSPEND_REASON_RESET;
m_profiler = (profile_type)(index + profile_type.PROFILER_DEVICE_FIRST);
m_inttrigger = index + TRIGGER_INT;
// allocate timers if we need them
if (m_timed_interrupt_period != attotime.zero)
{
m_timedint_timer = m_scheduler.timer_alloc(trigger_periodic_interrupt, this);
}
}
public attoseconds_t m_attoseconds_per_cycle; // attoseconds per adjusted clock cycle
// construction/destruction
//-------------------------------------------------
// device_execute_interface - constructor
//-------------------------------------------------
public device_execute_interface(machine_config mconfig, device_t device)
: base(device, "execute")
{
m_scheduler = null;
m_disabled = false;
m_vblank_interrupt = null;
m_vblank_interrupt_screen = null;
m_timed_interrupt = null;
m_timed_interrupt_period = attotime.zero;
m_nextexec = null;
m_driver_irq = null;
m_timedint_timer = null;
m_profiler = profile_type.PROFILER_IDLE;
m_icountptr = null;
m_cycles_running = 0;
m_cycles_stolen = 0;
m_suspend = 0;
m_nextsuspend = 0;
m_eatcycles = 0;
m_nexteatcycles = 0;
m_trigger = 0;
m_inttrigger = 0;
m_totalcycles = 0;
m_divisor = 0;
m_divshift = 0;
m_cycles_per_second = 0;
m_attoseconds_per_cycle = 0;
for (int line = 0; line < m_input.Length; line++)
{
m_input[line] = new device_input();
}
// configure the fast accessor
assert(device.interfaces().m_execute == null);
device.interfaces().m_execute = this;
}
