自学教程：C++ timer_expired_delegate函数代码示例

VIDEO_START_MEMBER(aim65_state,aim65){	m_print_timer = machine().scheduler().timer_alloc(timer_expired_delegate(FUNC(aim65_state::aim65_printer_timer),this));	m_printerRAM = std::make_unique<uint16_t[]>((600 * 10 * 2) / 2);	memset(m_printerRAM, 0, videoram_size);	VIDEO_START_CALL_MEMBER(generic);	m_printer_x = 0;	m_printer_y = 0;	m_printer_dir = 0;	m_flag_a = 0;	m_flag_b = 0;	m_printer_level = 0;}

void beta_state::machine_start(){	m_led_refresh_timer = machine().scheduler().timer_alloc(timer_expired_delegate(FUNC(beta_state::led_refresh),this));	// state saving	save_item(NAME(m_eprom_oe));	save_item(NAME(m_eprom_ce));	save_item(NAME(m_eprom_addr));	save_item(NAME(m_eprom_data));	save_item(NAME(m_old_data));	save_item(NAME(m_ls145_p));	save_item(NAME(m_segment));}

void famibox_state::machine_start(){	m_nt_ram = auto_alloc_array(machine(), UINT8, 0x1000);	m_nt_page[0] = m_nt_ram;	m_nt_page[1] = m_nt_ram + 0x400;	m_nt_page[2] = m_nt_ram + 0x800;	m_nt_page[3] = m_nt_ram + 0xc00;	machine().device("ppu")->memory().space(AS_PROGRAM).install_readwrite_handler(0x2000, 0x3eff, read8_delegate(FUNC(famibox_state::famibox_nt_r), this), write8_delegate(FUNC(famibox_state::famibox_nt_w), this));	machine().device("ppu")->memory().space(AS_PROGRAM).install_read_bank(0x0000, 0x1fff, "ppubank1");	famicombox_bankswitch(0);	m_attract_timer = machine().scheduler().timer_alloc(timer_expired_delegate(FUNC(famibox_state::famicombox_attract_timer_callback),this));	m_gameplay_timer = machine().scheduler().timer_alloc(timer_expired_delegate(FUNC(famibox_state::famicombox_gameplay_timer_callback),this));	m_exception_cause = 0xff;	m_exception_mask = 0;	m_attract_timer_period = 0;	m_money_reg = 0;	m_coins = 0;}

void tms34061_device::device_start(){	/* resolve callbak */	m_interrupt_cb.resolve();	/* reset the data */	m_vrammask = m_vramsize - 1;	/* allocate memory for VRAM */	m_vram = auto_alloc_array_clear(machine(), UINT8, m_vramsize + 256 * 2);	/* allocate memory for latch RAM */	m_latchram = auto_alloc_array_clear(machine(), UINT8, m_vramsize + 256 * 2);	/* add some buffer space for VRAM and latch RAM */	m_vram += 256;	m_latchram += 256;	/* point the shift register to the base of VRAM for now */	m_shiftreg = m_vram;	/* initialize registers to their default values from the manual */	m_regs[TMS34061_HORENDSYNC]   = 0x0010;	m_regs[TMS34061_HORENDBLNK]   = 0x0020;	m_regs[TMS34061_HORSTARTBLNK] = 0x01f0;	m_regs[TMS34061_HORTOTAL]     = 0x0200;	m_regs[TMS34061_VERENDSYNC]   = 0x0004;	m_regs[TMS34061_VERENDBLNK]   = 0x0010;	m_regs[TMS34061_VERSTARTBLNK] = 0x00f0;	m_regs[TMS34061_VERTOTAL]     = 0x0100;	m_regs[TMS34061_DISPUPDATE]   = 0x0000;	m_regs[TMS34061_DISPSTART]    = 0x0000;	m_regs[TMS34061_VERINT]       = 0x0000;	m_regs[TMS34061_CONTROL1]     = 0x7000;	m_regs[TMS34061_CONTROL2]     = 0x0600;	m_regs[TMS34061_STATUS]       = 0x0000;	m_regs[TMS34061_XYOFFSET]     = 0x0010;	m_regs[TMS34061_XYADDRESS]    = 0x0000;	m_regs[TMS34061_DISPADDRESS]  = 0x0000;	m_regs[TMS34061_VERCOUNTER]   = 0x0000;	/* start vertical interrupt timer */	m_timer = machine().scheduler().timer_alloc(timer_expired_delegate(FUNC(tms34061_device::interrupt), this));	save_item(NAME(m_regs));	save_item(NAME(m_xmask));	save_item(NAME(m_yshift));	save_pointer(NAME(m_vram), m_vramsize);	save_pointer(NAME(m_latchram), m_vramsize);	save_item(NAME(m_latchdata));}

MACHINE_START_MEMBER(gb_state,sgb){	m_sgb_packets = -1;	/* Allocate the serial timer, and disable it */	m_gb_serial_timer = machine().scheduler().timer_alloc(timer_expired_delegate(FUNC(gb_state::gb_serial_timer_proc),this));	m_gb_serial_timer->enable( 0 );	save_gb_base();	save_sgb_only();	if (m_cartslot && m_cartslot->get_sgb_hack())		machine().device<sgb_lcd_device>("lcd")->set_sgb_hack(TRUE);}

void kbdc8042_device::device_start(){	// resolve callbacks	m_system_reset_func.resolve(m_system_reset_cb, *this);	m_gate_a20_func.resolve(m_gate_a20_cb, *this);	m_input_buffer_full_func.resolve(m_input_buffer_full_cb, *this);	m_output_buffer_empty_func.resolve(m_output_buffer_empty_cb, *this);	m_speaker_func.resolve(m_speaker_cb, *this);	m_getout2_func.resolve(m_getout2_cb, *this);	machine().scheduler().timer_pulse(attotime::from_hz(60), timer_expired_delegate(FUNC(kbdc8042_device::kbdc8042_time),this));	at_keyboard_init(machine(), AT_KEYBOARD_TYPE_AT);	at_keyboard_set_scan_code_set(1);	m_operation_write_state = 0; /* first write to 0x60 might occur before anything can set this */}

void amis2152_cpu_device::device_start(){	amis2000_base_device::device_start();	m_d2f_timer = machine().scheduler().timer_alloc(timer_expired_delegate(FUNC(amis2152_cpu_device::d2f_timer_cb), this));	// zerofill	m_d2f_latch = 0;	m_fout_state = 0;	// register for savestates	save_item(NAME(m_d2f_latch));	save_item(NAME(m_fout_state));}

void mame_machine_manager::create_custom(running_machine& machine){	// start the inifile manager	m_inifile = std::make_unique<inifile_manager>(machine, m_ui->options());	// allocate autoboot timer	m_autoboot_timer = machine.scheduler().timer_alloc(timer_expired_delegate(FUNC(mame_machine_manager::autoboot_callback), this));	// start favorite manager	m_favorite = std::make_unique<favorite_manager>(machine, m_ui->options());	// set up the cheat engine	m_cheat = std::make_unique<cheat_manager>(machine);}

void sprint4_state::machine_reset(){	machine().scheduler().timer_set(machine().primary_screen->time_until_pos(32), timer_expired_delegate(FUNC(sprint4_state::nmi_callback),this), 32);	memset(m_steer_FF1, 0, sizeof m_steer_FF1);	memset(m_steer_FF2, 0, sizeof m_steer_FF2);	m_gear[0] = 1;	m_gear[1] = 1;	m_gear[2] = 1;	m_gear[3] = 1;	m_da_latch = 0;}

void pb1000_state::machine_start(){	std::string region_tag;	m_rom_reg = memregion("rom");	if (m_card1)		m_card1_reg = memregion(region_tag.assign(m_card1->tag()).append(GENERIC_ROM_REGION_TAG).c_str());	if (m_card2)		m_card2_reg = memregion(region_tag.assign(m_card2->tag()).append(GENERIC_ROM_REGION_TAG).c_str());	membank("bank1")->set_base(m_rom_reg->base());	m_kb_timer = machine().scheduler().timer_alloc(timer_expired_delegate(FUNC(pb1000_state::keyboard_timer),this));	m_kb_timer->adjust(attotime::from_hz(192), 0, attotime::from_hz(192));}

void cdislave_device::device_start(){	save_item(NAME(m_channel[0].m_out_buf[0]));	save_item(NAME(m_channel[0].m_out_buf[1]));	save_item(NAME(m_channel[0].m_out_buf[2]));	save_item(NAME(m_channel[0].m_out_buf[3]));	save_item(NAME(m_channel[0].m_out_index));	save_item(NAME(m_channel[0].m_out_count));	save_item(NAME(m_channel[0].m_out_cmd));	save_item(NAME(m_channel[1].m_out_buf[0]));	save_item(NAME(m_channel[1].m_out_buf[1]));	save_item(NAME(m_channel[1].m_out_buf[2]));	save_item(NAME(m_channel[1].m_out_buf[3]));	save_item(NAME(m_channel[1].m_out_index));	save_item(NAME(m_channel[1].m_out_count));	save_item(NAME(m_channel[1].m_out_cmd));	save_item(NAME(m_channel[2].m_out_buf[0]));	save_item(NAME(m_channel[2].m_out_buf[1]));	save_item(NAME(m_channel[2].m_out_buf[2]));	save_item(NAME(m_channel[2].m_out_buf[3]));	save_item(NAME(m_channel[2].m_out_index));	save_item(NAME(m_channel[2].m_out_count));	save_item(NAME(m_channel[2].m_out_cmd));	save_item(NAME(m_channel[3].m_out_buf[0]));	save_item(NAME(m_channel[3].m_out_buf[1]));	save_item(NAME(m_channel[3].m_out_buf[2]));	save_item(NAME(m_channel[3].m_out_buf[3]));	save_item(NAME(m_channel[3].m_out_index));	save_item(NAME(m_channel[3].m_out_count));	save_item(NAME(m_channel[3].m_out_cmd));	save_item(NAME(m_in_buf));	save_item(NAME(m_in_index));	save_item(NAME(m_in_count));	save_item(NAME(m_polling_active));	save_item(NAME(m_xbus_interrupt_enable));	save_item(NAME(m_lcd_state));	save_item(NAME(m_real_mouse_x));	save_item(NAME(m_real_mouse_y));	save_item(NAME(m_fake_mouse_x));	save_item(NAME(m_fake_mouse_y));	m_interrupt_timer = machine().scheduler().timer_alloc(timer_expired_delegate(FUNC(cdislave_device::trigger_readback_int), this));	m_interrupt_timer->adjust(attotime::never);}

void irisha_state::machine_start(){	static const char *const keynames[] = {		"LINE0", "LINE1", "LINE2", "LINE3", "LINE4",		"LINE5", "LINE6", "LINE7", "LINE8", "LINE9"	};	for ( int i = 0; i < 10; i++ )	{		m_io_ports[i] = ioport( keynames[i] );	}	machine().scheduler().timer_pulse(attotime::from_msec(30), timer_expired_delegate(FUNC(irisha_state::irisha_key),this));}

INPUT_PORTS_ENDMACHINE_START_MEMBER(moo_state,moo){	save_item(NAME(m_cur_control2));	save_item(NAME(m_alpha_enabled));	save_item(NAME(m_sprite_colorbase));	save_item(NAME(m_layer_colorbase));	save_item(NAME(m_layerpri));	save_item(NAME(m_protram));	m_dmaend_timer = machine().scheduler().timer_alloc(timer_expired_delegate(FUNC(moo_state::dmaend_callback),this));}

void z80ctc_device::ctc_channel::start(z80ctc_device *device, int index){	// initialize state	m_device = device;	m_index = index;	m_timer = m_device->machine().scheduler().timer_alloc(timer_expired_delegate(FUNC(z80ctc_device::ctc_channel::timer_callback), this));	// register for save states	m_device->save_item(NAME(m_mode), m_index);	m_device->save_item(NAME(m_tconst), m_index);	m_device->save_item(NAME(m_down), m_index);	m_device->save_item(NAME(m_extclk), m_index);	m_device->save_item(NAME(m_int_state), m_index);}

void ay31015_device::device_start(){	m_read_si.resolve(read_si_cb, *this);	m_write_so.resolve(write_so_cb, *this);	m_status_changed.resolve(status_changed_cb, *this);	m_tx_clock = transmitter_clock;	m_rx_clock = receiver_clock;	m_rx_timer = machine().scheduler().timer_alloc(timer_expired_delegate(FUNC(ay31015_device::rx_process),this));	m_tx_timer = machine().scheduler().timer_alloc(timer_expired_delegate(FUNC(ay31015_device::tx_process),this));	update_rx_timer();	update_tx_timer();	save_item(NAME(m_pins));	save_item(NAME(m_control_reg));	save_item(NAME(m_status_reg));	save_item(NAME(m_second_stop_bit));	save_item(NAME(m_total_pulses));	save_item(NAME(m_internal_sample));	save_item(NAME(m_rx_state));	save_item(NAME(m_rx_data));	save_item(NAME(m_rx_buffer));	save_item(NAME(m_rx_bit_count));	save_item(NAME(m_rx_parity));	save_item(NAME(m_rx_pulses));	save_item(NAME(m_rx_clock));	save_item(NAME(m_tx_state));	save_item(NAME(m_tx_data));	save_item(NAME(m_tx_buffer));	save_item(NAME(m_tx_parity));	save_item(NAME(m_tx_pulses));	save_item(NAME(m_tx_clock));}

ROM_ENDDRIVER_INIT_MEMBER(sslam_state,sslam){	m_track = 0;	m_melody = 0;	m_bar = 0;	save_item(NAME(m_track));	save_item(NAME(m_melody));	save_item(NAME(m_bar));	save_item(NAME(m_snd_bank));	m_music_timer = machine().scheduler().timer_alloc(timer_expired_delegate(FUNC(sslam_state::music_playback),this));}

MACHINE_START_MEMBER( mc1502_state, mc1502 ){	DBG_LOG(0,"init",("machine_start()/n"));	/*	       Keyboard polling circuit holds IRQ1 high until a key is	       pressed, then it starts a timer that pulses IRQ1 low each	       40ms (check) for 20ms (check) until all keys are released.	       Last pulse causes BIOS to write a 'break' scancode into port 60h.	 */	m_pic8259->ir1_w(1);	memset(&m_kbd, 0, sizeof(m_kbd));	m_kbd.keyb_signal_timer = machine().scheduler().timer_alloc(timer_expired_delegate(FUNC(mc1502_state::keyb_signal_callback),this));	m_kbd.keyb_signal_timer->adjust( attotime::from_msec(20), 0, attotime::from_msec(20) );}

MACHINE_CONFIG_ENDMACHINE_START_MEMBER(md_boot_state, md_6button){	MACHINE_START_CALL_MEMBER(md_bootleg);	m_io_pad_6b[0] = ioport("EXTRA1");	m_io_pad_6b[1] = ioport("EXTRA2");	m_io_pad_6b[2] = ioport("IN0");	m_io_pad_6b[3] = ioport("UNK");	// setup timers for 6 button pads	for (int i = 0; i < 3; i++)		m_io_timeout[i] = machine().scheduler().timer_alloc(timer_expired_delegate(FUNC(md_base_state::io_timeout_timer_callback),this), (void*)(FPTR)i);}

void sorcerer_state::machine_reset(){	address_space &space = machine().device("maincpu")->memory().space(AS_PROGRAM);	/* Initialize cassette interface */	m_cass_data.output.length = 0;	m_cass_data.output.level = 1;	m_cass_data.input.length = 0;	m_cass_data.input.bit = 1;	m_fe = 0xff;	sorcerer_fe_w(space, 0, 0, 0xff);	membank("boot")->set_entry(1);	machine().scheduler().timer_set(attotime::from_usec(10), timer_expired_delegate(FUNC(sorcerer_state::sorcerer_reset),this));}

INPUT_PORTS_END/****************************************************************************** Machine Drivers******************************************************************************/TIMER_CALLBACK_MEMBER(dectalk_state::outfifo_read_cb){	UINT16 data;	dac_device *speaker = machine().device<dac_device>("dac");	data = dectalk_outfifo_r(machine());#ifdef VERBOSE	if (data!= 0x8000) logerror("sample output: %04X/n", data);#endif	machine().scheduler().timer_set(attotime::from_hz(10000), timer_expired_delegate(FUNC(dectalk_state::outfifo_read_cb),this));	speaker->write_signed16(data);}

void kbdc8042_device::at_8042_receive(UINT8 data){	if (LOG_KEYBOARD)		logerror("at_8042_receive Received 0x%02x/n", data);	m_data = data;	m_keyboard.received = 1;	if (!m_input_buffer_full_cb.isnull())	{		m_input_buffer_full_cb(1);		/* Lets 8952's timers do their job before clear the interrupt line, */		/* else Keyboard interrupt never happens. */		machine().scheduler().timer_set(attotime::from_usec(2), timer_expired_delegate(FUNC(kbdc8042_device::kbdc8042_clr_int),this));	}}

void v3021_device::device_start(){	/* let's call the timer callback every second */	machine().scheduler().timer_pulse(attotime::from_hz(clock() / XTAL_32_768kHz), timer_expired_delegate(FUNC(v3021_device::timer_callback),this));	system_time systime;	machine().base_datetime(systime);	m_rtc.day = ((systime.local_time.mday / 10)<<4) | ((systime.local_time.mday % 10) & 0xf);	m_rtc.month = (((systime.local_time.month+1) / 10) << 4) | (((systime.local_time.month+1) % 10) & 0xf);	m_rtc.wday = 1 << systime.local_time.weekday;	m_rtc.year = (((systime.local_time.year % 100)/10)<<4) | ((systime.local_time.year % 10) & 0xf);	m_rtc.hour = ((systime.local_time.hour / 10)<<4) | ((systime.local_time.hour % 10) & 0xf);	m_rtc.min = ((systime.local_time.minute / 10)<<4) | ((systime.local_time.minute % 10) & 0xf);	m_rtc.sec = ((systime.local_time.second / 10)<<4) | ((systime.local_time.second % 10) & 0xf);}

VIDEO_START_MEMBER(atarisy2_state,atarisy2){	/* initialize banked memory */	m_alpha_tilemap->basemem().set(&m_vram[0x0000], 0x2000, 16, ENDIANNESS_NATIVE, 2);	m_playfield_tilemap->basemem().set(&m_vram[0x2000], 0x2000, 16, ENDIANNESS_NATIVE, 2);	m_mob->set_spriteram(&m_vram[0x0c00], 0x0400);	/* reset the statics */	m_yscroll_reset_timer = machine().scheduler().timer_alloc(timer_expired_delegate(FUNC(atarisy2_state::reset_yscroll_callback),this));	m_videobank = 0;	/* save states */	save_item(NAME(m_playfield_tile_bank));	save_item(NAME(m_videobank));	save_item(NAME(m_vram));}

GFXDECODE_END/************************************* * *  Machine setup * *************************************/void orbit_state::machine_start(){	m_irq_off_timer = machine().scheduler().timer_alloc(timer_expired_delegate(FUNC(orbit_state::irq_off), this));	save_item(NAME(m_flip_screen));}

void psxrcnt_device::device_start(){	int n;	m_irq0_handler.resolve_safe();	m_irq1_handler.resolve_safe();	m_irq2_handler.resolve_safe();	for( n = 0; n < 3; n++ )	{		root_counter[ n ].timer = machine().scheduler().timer_alloc( timer_expired_delegate( FUNC( psxrcnt_device::root_finished ), this ) );		state_save_register_item( machine(), "psxroot", NULL, n, root_counter[ n ].n_count );		state_save_register_item( machine(), "psxroot", NULL, n, root_counter[ n ].n_mode );		state_save_register_item( machine(), "psxroot", NULL, n, root_counter[ n ].n_target );		state_save_register_item( machine(), "psxroot", NULL, n, root_counter[ n ].n_start );	}}

void dio16_98544_device::device_start(){	// set_nubus_device makes m_slot valid	set_dio_device();	m_rom = device().machine().root_device().memregion(this->subtag(HP98544_ROM_REGION).c_str())->base();	m_vram.resize(VRAM_SIZE);	m_dio->install_memory(0x200000, 0x2fffff, read16_delegate(FUNC(dio16_98544_device::vram_r), this),							write16_delegate(FUNC(dio16_98544_device::vram_w), this));	m_dio->install_memory(0x560000, 0x563fff, read16_delegate(FUNC(dio16_98544_device::rom_r), this),							write16_delegate(FUNC(dio16_98544_device::rom_w), this));	m_dio->install_memory(0x564000, 0x567fff, read16_delegate(FUNC(dio16_98544_device::ctrl_r), this),							write16_delegate(FUNC(dio16_98544_device::ctrl_w), this));	m_cursor_timer = machine().scheduler().timer_alloc(timer_expired_delegate(FUNC(dio16_98544_device::cursor_callback),this));	m_cursor_timer->adjust(attotime::from_hz(3));}

void itech32_state::video_start(){	int i;	/* allocate memory */	m_videoram = std::make_unique<UINT16[]>(VRAM_WIDTH * (m_vram_height + 16) * 2);	memset(m_videoram.get(), 0xff, VRAM_WIDTH * (m_vram_height + 16) * 2 * 2);	/* videoplane[0] is the foreground; videoplane[1] is the background */	m_videoplane[0] = &m_videoram[0 * VRAM_WIDTH * (m_vram_height + 16) + 8 * VRAM_WIDTH];	m_videoplane[1] = &m_videoram[1 * VRAM_WIDTH * (m_vram_height + 16) + 8 * VRAM_WIDTH];	/* set the masks */	m_vram_mask = VRAM_WIDTH * m_vram_height - 1;	m_vram_xmask = VRAM_WIDTH - 1;	m_vram_ymask = m_vram_height - 1;	/* clear the planes initially */	for (i = 0; i < VRAM_WIDTH * m_vram_height; i++)		m_videoplane[0][i] = m_videoplane[1][i] = 0xff;	/* fetch the GROM base */	m_grom_base = memregion("gfx1")->base();	m_grom_size = memregion("gfx1")->bytes();	m_grom_bank = 0;	m_grom_bank_mask = m_grom_size >> 24;	if (m_grom_bank_mask == 2)		m_grom_bank_mask = 3;	/* reset statics */	memset(m_video, 0, 0x80);	m_scanline_timer = machine().scheduler().timer_alloc(timer_expired_delegate(FUNC(itech32_state::scanline_interrupt),this));	m_enable_latch[0] = 1;	m_enable_latch[1] = (m_planes > 1) ? 1 : 0;	save_item(NAME(m_xfer_xcount));	save_item(NAME(m_xfer_ycount));	save_item(NAME(m_xfer_xcur));	save_item(NAME(m_xfer_ycur));	save_item(NAME(m_grom_bank));	save_item(NAME(m_color_latch));	save_item(NAME(m_enable_latch));	save_pointer(NAME(m_videoram.get()), VRAM_WIDTH * (m_vram_height + 16) * 2);}

void tmp68301_device::device_start(){	int i;	for (i = 0; i < 3; i++)		m_tmp68301_timer[i] = machine().scheduler().timer_alloc(timer_expired_delegate(FUNC(tmp68301_device::timer_callback), this));	m_in_parallel_cb.resolve_safe(0);	m_out_parallel_cb.resolve_safe();	save_item(NAME(m_regs));	save_item(NAME(m_icr));	save_item(NAME(m_irq_vector));	save_item(NAME(m_imr));	save_item(NAME(m_iisr));	save_item(NAME(m_scr));	save_item(NAME(m_pdir));	save_item(NAME(m_pdr));}

void xexex_state::machine_start(){	membank("z80bank")->configure_entries(0, 8, memregion("audiocpu")->base(), 0x4000);	membank("z80bank")->set_entry(0);	save_item(NAME(m_cur_alpha));	save_item(NAME(m_sprite_colorbase));	save_item(NAME(m_layer_colorbase));	save_item(NAME(m_layerpri));	save_item(NAME(m_suspension_active));	save_item(NAME(m_frame));	save_item(NAME(m_cur_control2));	machine().save().register_postload(save_prepost_delegate(FUNC(xexex_state::xexex_postload), this));	m_dmadelay_timer = machine().scheduler().timer_alloc(timer_expired_delegate(FUNC(xexex_state::dmaend_callback),this));}