Sprinter/mame
2
0
Fork 0
mirror of https://github.com/holub/mame synced 2025-06-06 04:43:45 +03:00
Code Issues Actions Packages Projects Releases Wiki Activity

Do not use FUNC in delegate where applicable (nw)

Browse Source
This commit is contained in:
Miodrag Milanovic 2016-11-06 14:11:55 +01:00
parent e311c17406
commit 2027d59e7f
149 changed files with 422 additions and 418 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

2
src/devices/bus/cbmiec/c1571.cpp
View File

@ -916,7 +916,7 @@ void c1571_t::device_start()
// install image callbacks
m_ga->set_floppy(m_floppy);
//m_fdc->set_floppy(m_floppy);
m_floppy->setup_wpt_cb(floppy_image_device::wpt_cb(FUNC(c1571_t::wpt_callback), this));
m_floppy->setup_wpt_cb(floppy_image_device::wpt_cb(&c1571_t::wpt_callback, this));
// register for state saving
save_item(NAME(m_1_2mhz));

4
src/devices/bus/cpc/mface2.cpp
View File

@ -66,7 +66,7 @@ DIRECT_UPDATE_MEMBER( cpc_multiface2_device::amstrad_multiface_directoverride )
m_romdis=0;
/* clear op base override */
machine().device("maincpu")->memory().space(AS_PROGRAM).set_direct_update_handler(direct_update_delegate(FUNC(cpc_multiface2_device::amstrad_default),this));
machine().device("maincpu")->memory().space(AS_PROGRAM).set_direct_update_handler(direct_update_delegate(&cpc_multiface2_device::amstrad_default,this));
}
return pc;
@ -158,7 +158,7 @@ void cpc_multiface2_device::multiface_stop()
m_slot->nmi_w(0);
/* initialise 0065 override to monitor calls to 0065 */
machine().device("maincpu")->memory().space(AS_PROGRAM).set_direct_update_handler(direct_update_delegate(FUNC(cpc_multiface2_device::amstrad_multiface_directoverride),this));
machine().device("maincpu")->memory().space(AS_PROGRAM).set_direct_update_handler(direct_update_delegate(&cpc_multiface2_device::amstrad_multiface_directoverride,this));
}
}

4
src/devices/bus/generic/slot.h
View File

@ -82,10 +82,10 @@ enum
static_cast<generic_slot_device *>(device)->set_extensions(_ext);
#define MCFG_GENERIC_LOAD(_class, _method) \
generic_slot_device::static_set_device_load(*device, device_image_load_delegate(&DEVICE_IMAGE_LOAD_NAME(_class,_method), #_class "::device_image_load_" #_method, downcast<_class *>(owner)));
generic_slot_device::static_set_device_load(*device, device_image_load_delegate(&DEVICE_IMAGE_LOAD_NAME(_class,_method), downcast<_class *>(owner)));
#define MCFG_GENERIC_UNLOAD(_class, _method) \
generic_slot_device::static_set_device_unload(*device, device_image_func_delegate(&DEVICE_IMAGE_UNLOAD_NAME(_class,_method), #_class "::device_image_unload_" #_method, downcast<_class *>(owner)));
generic_slot_device::static_set_device_unload(*device, device_image_func_delegate(&DEVICE_IMAGE_UNLOAD_NAME(_class,_method), downcast<_class *>(owner)));

2
src/devices/bus/isa/pgc.cpp
View File

@ -246,7 +246,7 @@ void isa8_pgc_device::device_start()
m_eram = std::make_unique<uint8_t[]>(0x8000);
machine().add_notifier(MACHINE_NOTIFY_RESET, machine_notify_delegate(FUNC(isa8_pgc_device::reset_common), this));
machine().add_notifier(MACHINE_NOTIFY_RESET, machine_notify_delegate(&isa8_pgc_device::reset_common, this));
}
void isa8_pgc_device::reset_common()

4
src/devices/bus/psx/ctlrport.cpp
View File

@ -55,8 +55,8 @@ void psxcontrollerports_device::device_start()
m_port0 = machine().device<psx_controller_port_device>("port1");
m_port1 = machine().device<psx_controller_port_device>("port2");
m_port0->setup_ack_cb(psx_controller_port_device::void_cb(FUNC(psxcontrollerports_device::ack), this));
m_port1->setup_ack_cb(psx_controller_port_device::void_cb(FUNC(psxcontrollerports_device::ack), this));
m_port0->setup_ack_cb(psx_controller_port_device::void_cb(&psxcontrollerports_device::ack, this));
m_port1->setup_ack_cb(psx_controller_port_device::void_cb(&psxcontrollerports_device::ack, this));
}
// add controllers to define so they can be connected to the multitap

8
src/devices/bus/psx/multitap.cpp
View File

@ -34,10 +34,10 @@ machine_config_constructor psx_multitap_device::device_mconfig_additions() const
void psx_multitap_device::device_start()
{
m_porta->setup_ack_cb(psx_controller_port_device::void_cb(FUNC(psx_multitap_device::ack), this));
m_portb->setup_ack_cb(psx_controller_port_device::void_cb(FUNC(psx_multitap_device::ack), this));
m_portc->setup_ack_cb(psx_controller_port_device::void_cb(FUNC(psx_multitap_device::ack), this));
m_portd->setup_ack_cb(psx_controller_port_device::void_cb(FUNC(psx_multitap_device::ack), this));
m_porta->setup_ack_cb(psx_controller_port_device::void_cb(&psx_multitap_device::ack, this));
m_portb->setup_ack_cb(psx_controller_port_device::void_cb(&psx_multitap_device::ack, this));
m_portc->setup_ack_cb(psx_controller_port_device::void_cb(&psx_multitap_device::ack, this));
m_portd->setup_ack_cb(psx_controller_port_device::void_cb(&psx_multitap_device::ack, this));
m_nextmode = false;
save_item(NAME(m_activeport));

8
src/devices/bus/ti99_peb/hfdc.cpp
View File

@ -728,7 +728,7 @@ void myarc_hfdc_device::connect_floppy_unit(int index)
// The controller fetches the state with the auxbus access
if (TRACE_LINES) logerror("Connect index callback DSK%d\n", index+1);
if (m_current_floppy != nullptr)
m_current_floppy->setup_index_pulse_cb(floppy_image_device::index_pulse_cb(FUNC(myarc_hfdc_device::floppy_index_callback), this));
m_current_floppy->setup_index_pulse_cb(floppy_image_device::index_pulse_cb(&myarc_hfdc_device::floppy_index_callback, this));
else
logerror("Connection to DSK%d failed because no drive is connected\n", index+1);
m_hdc9234->connect_floppy_drive(m_floppy_unit[index]);
@ -753,9 +753,9 @@ void myarc_hfdc_device::connect_harddisk_unit(int index)
if (TRACE_LINES) logerror("Connect index callback WDS%d\n", index+1);
if (m_current_harddisk != nullptr)
{
m_current_harddisk->setup_index_pulse_cb(mfm_harddisk_device::index_pulse_cb(FUNC(myarc_hfdc_device::harddisk_index_callback), this));
m_current_harddisk->setup_ready_cb(mfm_harddisk_device::ready_cb(FUNC(myarc_hfdc_device::harddisk_ready_callback), this));
m_current_harddisk->setup_seek_complete_cb(mfm_harddisk_device::seek_complete_cb(FUNC(myarc_hfdc_device::harddisk_skcom_callback), this));
m_current_harddisk->setup_index_pulse_cb(mfm_harddisk_device::index_pulse_cb(&myarc_hfdc_device::harddisk_index_callback, this));
m_current_harddisk->setup_ready_cb(mfm_harddisk_device::ready_cb(&myarc_hfdc_device::harddisk_ready_callback, this));
m_current_harddisk->setup_seek_complete_cb(mfm_harddisk_device::seek_complete_cb(&myarc_hfdc_device::harddisk_skcom_callback, this));
}
else
logerror("Connection to WDS%d failed because no drive is connected\n", index+1);

2
src/devices/bus/ti99_peb/ti_fdc.cpp
View File

@ -380,7 +380,7 @@ void ti_fdc_device::device_start()
m_motor_on_timer = timer_alloc(MOTOR_TIMER);
m_cru_base = 0x1100;
// In case we implement a callback after all:
// m_fd1771->setup_ready_cb(wd_fdc_t::rline_cb(FUNC(ti_fdc_device::dvena_r), this));
// m_fd1771->setup_ready_cb(wd_fdc_t::rline_cb(&ti_fdc_device::dvena_r, this));
save_item(NAME(m_address));
save_item(NAME(m_DRQ));

2
src/devices/bus/vtech/memexp/floppy.cpp
View File

@ -157,7 +157,7 @@ WRITE8_MEMBER(floppy_controller_device::latch_w)
if(newflop) {
newflop->set_rpm(85);
newflop->mon_w(0);
newflop->setup_index_pulse_cb(floppy_image_device::index_pulse_cb(FUNC(floppy_controller_device::index_callback), this));
newflop->setup_index_pulse_cb(floppy_image_device::index_pulse_cb(&floppy_controller_device::index_callback, this));
m_current_cyl = newflop->get_cyl() << 1;
}
m_floppy = newflop;

2
src/devices/cpu/drcbec.cpp
View File

@ -288,7 +288,7 @@ drcbe_c::drcbe_c(drcuml_state &drcuml, device_t &device, drc_cache &cache, uint3
m_hash(cache, modes, addrbits, ignorebits),
m_map(cache, 0),
m_labels(cache),
m_fixup_delegate(FUNC(drcbe_c::fixup_label), this)
m_fixup_delegate(&drcbe_c::fixup_label, this)
{
}

2
src/devices/cpu/drcbeut.cpp
View File

@ -435,7 +435,7 @@ uint32_t drc_map_variables::get_last_value(uint32_t mapvar)
drc_label_list::drc_label_list(drc_cache &cache)
: m_cache(cache),
m_oob_callback_delegate(FUNC(drc_label_list::oob_callback), this)
m_oob_callback_delegate(&drc_label_list::oob_callback, this)
{
}

4
src/devices/cpu/drcbex64.cpp
View File

@ -622,8 +622,8 @@ drcbe_x64::drcbe_x64(drcuml_state &drcuml, device_t &device, drc_cache &cache, u
m_entry(nullptr),
m_exit(nullptr),
m_nocode(nullptr),
m_fixup_label(FUNC(drcbe_x64::fixup_label), this),
m_fixup_exception(FUNC(drcbe_x64::fixup_exception), this),
m_fixup_label(&drcbe_x64::fixup_label, this),
m_fixup_exception(&drcbe_x64::fixup_exception, this),
m_near(*(near_state *)cache.alloc_near(sizeof(m_near)))
{
// build up necessary arrays

4
src/devices/cpu/drcbex86.cpp
View File

@ -542,8 +542,8 @@ drcbe_x86::drcbe_x86(drcuml_state &drcuml, device_t &device, drc_cache &cache, u
m_hashstacksave(nullptr),
m_reslo(0),
m_reshi(0),
m_fixup_label(FUNC(drcbe_x86::fixup_label), this),
m_fixup_exception(FUNC(drcbe_x86::fixup_exception), this)
m_fixup_label(&drcbe_x86::fixup_label, this),
m_fixup_exception(&drcbe_x86::fixup_exception, this)
{
// compute hi pointers for each register
for (int regnum = 0; regnum < ARRAY_LENGTH(int_register_map); regnum++)

2
src/devices/cpu/i86/i286.h
View File

@ -156,7 +156,7 @@ private:
};
#define MCFG_80286_A20(_class, _a20_cb) \
i80286_cpu_device::static_set_a20_callback(*device, i80286_cpu_device::a20_cb(FUNC(_class::_a20_cb), (_class *)owner));
i80286_cpu_device::static_set_a20_callback(*device, i80286_cpu_device::a20_cb(&_class::_a20_cb, (_class *)owner));
#define MCFG_80286_SHUTDOWN(_devcb) \
devcb = &i80286_cpu_device::static_set_shutdown_callback(*device, DEVCB_##_devcb);

70
src/devices/cpu/m68000/m68kcpu.cpp
View File

@ -1231,13 +1231,13 @@ void m68000_base_device::init8(address_space &space, address_space &ospace)
// m_cpustate = this;
opcode_xor = 0;
readimm16 = m68k_readimm16_delegate(FUNC(m68000_base_device::m68008_read_immediate_16), this);
read8 = m68k_read8_delegate(FUNC(address_space::read_byte), &space);
read16 = m68k_read16_delegate(FUNC(address_space::read_word), &space);
read32 = m68k_read32_delegate(FUNC(address_space::read_dword), &space);
write8 = m68k_write8_delegate(FUNC(address_space::write_byte), &space);
write16 = m68k_write16_delegate(FUNC(address_space::write_word), &space);
write32 = m68k_write32_delegate(FUNC(address_space::write_dword), &space);
readimm16 = m68k_readimm16_delegate(&m68000_base_device::m68008_read_immediate_16, this);
read8 = m68k_read8_delegate(&address_space::read_byte, &space);
read16 = m68k_read16_delegate(&address_space::read_word, &space);
read32 = m68k_read32_delegate(&address_space::read_dword, &space);
write8 = m68k_write8_delegate(&address_space::write_byte, &space);
write16 = m68k_write16_delegate(&address_space::write_word, &space);
write32 = m68k_write32_delegate(&address_space::write_dword, &space);
}
/****************************************************************************
@ -1270,13 +1270,13 @@ void m68000_base_device::init16(address_space &space, address_space &ospace)
opcode_xor = 0;
readimm16 = m68k_readimm16_delegate(FUNC(m68000_base_device::simple_read_immediate_16), this);
read8 = m68k_read8_delegate(FUNC(address_space::read_byte), &space);
read16 = m68k_read16_delegate(FUNC(address_space::read_word), &space);
read32 = m68k_read32_delegate(FUNC(address_space::read_dword), &space);
write8 = m68k_write8_delegate(FUNC(m68000_base_device::m68000_write_byte), this);
write16 = m68k_write16_delegate(FUNC(address_space::write_word), &space);
write32 = m68k_write32_delegate(FUNC(address_space::write_dword), &space);
readimm16 = m68k_readimm16_delegate(&m68000_base_device::simple_read_immediate_16, this);
read8 = m68k_read8_delegate(&address_space::read_byte, &space);
read16 = m68k_read16_delegate(&address_space::read_word, &space);
read32 = m68k_read32_delegate(&address_space::read_dword, &space);
write8 = m68k_write8_delegate(&m68000_base_device::m68000_write_byte, this);
write16 = m68k_write16_delegate(&address_space::write_word, &space);
write32 = m68k_write32_delegate(&address_space::write_dword, &space);
}
@ -1296,13 +1296,13 @@ void m68000_base_device::init32(address_space &space, address_space &ospace)
m_odirect = &ospace.direct();
opcode_xor = WORD_XOR_BE(0);
readimm16 = m68k_readimm16_delegate(FUNC(m68000_base_device::read_immediate_16), this);
read8 = m68k_read8_delegate(FUNC(address_space::read_byte), &space);
read16 = m68k_read16_delegate(FUNC(address_space::read_word_unaligned), &space);
read32 = m68k_read32_delegate(FUNC(address_space::read_dword_unaligned), &space);
write8 = m68k_write8_delegate(FUNC(address_space::write_byte), &space);
write16 = m68k_write16_delegate(FUNC(address_space::write_word_unaligned), &space);
write32 = m68k_write32_delegate(FUNC(address_space::write_dword_unaligned), &space);
readimm16 = m68k_readimm16_delegate(&m68000_base_device::read_immediate_16, this);
read8 = m68k_read8_delegate(&address_space::read_byte, &space);
read16 = m68k_read16_delegate(&address_space::read_word_unaligned, &space);
read32 = m68k_read32_delegate(&address_space::read_dword_unaligned, &space);
write8 = m68k_write8_delegate(&address_space::write_byte, &space);
write16 = m68k_write16_delegate(&address_space::write_word_unaligned, &space);
write32 = m68k_write32_delegate(&address_space::write_dword_unaligned, &space);
}
/* interface for 32-bit data bus with PMMU (68EC020, 68020) */
@ -1515,13 +1515,13 @@ void m68000_base_device::init32mmu(address_space &space, address_space &ospace)
m_odirect = &ospace.direct();
opcode_xor = WORD_XOR_BE(0);
readimm16 = m68k_readimm16_delegate(FUNC(m68000_base_device::read_immediate_16_mmu), this);
read8 = m68k_read8_delegate(FUNC(m68000_base_device::read_byte_32_mmu), this);
read16 = m68k_read16_delegate(FUNC(m68000_base_device::readword_d32_mmu), this);
read32 = m68k_read32_delegate(FUNC(m68000_base_device::readlong_d32_mmu), this);
write8 = m68k_write8_delegate(FUNC(m68000_base_device::write_byte_32_mmu), this);
write16 = m68k_write16_delegate(FUNC(m68000_base_device::writeword_d32_mmu), this);
write32 = m68k_write32_delegate(FUNC(m68000_base_device::writelong_d32_mmu), this);
readimm16 = m68k_readimm16_delegate(&m68000_base_device::read_immediate_16_mmu, this);
read8 = m68k_read8_delegate(&m68000_base_device::read_byte_32_mmu, this);
read16 = m68k_read16_delegate(&m68000_base_device::readword_d32_mmu, this);
read32 = m68k_read32_delegate(&m68000_base_device::readlong_d32_mmu, this);
write8 = m68k_write8_delegate(&m68000_base_device::write_byte_32_mmu, this);
write16 = m68k_write16_delegate(&m68000_base_device::writeword_d32_mmu, this);
write32 = m68k_write32_delegate(&m68000_base_device::writelong_d32_mmu, this);
}
@ -1643,13 +1643,13 @@ void m68000_base_device::init32hmmu(address_space &space, address_space &ospace)
m_odirect = &ospace.direct();
opcode_xor = WORD_XOR_BE(0);
readimm16 = m68k_readimm16_delegate(FUNC(m68000_base_device::read_immediate_16_hmmu), this);
read8 = m68k_read8_delegate(FUNC(m68000_base_device::read_byte_32_hmmu), this);
read16 = m68k_read16_delegate(FUNC(m68000_base_device::readword_d32_hmmu), this);
read32 = m68k_read32_delegate(FUNC(m68000_base_device::readlong_d32_hmmu), this);
write8 = m68k_write8_delegate(FUNC(m68000_base_device::write_byte_32_hmmu), this);
write16 = m68k_write16_delegate(FUNC(m68000_base_device::writeword_d32_hmmu), this);
write32 = m68k_write32_delegate(FUNC(m68000_base_device::writelong_d32_hmmu), this);
readimm16 = m68k_readimm16_delegate(&m68000_base_device::read_immediate_16_hmmu, this);
read8 = m68k_read8_delegate(&m68000_base_device::read_byte_32_hmmu, this);
read16 = m68k_read16_delegate(&m68000_base_device::readword_d32_hmmu, this);
read32 = m68k_read32_delegate(&m68000_base_device::readlong_d32_hmmu, this);
write8 = m68k_write8_delegate(&m68000_base_device::write_byte_32_hmmu, this);
write16 = m68k_write16_delegate(&m68000_base_device::writeword_d32_hmmu, this);
write32 = m68k_write32_delegate(&m68000_base_device::writelong_d32_hmmu, this);
}
void m68000_base_device::set_reset_callback(write_line_delegate callback)

4
src/devices/cpu/psx/psx.cpp
View File

@ -3391,8 +3391,8 @@ static MACHINE_CONFIG_FRAGMENT( psx )
MCFG_PSX_DMA_IRQ_HANDLER( DEVWRITELINE("irq", psxirq_device, intin3 ) )
MCFG_DEVICE_ADD( "mdec", PSX_MDEC, 0 )
MCFG_PSX_DMA_CHANNEL_WRITE( DEVICE_SELF, 0, psx_dma_write_delegate( FUNC( psxmdec_device::dma_write ), (psxmdec_device *) device ) )
MCFG_PSX_DMA_CHANNEL_READ( DEVICE_SELF, 1, psx_dma_read_delegate( FUNC( psxmdec_device::dma_read ), (psxmdec_device *) device ) )
MCFG_PSX_DMA_CHANNEL_WRITE( DEVICE_SELF, 0, psx_dma_write_delegate(&psxmdec_device::dma_write, (psxmdec_device *) device ) )
MCFG_PSX_DMA_CHANNEL_READ( DEVICE_SELF, 1, psx_dma_read_delegate(&psxmdec_device::dma_read, (psxmdec_device *) device ) )
MCFG_DEVICE_ADD( "rcnt", PSX_RCNT, 0 )
MCFG_PSX_RCNT_IRQ0_HANDLER( DEVWRITELINE( "irq", psxirq_device, intin4 ) )

2
src/devices/cpu/tms32031/tms32031.cpp
View File

@ -383,7 +383,7 @@ void tms3203x_device::device_start()
// set up the internal boot loader ROM
m_bootrom = reinterpret_cast<uint32_t*>(memregion(shortname())->base());
m_direct->set_direct_update(direct_update_delegate(FUNC(tms3203x_device::direct_handler), this));
m_direct->set_direct_update(direct_update_delegate(&tms3203x_device::direct_handler, this));
// save state
save_item(NAME(m_pc));

4
src/devices/imagedev/diablo.h
View File

@ -80,10 +80,10 @@ extern const device_type DIABLO;
MCFG_DEVICE_ADD(_tag, DIABLO, 0)
#define MCFG_DIABLO_LOAD(_class,_method) \
diablo_image_device::static_set_device_load(*device, device_image_load_delegate(&DEVICE_IMAGE_LOAD_NAME(_class,_method), #_class "::device_image_load_" #_method, downcast<_class *>(owner)));
diablo_image_device::static_set_device_load(*device, device_image_load_delegate(&DEVICE_IMAGE_LOAD_NAME(_class,_method), downcast<_class *>(owner)));
#define MCFG_DIABLO_UNLOAD(_class,_method) \
diablo_image_device::static_set_device_unload(*device, device_image_func_delegate(&DEVICE_IMAGE_UNLOAD_NAME(_class,_method), #_class "::device_image_unload_" #_method, downcast<_class *>(owner)));
diablo_image_device::static_set_device_unload(*device, device_image_func_delegate(&DEVICE_IMAGE_UNLOAD_NAME(_class,_method), downcast<_class *>(owner)));
#define MCFG_DIABLO_INTERFACE(_interface) \
diablo_image_device::static_set_interface(*device, _interface);

4
src/devices/imagedev/harddriv.h
View File

@ -84,10 +84,10 @@ extern const device_type HARDDISK;
MCFG_DEVICE_ADD(_tag, HARDDISK, 0)
#define MCFG_HARDDISK_LOAD(_class,_method) \
harddisk_image_device::static_set_device_load(*device, device_image_load_delegate(&DEVICE_IMAGE_LOAD_NAME(_class,_method), #_class "::device_image_load_" #_method, downcast<_class *>(owner)));
harddisk_image_device::static_set_device_load(*device, device_image_load_delegate(&DEVICE_IMAGE_LOAD_NAME(_class,_method), downcast<_class *>(owner)));
#define MCFG_HARDDISK_UNLOAD(_class,_method) \
harddisk_image_device::static_set_device_unload(*device, device_image_func_delegate(&DEVICE_IMAGE_UNLOAD_NAME(_class,_method), #_class "::device_image_unload_" #_method, downcast<_class *>(owner)));
harddisk_image_device::static_set_device_unload(*device, device_image_func_delegate(&DEVICE_IMAGE_UNLOAD_NAME(_class,_method), downcast<_class *>(owner)));
#define MCFG_HARDDISK_INTERFACE(_interface) \
harddisk_image_device::static_set_interface(*device, _interface);

4
src/devices/imagedev/snapquik.h
View File

@ -79,13 +79,13 @@ extern const device_type QUICKLOAD;
#define SNAPSHOT_LOAD_NAME(_class,_name) _class::SNAPSHOT_LOAD_MEMBER_NAME(_name)
#define DECLARE_SNAPSHOT_LOAD_MEMBER(_name) image_init_result SNAPSHOT_LOAD_MEMBER_NAME(_name)(device_image_interface &image, const char *file_type, int snapshot_size)
#define SNAPSHOT_LOAD_MEMBER(_class,_name) image_init_result SNAPSHOT_LOAD_NAME(_class,_name)(device_image_interface &image, const char *file_type, int snapshot_size)
#define SNAPSHOT_LOAD_DELEGATE(_class,_name) snapquick_load_delegate(&SNAPSHOT_LOAD_NAME(_class,_name),#_class "::snapshot_load_" #_name, downcast<_class *>(device->owner()))
#define SNAPSHOT_LOAD_DELEGATE(_class,_name) snapquick_load_delegate(&SNAPSHOT_LOAD_NAME(_class,_name), downcast<_class *>(device->owner()))
#define QUICKLOAD_LOAD_MEMBER_NAME(_name) quickload_load##_name
#define QUICKLOAD_LOAD_NAME(_class,_name) _class::QUICKLOAD_LOAD_MEMBER_NAME(_name)
#define DECLARE_QUICKLOAD_LOAD_MEMBER(_name) image_init_result QUICKLOAD_LOAD_MEMBER_NAME(_name)(device_image_interface &image, const char *file_type, int quickload_size)
#define QUICKLOAD_LOAD_MEMBER(_class,_name) image_init_result QUICKLOAD_LOAD_NAME(_class,_name)(device_image_interface &image, const char *file_type, int quickload_size)
#define QUICKLOAD_LOAD_DELEGATE(_class,_name) snapquick_load_delegate(&QUICKLOAD_LOAD_NAME(_class,_name),#_class "::quickload_load_" #_name, downcast<_class *>(device->owner()))
#define QUICKLOAD_LOAD_DELEGATE(_class,_name) snapquick_load_delegate(&QUICKLOAD_LOAD_NAME(_class,_name), downcast<_class *>(device->owner()))
#define MCFG_SNAPSHOT_ADD(_tag, _class, _load, _file_extensions, _delay) \
MCFG_DEVICE_ADD(_tag, SNAPSHOT, 0) \

34
src/devices/machine/53c810.cpp
View File

@ -636,25 +636,25 @@ void lsi53c810_device::device_start()
for (auto & elem : dma_opcode)
{
elem = opcode_handler_delegate(FUNC(lsi53c810_device::dmaop_invalid), this);
elem = opcode_handler_delegate(&lsi53c810_device::dmaop_invalid, this);
}
add_opcode(0x00, 0xc0, opcode_handler_delegate(FUNC( lsi53c810_device::dmaop_block_move ), this));
add_opcode(0x40, 0xf8, opcode_handler_delegate(FUNC( lsi53c810_device::dmaop_select ), this));
add_opcode(0x48, 0xf8, opcode_handler_delegate(FUNC( lsi53c810_device::dmaop_wait_disconnect ), this));
add_opcode(0x50, 0xf8, opcode_handler_delegate(FUNC( lsi53c810_device::dmaop_wait_reselect ), this));
add_opcode(0x58, 0xf8, opcode_handler_delegate(FUNC( lsi53c810_device::dmaop_set ), this));
add_opcode(0x60, 0xf8, opcode_handler_delegate(FUNC( lsi53c810_device::dmaop_clear ), this));
add_opcode(0x68, 0xf8, opcode_handler_delegate(FUNC( lsi53c810_device::dmaop_move_from_sfbr ), this));
add_opcode(0x70, 0xf8, opcode_handler_delegate(FUNC( lsi53c810_device::dmaop_move_to_sfbr ), this));
add_opcode(0x78, 0xf8, opcode_handler_delegate(FUNC( lsi53c810_device::dmaop_read_modify_write ), this));
add_opcode(0x80, 0xf8, opcode_handler_delegate(FUNC( lsi53c810_device::dmaop_jump ), this));
add_opcode(0x88, 0xf8, opcode_handler_delegate(FUNC( lsi53c810_device::dmaop_call ), this));
add_opcode(0x90, 0xf8, opcode_handler_delegate(FUNC( lsi53c810_device::dmaop_return ), this));
add_opcode(0x98, 0xf8, opcode_handler_delegate(FUNC( lsi53c810_device::dmaop_interrupt ), this));
add_opcode(0xc0, 0xfe, opcode_handler_delegate(FUNC( lsi53c810_device::dmaop_move_memory ), this));
add_opcode(0xe0, 0xed, opcode_handler_delegate(FUNC( lsi53c810_device::dmaop_store ), this));
add_opcode(0xe1, 0xed, opcode_handler_delegate(FUNC( lsi53c810_device::dmaop_load ), this));
add_opcode(0x00, 0xc0, opcode_handler_delegate(&lsi53c810_device::dmaop_block_move, this));
add_opcode(0x40, 0xf8, opcode_handler_delegate(&lsi53c810_device::dmaop_select, this));
add_opcode(0x48, 0xf8, opcode_handler_delegate(&lsi53c810_device::dmaop_wait_disconnect, this));
add_opcode(0x50, 0xf8, opcode_handler_delegate(&lsi53c810_device::dmaop_wait_reselect, this));
add_opcode(0x58, 0xf8, opcode_handler_delegate(&lsi53c810_device::dmaop_set, this));
add_opcode(0x60, 0xf8, opcode_handler_delegate(&lsi53c810_device::dmaop_clear, this));
add_opcode(0x68, 0xf8, opcode_handler_delegate(&lsi53c810_device::dmaop_move_from_sfbr, this));
add_opcode(0x70, 0xf8, opcode_handler_delegate(&lsi53c810_device::dmaop_move_to_sfbr, this));
add_opcode(0x78, 0xf8, opcode_handler_delegate(&lsi53c810_device::dmaop_read_modify_write, this));
add_opcode(0x80, 0xf8, opcode_handler_delegate(&lsi53c810_device::dmaop_jump, this));
add_opcode(0x88, 0xf8, opcode_handler_delegate(&lsi53c810_device::dmaop_call, this));
add_opcode(0x90, 0xf8, opcode_handler_delegate(&lsi53c810_device::dmaop_return, this));
add_opcode(0x98, 0xf8, opcode_handler_delegate(&lsi53c810_device::dmaop_interrupt, this));
add_opcode(0xc0, 0xfe, opcode_handler_delegate(&lsi53c810_device::dmaop_move_memory, this));
add_opcode(0xe0, 0xed, opcode_handler_delegate(&lsi53c810_device::dmaop_store, this));
add_opcode(0xe1, 0xed, opcode_handler_delegate(&lsi53c810_device::dmaop_load, this));
}
/*************************************

14
src/devices/machine/68307.cpp
View File

@ -162,13 +162,13 @@ void m68307cpu_device::init16_m68307(address_space &space)
m_direct = &space.direct();
opcode_xor = 0;
readimm16 = m68k_readimm16_delegate(FUNC(m68307cpu_device::simple_read_immediate_16_m68307), this);
read8 = m68k_read8_delegate(FUNC(m68307cpu_device::read_byte_m68307), this);
read16 = m68k_read16_delegate(FUNC(m68307cpu_device::read_word_m68307), this);
read32 = m68k_read32_delegate(FUNC(m68307cpu_device::read_dword_m68307), this);
write8 = m68k_write8_delegate(FUNC(m68307cpu_device::write_byte_m68307), this);
write16 = m68k_write16_delegate(FUNC(m68307cpu_device::write_word_m68307), this);
write32 = m68k_write32_delegate(FUNC(m68307cpu_device::write_dword_m68307), this);
readimm16 = m68k_readimm16_delegate(&m68307cpu_device::simple_read_immediate_16_m68307, this);
read8 = m68k_read8_delegate(&m68307cpu_device::read_byte_m68307, this);
read16 = m68k_read16_delegate(&m68307cpu_device::read_word_m68307, this);
read32 = m68k_read32_delegate(&m68307cpu_device::read_dword_m68307, this);
write8 = m68k_write8_delegate(&m68307cpu_device::write_byte_m68307, this);
write16 = m68k_write16_delegate(&m68307cpu_device::write_word_m68307, this);
write32 = m68k_write32_delegate(&m68307cpu_device::write_dword_m68307, this);
}

2
src/devices/machine/amigafdc.cpp
View File

@ -463,7 +463,7 @@ WRITE8_MEMBER( amiga_fdc::ciaaprb_w )
if(old_floppy)
old_floppy->setup_index_pulse_cb(floppy_image_device::index_pulse_cb());
if(floppy)
floppy->setup_index_pulse_cb(floppy_image_device::index_pulse_cb(FUNC(amiga_fdc::index_callback), this));
floppy->setup_index_pulse_cb(floppy_image_device::index_pulse_cb(&amiga_fdc::index_callback, this));
}
if(floppy) {

4
src/devices/machine/i8271.cpp
View File

@ -51,7 +51,7 @@ void i8271_device::device_start()
if(con) {
flopi[i].dev = con->get_device();
if (flopi[i].dev != nullptr)
flopi[i].dev->setup_index_pulse_cb(floppy_image_device::index_pulse_cb(FUNC(i8271_device::index_callback), this));
flopi[i].dev->setup_index_pulse_cb(floppy_image_device::index_pulse_cb(&i8271_device::index_callback, this));
} else
flopi[i].dev = nullptr;
} else
@ -126,7 +126,7 @@ void i8271_device::set_floppy(floppy_image_device *flop)
elem.dev = flop;
}
if(flop)
flop->setup_index_pulse_cb(floppy_image_device::index_pulse_cb(FUNC(i8271_device::index_callback), this));
flop->setup_index_pulse_cb(floppy_image_device::index_pulse_cb(&i8271_device::index_callback, this));
}
READ8_MEMBER(i8271_device::sr_r)

4
src/devices/machine/laserdsc.cpp
View File

@ -321,7 +321,7 @@ void laserdisc_device::device_start()
init_audio();
// register callbacks
machine().configuration().config_register("laserdisc", config_saveload_delegate(FUNC(laserdisc_device::config_load), this), config_saveload_delegate(FUNC(laserdisc_device::config_save), this));
machine().configuration().config_register("laserdisc", config_saveload_delegate(&laserdisc_device::config_load, this), config_saveload_delegate(&laserdisc_device::config_save, this));
}
@ -792,7 +792,7 @@ void laserdisc_device::init_disc()
void laserdisc_device::init_video()
{
// register for VBLANK callbacks
m_screen->register_vblank_callback(vblank_state_delegate(FUNC(laserdisc_device::vblank_state_changed), this));
m_screen->register_vblank_callback(vblank_state_delegate(&laserdisc_device::vblank_state_changed, this));
// allocate palette for applying brightness/contrast/gamma
m_videopalette = palette_t::alloc(256);

2
src/devices/machine/microtch.h
View File

@ -72,7 +72,7 @@ extern const device_type MICROTOUCH;
devcb = &microtouch_device::static_set_stx_callback(*device, DEVCB_##_devcb);
#define MCFG_MICROTOUCH_TOUCH_CB(_class, _touch_cb) \
microtouch_device::static_set_touch_callback(*device, microtouch_device::touch_cb(FUNC(_class::_touch_cb), (_class *)owner));
microtouch_device::static_set_touch_callback(*device, microtouch_device::touch_cb(&_class::_touch_cb, (_class *)owner));
#endif //_MICROTOUCH_H

4
src/devices/machine/pci.cpp
View File

@ -446,7 +446,7 @@ void pci_bridge_device::device_start()
sub_devices[(id << 3) | fct] = downcast<pci_device *>(&d);
}
mapper_cb cf_cb(FUNC(pci_bridge_device::regenerate_config_mapping), this);
mapper_cb cf_cb(&pci_bridge_device::regenerate_config_mapping, this);
for(int i=0; i<32*8; i++)
if(sub_devices[i]) {
@ -817,7 +817,7 @@ device_t *pci_host_device::bus_root()
void pci_host_device::device_start()
{
remap_cb = mapper_cb(FUNC(pci_host_device::regenerate_mapping), this);
remap_cb = mapper_cb(&pci_host_device::regenerate_mapping, this);
pci_bridge_device::device_start();

6
src/devices/machine/pckeybrd.cpp
View File

@ -336,9 +336,9 @@ void pc_keyboard_device::device_start()
memset(m_make, 0, sizeof(m_make));
machine().ioport().natkeyboard().configure(
ioport_queue_chars_delegate(FUNC(pc_keyboard_device::queue_chars), this),
ioport_accept_char_delegate(FUNC(pc_keyboard_device::accept_char), this),
ioport_charqueue_empty_delegate(FUNC(pc_keyboard_device::charqueue_empty), this));
ioport_queue_chars_delegate(&pc_keyboard_device::queue_chars, this),
ioport_accept_char_delegate(&pc_keyboard_device::accept_char, this),
ioport_charqueue_empty_delegate(&pc_keyboard_device::charqueue_empty, this));
m_out_keypress_func.resolve_safe();
m_keyboard_timer = timer_alloc();

4
src/devices/machine/upd765.cpp
View File

@ -156,7 +156,7 @@ void upd765_family_device::device_start()
if(con) {
flopi[i].dev = con->get_device();
if (flopi[i].dev != nullptr)
flopi[i].dev->setup_index_pulse_cb(floppy_image_device::index_pulse_cb(FUNC(upd765_family_device::index_callback), this));
flopi[i].dev->setup_index_pulse_cb(floppy_image_device::index_pulse_cb(&upd765_family_device::index_callback, this));
} else
flopi[i].dev = nullptr;
} else
@ -268,7 +268,7 @@ void upd765_family_device::set_floppy(floppy_image_device *flop)
elem.dev = flop;
}
if(flop)
flop->setup_index_pulse_cb(floppy_image_device::index_pulse_cb(FUNC(upd765_family_device::index_callback), this));
flop->setup_index_pulse_cb(floppy_image_device::index_pulse_cb(&upd765_family_device::index_callback, this));
}
READ8_MEMBER(upd765_family_device::sra_r)

2
src/devices/machine/watchdog.cpp
View File

@ -89,7 +89,7 @@ void watchdog_timer_device::device_start()
// fetch the screen
screen_device *screen = siblingdevice<screen_device>(m_screen_tag);
if (screen != nullptr)
screen->register_vblank_callback(vblank_state_delegate(FUNC(watchdog_timer_device::watchdog_vblank), this));
screen->register_vblank_callback(vblank_state_delegate(&watchdog_timer_device::watchdog_vblank, this));
}
save_item(NAME(m_enabled));
save_item(NAME(m_counter));

4
src/devices/machine/wd_fdc.cpp
View File

@ -179,8 +179,8 @@ void wd_fdc_t::set_floppy(floppy_image_device *_floppy)
if(floppy) {
if(motor_control)
floppy->mon_w(status & S_MON ? 0 : 1);
floppy->setup_index_pulse_cb(floppy_image_device::index_pulse_cb(FUNC(wd_fdc_t::index_callback), this));
floppy->setup_ready_cb(floppy_image_device::ready_cb(FUNC(wd_fdc_t::ready_callback), this));
floppy->setup_index_pulse_cb(floppy_image_device::index_pulse_cb(&wd_fdc_t::index_callback, this));
floppy->setup_ready_cb(floppy_image_device::ready_cb(&wd_fdc_t::ready_callback, this));
}
if(prev_ready != next_ready)

2
src/devices/sound/2203intf.cpp
View File

@ -149,7 +149,7 @@ void ym2203_device::calculate_rates()
if (m_stream != nullptr)
m_stream->set_sample_rate(rate);
else
m_stream = machine().sound().stream_alloc(*this,0,1,rate, stream_update_delegate(FUNC(ym2203_device::stream_generate),this));
m_stream = machine().sound().stream_alloc(*this,0,1,rate, stream_update_delegate(&ym2203_device::stream_generate,this));
}
//-------------------------------------------------

2
src/devices/sound/2608intf.cpp
View File

@ -142,7 +142,7 @@ void ym2608_device::device_start()
m_timer[1] = timer_alloc(1);
/* stream system initialize */
m_stream = machine().sound().stream_alloc(*this,0,2,rate, stream_update_delegate(FUNC(ym2608_device::stream_generate),this));
m_stream = machine().sound().stream_alloc(*this,0,2,rate, stream_update_delegate(&ym2608_device::stream_generate,this));
/* setup adpcm buffers */
pcmbufa = m_region->base();
pcmsizea = m_region->bytes();

2
src/devices/sound/2610intf.cpp
View File

@ -154,7 +154,7 @@ void ym2610_device::device_start()
m_timer[1] = timer_alloc(1);
/* stream system initialize */
m_stream = machine().sound().stream_alloc(*this,0,2,rate, stream_update_delegate(FUNC(ym2610_device::stream_generate),this));
m_stream = machine().sound().stream_alloc(*this,0,2,rate, stream_update_delegate(&ym2610_device::stream_generate,this));
/* setup adpcm buffers */
void *pcmbufa = m_region->base();

2
src/devices/sound/disc_inp.hxx
View File

@ -318,7 +318,7 @@ void DISCRETE_CLASS_NAME(dss_input_stream)::stream_start(void)
discrete_sound_device *snd_device = downcast<discrete_sound_device *>(m_device);
//assert(DSS_INPUT_STREAM__STREAM < snd_device->m_input_stream_list.count());
m_buffer_stream = m_device->machine().sound().stream_alloc(*snd_device, 0, 1, this->sample_rate(), stream_update_delegate(FUNC(discrete_dss_input_stream_node::stream_generate),this));
m_buffer_stream = m_device->machine().sound().stream_alloc(*snd_device, 0, 1, this->sample_rate(), stream_update_delegate(&discrete_dss_input_stream_node::stream_generate,this));
snd_device->get_stream()->set_input(m_stream_in_number, m_buffer_stream);
}

4
src/devices/sound/spu.h
View File

@ -20,8 +20,8 @@
MCFG_PSX_SPU_WRITE_HANDLER(DEVWRITE16(_tag, spu_device, write)) \
MCFG_DEVICE_ADD(_tag, SPU, _clock) \
MCFG_SPU_IRQ_HANDLER(DEVWRITELINE("maincpu:irq", psxirq_device, intin9)) \
MCFG_PSX_DMA_CHANNEL_READ( "maincpu", 4, psx_dma_read_delegate( FUNC( spu_device::dma_read ), (spu_device *) device ) ) \
MCFG_PSX_DMA_CHANNEL_WRITE( "maincpu", 4, psx_dma_write_delegate( FUNC( spu_device::dma_write ), (spu_device *) device ) )
MCFG_PSX_DMA_CHANNEL_READ( "maincpu", 4, psx_dma_read_delegate(&spu_device::dma_read, (spu_device *) device ) ) \
MCFG_PSX_DMA_CHANNEL_WRITE( "maincpu", 4, psx_dma_write_delegate(&spu_device::dma_write, (spu_device *) device ) )
// ======================> spu_device

2
src/devices/video/psx.cpp
View File

@ -3804,7 +3804,7 @@ MACHINE_CONFIG_FRAGMENT( psxgpu )
MCFG_SCREEN_SIZE( 1024, 1024 )
MCFG_SCREEN_VISIBLE_AREA( 0, 639, 0, 479 )
MCFG_SCREEN_UPDATE_DEVICE( DEVICE_SELF, psxgpu_device, update_screen )
((screen_device *)device)->register_vblank_callback(vblank_state_delegate(FUNC(psxgpu_device::vblank), (psxgpu_device *) owner));
((screen_device *)device)->register_vblank_callback(vblank_state_delegate(&psxgpu_device::vblank, (psxgpu_device *) owner));
MCFG_SCREEN_PALETTE("palette")
MCFG_PALETTE_ADD( "palette", 65536 )

8
src/devices/video/psx.h
View File

@ -24,8 +24,8 @@
MCFG_DEVICE_ADD( tag, type, clock ) \
((psxgpu_device *) device)->vramSize = _vramSize; \
MCFG_PSX_GPU_VBLANK_HANDLER(DEVWRITELINE(cputag ":irq", psxirq_device, intin0)) \
MCFG_PSX_DMA_CHANNEL_READ( cputag, 2, psx_dma_write_delegate( FUNC( psxgpu_device::dma_read ), (psxgpu_device *) device ) ) \
MCFG_PSX_DMA_CHANNEL_WRITE( cputag, 2, psx_dma_read_delegate( FUNC( psxgpu_device::dma_write ), (psxgpu_device *) device ) )
MCFG_PSX_DMA_CHANNEL_READ( cputag, 2, psx_dma_write_delegate(&psxgpu_device::dma_read, (psxgpu_device *) device ) ) \
MCFG_PSX_DMA_CHANNEL_WRITE( cputag, 2, psx_dma_read_delegate(&psxgpu_device::dma_write, (psxgpu_device *) device ) )
#define MCFG_PSXGPU_REPLACE( cputag, tag, type, _vramSize, clock ) \
MCFG_DEVICE_MODIFY( cputag ) \
@ -34,8 +34,8 @@
MCFG_DEVICE_REPLACE( tag, type, clock ) \
((psxgpu_device *) device)->vramSize = _vramSize; \
MCFG_PSX_GPU_VBLANK_HANDLER(DEVWRITELINE(cputag ":irq", psxirq_device, intin0)) \
MCFG_PSX_DMA_CHANNEL_READ( cputag, 2, psx_dma_write_delegate( FUNC( psxgpu_device::dma_read ), (psxgpu_device *) device ) ) \
MCFG_PSX_DMA_CHANNEL_WRITE( cputag, 2, psx_dma_read_delegate( FUNC( psxgpu_device::dma_write ), (psxgpu_device *) device ) )
MCFG_PSX_DMA_CHANNEL_READ( cputag, 2, psx_dma_write_delegate(&psxgpu_device::dma_read, (psxgpu_device *) device ) ) \
MCFG_PSX_DMA_CHANNEL_WRITE( cputag, 2, psx_dma_read_delegate(&psxgpu_device::dma_write, (psxgpu_device *) device ) )
#define MCFG_PSXGPU_VBLANK_CALLBACK( _delegate ) \
((screen_device *) config.device_find( device, "screen" ))->register_vblank_callback( _delegate );

2
src/devices/video/stvvdp2.cpp
View File

@ -6099,7 +6099,7 @@ void saturn_state::stv_vdp2_exit ( void )
int saturn_state::stv_vdp2_start ( void )
{
machine().add_notifier(MACHINE_NOTIFY_EXIT, machine_notify_delegate(FUNC(saturn_state::stv_vdp2_exit), this));
machine().add_notifier(MACHINE_NOTIFY_EXIT, machine_notify_delegate(&saturn_state::stv_vdp2_exit, this));
m_vdp2_regs = make_unique_clear<uint16_t[]>(0x040000/2 );
m_vdp2_vram = make_unique_clear<uint32_t[]>(0x100000/4 );

8
src/devices/video/zeus2.cpp
View File

@ -80,7 +80,7 @@ void zeus2_device::device_start()
m_irq.resolve_safe();
/* we need to cleanup on exit */
//machine().add_notifier(MACHINE_NOTIFY_EXIT, machine_notify_delegate(FUNC(zeus2_device::exit_handler2), this));
//machine().add_notifier(MACHINE_NOTIFY_EXIT, machine_notify_delegate(&zeus2_device::exit_handler2, this));
int_timer = machine().scheduler().timer_alloc(timer_expired_delegate(FUNC(zeus2_device::int_timer_callback), this));
vblank_timer = machine().scheduler().timer_alloc(timer_expired_delegate(FUNC(zeus2_device::display_irq), this));
@ -1550,11 +1550,11 @@ void zeus2_renderer::zeus2_draw_quad(const uint32_t *databuffer, uint32_t texdat
// tests, but the (numverts == 5) statement below may actually be a quad fan instead of a 5-sided
// polygon.
if (numverts == 3)
render_triangle(m_state->zeus_cliprect, render_delegate(FUNC(zeus2_renderer::render_poly_8bit), this), 4, clipvert[0], clipvert[1], clipvert[2]);
render_triangle(m_state->zeus_cliprect, render_delegate(&zeus2_renderer::render_poly_8bit, this), 4, clipvert[0], clipvert[1], clipvert[2]);
else if (numverts == 4)
render_polygon<4>(m_state->zeus_cliprect, render_delegate(FUNC(zeus2_renderer::render_poly_8bit), this), 4, clipvert);
render_polygon<4>(m_state->zeus_cliprect, render_delegate(&zeus2_renderer::render_poly_8bit, this), 4, clipvert);
else if (numverts == 5)
render_polygon<5>(m_state->zeus_cliprect, render_delegate(FUNC(zeus2_renderer::render_poly_8bit), this), 4, clipvert);
render_polygon<5>(m_state->zeus_cliprect, render_delegate(&zeus2_renderer::render_poly_8bit, this), 4, clipvert);
}

2
src/emu/bookkeeping.cpp
View File

@ -39,7 +39,7 @@ bookkeeping_manager::bookkeeping_manager(running_machine &machine)
machine.save().save_item(NAME(m_dispensed_tickets));
// register for configuration
machine.configuration().config_register("counters", config_saveload_delegate(FUNC(bookkeeping_manager::config_load), this), config_saveload_delegate(FUNC(bookkeeping_manager::config_save), this));
machine.configuration().config_register("counters", config_saveload_delegate(&bookkeeping_manager::config_load, this), config_saveload_delegate(&bookkeeping_manager::config_save, this));
}

6
src/emu/crsshair.cpp
View File

@ -287,7 +287,7 @@ crosshair_manager::crosshair_manager(running_machine &machine)
, m_auto_time(CROSSHAIR_VISIBILITY_AUTOTIME_DEFAULT)
{
/* request a callback upon exiting */
machine.add_notifier(MACHINE_NOTIFY_EXIT, machine_notify_delegate(FUNC(crosshair_manager::exit), this));
machine.add_notifier(MACHINE_NOTIFY_EXIT, machine_notify_delegate(&crosshair_manager::exit, this));
for (int player = 0; player < MAX_PLAYERS; player++)
m_crosshair[player] = std::make_unique<render_crosshair>(machine, player);
@ -311,11 +311,11 @@ crosshair_manager::crosshair_manager(running_machine &machine)
/* register callbacks for when we load/save configurations */
if (m_usage)
machine.configuration().config_register("crosshairs", config_saveload_delegate(FUNC(crosshair_manager::config_load), this), config_saveload_delegate(FUNC(crosshair_manager::config_save), this));
machine.configuration().config_register("crosshairs", config_saveload_delegate(&crosshair_manager::config_load, this), config_saveload_delegate(&crosshair_manager::config_save, this));
/* register the animation callback */
if (machine.first_screen() != nullptr)
machine.first_screen()->register_vblank_callback(vblank_state_delegate(FUNC(crosshair_manager::animate), this));
machine.first_screen()->register_vblank_callback(vblank_state_delegate(&crosshair_manager::animate, this));
}
/*-------------------------------------------------

2
src/emu/debug/debugcon.cpp
View File

@ -52,7 +52,7 @@ debugger_console::debugger_console(running_machine &machine)
printf("Currently targeting %s (%s)\n", m_machine.system().name, m_machine.system().description);
/* request callback upon exiting */
m_machine.add_notifier(MACHINE_NOTIFY_EXIT, machine_notify_delegate(FUNC(debugger_console::exit), this));
m_machine.add_notifier(MACHINE_NOTIFY_EXIT, machine_notify_delegate(&debugger_console::exit, this));
/* listen in on the errorlog */
using namespace std::placeholders;

2
src/emu/debug/debugcpu.cpp
View File

@ -83,7 +83,7 @@ debugger_cpu::debugger_cpu(running_machine &machine)
/* add callback for breaking on VBLANK */
if (m_machine.first_screen() != nullptr)
m_machine.first_screen()->register_vblank_callback(vblank_state_delegate(FUNC(debugger_cpu::on_vblank), this));
m_machine.first_screen()->register_vblank_callback(vblank_state_delegate(&debugger_cpu::on_vblank, this));
}
void debugger_cpu::configure_memory(symbol_table &table)

33
src/emu/devdelegate.h
View File

@ -38,15 +38,38 @@ protected:
};
// ======================> named_delegate
template<typename _Signature>
class named_delegate : public delegate<_Signature>
{
typedef delegate<_Signature> basetype;
public:
// create a standard set of constructors
named_delegate() : basetype(), m_name(nullptr) { }
explicit named_delegate(const basetype &src) : basetype(src), m_name(src.m_name) { }
named_delegate(const basetype &src, delegate_late_bind &object) : basetype(src, object), m_name(src.m_name) { }
template<class _FunctionClass> named_delegate(typename basetype::template traits<_FunctionClass>::member_func_type funcptr, const char *name, _FunctionClass *object) : basetype(funcptr, object), m_name(name) { }
template<class _FunctionClass> named_delegate(typename basetype::template traits<_FunctionClass>::const_member_func_type funcptr, const char *name, _FunctionClass *object) : basetype(funcptr, object), m_name(name) { }
explicit named_delegate(std::function<_Signature> funcptr, const char *name) : basetype(funcptr), m_name(name) { }
template<class _FunctionClass> named_delegate(typename basetype::template traits<_FunctionClass>::static_func_type funcptr, const char *name, _FunctionClass *object) : basetype(funcptr, object), m_name(name) { }
template<class _FunctionClass> named_delegate(typename basetype::template traits<_FunctionClass>::static_ref_func_type funcptr, const char *name, _FunctionClass *object) : basetype(funcptr, object), m_name(name) { }
named_delegate &operator=(const basetype &src) { *static_cast<basetype *>(this) = src; m_name = src.m_name; return *this; }
const char *name() const { return m_name; }
private:
const char * m_name; // name string
};
// ======================> device_delegate
// device_delegate is a delegate that wraps with a device tag and can be easily
// late bound without replicating logic everywhere
template<typename _Signature>
class device_delegate : public delegate<_Signature>, device_delegate_helper
class device_delegate : public named_delegate<_Signature>, device_delegate_helper
{
typedef device_delegate<_Signature> thistype;
typedef delegate<_Signature> basetype;
typedef named_delegate<_Signature> basetype;
public:
// provide the same constructors as the base class
@ -55,11 +78,9 @@ public:
device_delegate(const basetype &src, delegate_late_bind &object) : basetype(src, object), device_delegate_helper(src.m_device_name) { }
template<class _FunctionClass> device_delegate(typename basetype::template traits<_FunctionClass>::member_func_type funcptr, const char *name, _FunctionClass *object) : basetype(funcptr, name, object), device_delegate_helper(safe_tag(dynamic_cast<device_t *>(object))) { }
template<class _FunctionClass> device_delegate(typename basetype::template traits<_FunctionClass>::const_member_func_type funcptr, const char *name, _FunctionClass *object) : basetype(funcptr, name, object), device_delegate_helper(safe_tag(dynamic_cast<device_t *>(object))) { }
#ifdef USE_STATIC_DELEGATE
template<class _FunctionClass> device_delegate(typename basetype::template traits<_FunctionClass>::static_func_type funcptr, const char *name, _FunctionClass *object) : basetype(funcptr, name, object), device_delegate_helper(safe_tag(dynamic_cast<device_t *>(object))) { }
template<class _FunctionClass> device_delegate(typename basetype::template traits<_FunctionClass>::static_ref_func_type funcptr, const char *name, _FunctionClass *object) : basetype(funcptr, name, object), device_delegate_helper(safe_tag(dynamic_cast<device_t *>(object))) { }
#endif
device_delegate(std::function<_Signature> funcptr) : basetype(funcptr), device_delegate_helper(nullptr) { }
device_delegate(std::function<_Signature> funcptr, const char *name) : basetype(funcptr,name), device_delegate_helper(nullptr) { }
device_delegate &operator=(const thistype &src) { *static_cast<basetype *>(this) = src; m_device_name = src.m_device_name; return *this; }
// provide additional constructors that take a device name string
@ -67,12 +88,10 @@ public:
template<class _FunctionClass> device_delegate(typename basetype::template traits<_FunctionClass>::member_func_type funcptr, const char *name, const char *devname, _FunctionClass *) : basetype(funcptr, name, static_cast<_FunctionClass *>(nullptr)), device_delegate_helper(devname) { }
template<class _FunctionClass> device_delegate(typename basetype::template traits<_FunctionClass>::const_member_func_type funcptr, const char *name, const char *devname) : basetype(funcptr, name, static_cast<_FunctionClass *>(nullptr)), device_delegate_helper(devname) { }
template<class _FunctionClass> device_delegate(typename basetype::template traits<_FunctionClass>::const_member_func_type funcptr, const char *name, const char *devname, _FunctionClass *) : basetype(funcptr, name, static_cast<_FunctionClass *>(nullptr)), device_delegate_helper(devname) { }
#ifdef USE_STATIC_DELEGATE
template<class _FunctionClass> device_delegate(typename basetype::template traits<_FunctionClass>::static_func_type funcptr, const char *name, const char *devname, _FunctionClass *) : basetype(funcptr, name, static_cast<_FunctionClass *>(nullptr)), device_delegate_helper(devname) { }
template<class _FunctionClass> device_delegate(typename basetype::template traits<_FunctionClass>::static_ref_func_type funcptr, const char *name, const char *devname, _FunctionClass *) : basetype(funcptr, name, static_cast<_FunctionClass *>(nullptr)), device_delegate_helper(devname) { }
device_delegate(typename basetype::template traits<device_t>::static_func_type funcptr, const char *name) : basetype(funcptr, name, static_cast<device_t *>(nullptr)), device_delegate_helper(nullptr) { }
device_delegate(typename basetype::template traits<device_t>::static_ref_func_type funcptr, const char *name) : basetype(funcptr, name, static_cast<device_t *>(nullptr)), device_delegate_helper(nullptr) { }
#endif
// and constructors that provide a search root
device_delegate(const thistype &src, device_t &search_root) : basetype(src), device_delegate_helper(src.m_device_name) { bind_relative_to(search_root); }

2
src/emu/diexec.cpp
View File

@ -548,7 +548,7 @@ void device_execute_interface::interface_post_reset()
screen_device *screen = downcast<screen_device *>(device().machine().device(device().siblingtag(m_vblank_interrupt_screen).c_str()));
assert(screen != nullptr);
screen->register_vblank_callback(vblank_state_delegate(FUNC(device_execute_interface::on_vblank), this));
screen->register_vblank_callback(vblank_state_delegate(&device_execute_interface::on_vblank, this));
}
// reconfigure periodic interrupts

4
src/emu/diimage.h
View File

@ -116,13 +116,13 @@ typedef void (*device_image_partialhash_func)(util::hash_collection &, const uns
#define DEVICE_IMAGE_LOAD_NAME(_class,_name) _class::DEVICE_IMAGE_LOAD_MEMBER_NAME(_name)
#define DECLARE_DEVICE_IMAGE_LOAD_MEMBER(_name) image_init_result DEVICE_IMAGE_LOAD_MEMBER_NAME(_name)(device_image_interface &image)
#define DEVICE_IMAGE_LOAD_MEMBER(_class,_name) image_init_result DEVICE_IMAGE_LOAD_NAME(_class,_name)(device_image_interface &image)
#define DEVICE_IMAGE_LOAD_DELEGATE(_class,_name) device_image_load_delegate(&DEVICE_IMAGE_LOAD_NAME(_class,_name),#_class "::device_image_load_" #_name, downcast<_class *>(device->owner()))
#define DEVICE_IMAGE_LOAD_DELEGATE(_class,_name) device_image_load_delegate(&DEVICE_IMAGE_LOAD_NAME(_class,_name), downcast<_class *>(device->owner()))
#define DEVICE_IMAGE_UNLOAD_MEMBER_NAME(_name) device_image_unload_##_name
#define DEVICE_IMAGE_UNLOAD_NAME(_class,_name) _class::DEVICE_IMAGE_UNLOAD_MEMBER_NAME(_name)
#define DECLARE_DEVICE_IMAGE_UNLOAD_MEMBER(_name) void DEVICE_IMAGE_UNLOAD_MEMBER_NAME(_name)(device_image_interface &image)
#define DEVICE_IMAGE_UNLOAD_MEMBER(_class,_name) void DEVICE_IMAGE_UNLOAD_NAME(_class,_name)(device_image_interface &image)
#define DEVICE_IMAGE_UNLOAD_DELEGATE(_class,_name) device_image_func_delegate(&DEVICE_IMAGE_UNLOAD_NAME(_class,_name),#_class "::device_image_unload_" #_name, downcast<_class *>(device->owner()))
#define DEVICE_IMAGE_UNLOAD_DELEGATE(_class,_name) device_image_func_delegate(&DEVICE_IMAGE_UNLOAD_NAME(_class,_name), downcast<_class *>(device->owner()))
#define MCFG_SET_IMAGE_LOADABLE(_usrload) \
device_image_interface::static_set_user_loadable(*device, _usrload);

12
src/emu/driver.h
View File

@ -24,28 +24,28 @@
// core machine callbacks
#define MCFG_MACHINE_START_OVERRIDE(_class, _func) \
driver_device::static_set_callback(config.root_device(), driver_device::CB_MACHINE_START, driver_callback_delegate(&_class::MACHINE_START_NAME(_func), #_class "::machine_start_" #_func, downcast<_class *>(owner)));
driver_device::static_set_callback(config.root_device(), driver_device::CB_MACHINE_START, driver_callback_delegate(&_class::MACHINE_START_NAME(_func), downcast<_class *>(owner)));
#define MCFG_MACHINE_RESET_OVERRIDE(_class, _func) \
driver_device::static_set_callback(config.root_device(), driver_device::CB_MACHINE_RESET, driver_callback_delegate(&_class::MACHINE_RESET_NAME(_func), #_class "::machine_reset_" #_func, downcast<_class *>(owner)));
driver_device::static_set_callback(config.root_device(), driver_device::CB_MACHINE_RESET, driver_callback_delegate(&_class::MACHINE_RESET_NAME(_func), downcast<_class *>(owner)));
#define MCFG_MACHINE_RESET_REMOVE() \
driver_device::static_set_callback(config.root_device(), driver_device::CB_MACHINE_RESET, driver_callback_delegate());
// core sound callbacks
#define MCFG_SOUND_START_OVERRIDE(_class, _func) \
driver_device::static_set_callback(config.root_device(), driver_device::CB_SOUND_START, driver_callback_delegate(&_class::SOUND_START_NAME(_func), #_class "::sound_start_" #_func, downcast<_class *>(owner)));
driver_device::static_set_callback(config.root_device(), driver_device::CB_SOUND_START, driver_callback_delegate(&_class::SOUND_START_NAME(_func), downcast<_class *>(owner)));
#define MCFG_SOUND_RESET_OVERRIDE(_class, _func) \
driver_device::static_set_callback(config.root_device(), driver_device::CB_SOUND_RESET, driver_callback_delegate(&_class::SOUND_RESET_NAME(_func), #_class "::sound_reset_" #_func, downcast<_class *>(owner)));
driver_device::static_set_callback(config.root_device(), driver_device::CB_SOUND_RESET, driver_callback_delegate(&_class::SOUND_RESET_NAME(_func), downcast<_class *>(owner)));
// core video callbacks
#define MCFG_VIDEO_START_OVERRIDE(_class, _func) \
driver_device::static_set_callback(config.root_device(), driver_device::CB_VIDEO_START, driver_callback_delegate(&_class::VIDEO_START_NAME(_func), #_class "::video_start_" #_func, downcast<_class *>(owner)));
driver_device::static_set_callback(config.root_device(), driver_device::CB_VIDEO_START, driver_callback_delegate(&_class::VIDEO_START_NAME(_func), downcast<_class *>(owner)));
#define MCFG_VIDEO_RESET_OVERRIDE(_class, _func) \
driver_device::static_set_callback(config.root_device(), driver_device::CB_VIDEO_RESET, driver_callback_delegate(&_class::VIDEO_RESET_NAME(_func), #_class "::video_reset_" #_func, downcast<_class *>(owner)));
driver_device::static_set_callback(config.root_device(), driver_device::CB_VIDEO_RESET, driver_callback_delegate(&_class::VIDEO_RESET_NAME(_func), downcast<_class *>(owner)));

2
src/emu/emumem.h
View File

@ -83,7 +83,7 @@ typedef uint32_t offs_t;
typedef void (*address_map_constructor)(address_map &map, device_t &devconfig);
// submap retriever delegate
typedef delegate<void (address_map &, device_t &)> address_map_delegate;
typedef named_delegate<void (address_map &, device_t &)> address_map_delegate;
// struct with function pointers for accessors; use is generally discouraged unless necessary
struct data_accessors

4
src/emu/image.cpp
View File

@ -76,7 +76,7 @@ image_manager::image_manager(running_machine &machine)
}
}
machine.configuration().config_register("image_directories", config_saveload_delegate(FUNC(image_manager::config_load), this), config_saveload_delegate(FUNC(image_manager::config_save), this));
machine.configuration().config_register("image_directories", config_saveload_delegate(&image_manager::config_load, this), config_saveload_delegate(&image_manager::config_save, this));
}
//-------------------------------------------------
@ -233,5 +233,5 @@ void image_manager::postdevice_init()
}
}
/* add a callback for when we shut down */
machine().add_notifier(MACHINE_NOTIFY_EXIT, machine_notify_delegate(FUNC(image_manager::unload_all), this));
machine().add_notifier(MACHINE_NOTIFY_EXIT, machine_notify_delegate(&image_manager::unload_all, this));
}

2
src/emu/inputdev.cpp
View File

@ -585,7 +585,7 @@ input_class_keyboard::input_class_keyboard(input_manager &manager)
: input_class(manager, DEVICE_CLASS_KEYBOARD, "keyboard", true, manager.machine().options().multi_keyboard())
{
// request a per-frame callback for the keyboard class
machine().add_notifier(MACHINE_NOTIFY_FRAME, machine_notify_delegate(FUNC(input_class_keyboard::frame_callback), this));
machine().add_notifier(MACHINE_NOTIFY_FRAME, machine_notify_delegate(&input_class_keyboard::frame_callback, this));
}

6
src/emu/ioport.cpp
View File

@ -1681,8 +1681,8 @@ ioport_manager::ioport_manager(running_machine &machine)
time_t ioport_manager::initialize()
{
// add an exit callback and a frame callback
machine().add_notifier(MACHINE_NOTIFY_EXIT, machine_notify_delegate(FUNC(ioport_manager::exit), this));
machine().add_notifier(MACHINE_NOTIFY_FRAME, machine_notify_delegate(FUNC(ioport_manager::frame_update_callback), this));
machine().add_notifier(MACHINE_NOTIFY_EXIT, machine_notify_delegate(&ioport_manager::exit, this));
machine().add_notifier(MACHINE_NOTIFY_FRAME, machine_notify_delegate(&ioport_manager::frame_update_callback, this));
// initialize the default port info from the OSD
init_port_types();
@ -1747,7 +1747,7 @@ time_t ioport_manager::initialize()
m_natkeyboard = std::make_unique<natural_keyboard>(machine());
// register callbacks for when we load configurations
machine().configuration().config_register("input", config_saveload_delegate(FUNC(ioport_manager::load_config), this), config_saveload_delegate(FUNC(ioport_manager::save_config), this));
machine().configuration().config_register("input", config_saveload_delegate(&ioport_manager::load_config, this), config_saveload_delegate(&ioport_manager::save_config, this));
// open playback and record files if specified
time_t basetime = playback_init();

4
src/emu/machine.cpp
View File

@ -256,8 +256,8 @@ void running_machine::start()
manager().create_custom(*this);
// register callbacks for the devices, then start them
add_notifier(MACHINE_NOTIFY_RESET, machine_notify_delegate(FUNC(running_machine::reset_all_devices), this));
add_notifier(MACHINE_NOTIFY_EXIT, machine_notify_delegate(FUNC(running_machine::stop_all_devices), this));
add_notifier(MACHINE_NOTIFY_RESET, machine_notify_delegate(&running_machine::reset_all_devices, this));
add_notifier(MACHINE_NOTIFY_EXIT, machine_notify_delegate(&running_machine::stop_all_devices, this));
save().register_presave(save_prepost_delegate(FUNC(running_machine::presave_all_devices), this));
start_all_devices();
save().register_postload(save_prepost_delegate(FUNC(running_machine::postload_all_devices), this));

2
src/emu/network.cpp
View File

@ -24,7 +24,7 @@
network_manager::network_manager(running_machine &machine)
: m_machine(machine)
{
machine.configuration().config_register("network", config_saveload_delegate(FUNC(network_manager::config_load), this), config_saveload_delegate(FUNC(network_manager::config_save), this));
machine.configuration().config_register("network", config_saveload_delegate(&network_manager::config_load, this), config_saveload_delegate(&network_manager::config_save, this));
}
//-------------------------------------------------

4
src/emu/output.cpp
View File

@ -28,8 +28,8 @@ output_manager::output_manager(running_machine &machine)
m_uniqueid(12345)
{
/* add pause callback */
machine.add_notifier(MACHINE_NOTIFY_PAUSE, machine_notify_delegate(FUNC(output_manager::pause), this));
machine.add_notifier(MACHINE_NOTIFY_RESUME, machine_notify_delegate(FUNC(output_manager::resume), this));
machine.add_notifier(MACHINE_NOTIFY_PAUSE, machine_notify_delegate(&output_manager::pause, this));
machine.add_notifier(MACHINE_NOTIFY_RESUME, machine_notify_delegate(&output_manager::resume, this));
}
/*-------------------------------------------------

2
src/emu/render.cpp
View File

@ -2618,7 +2618,7 @@ render_manager::render_manager(running_machine &machine)
m_ui_container(global_alloc(render_container(*this)))
{
// register callbacks
machine.configuration().config_register("video", config_saveload_delegate(FUNC(render_manager::config_load), this), config_saveload_delegate(FUNC(render_manager::config_save), this));
machine.configuration().config_register("video", config_saveload_delegate(&render_manager::config_load, this), config_saveload_delegate(&render_manager::config_save, this));
// create one container per screen
for (screen_device &screen : screen_device_iterator(machine.root_device()))

2
src/emu/save.h
View File

@ -39,7 +39,7 @@ enum save_error
//**************************************************************************
// callback delegate for presave/postload
typedef delegate<void ()> save_prepost_delegate;
typedef named_delegate<void ()> save_prepost_delegate;
// use this to declare a given type is a simple, non-pointer type that can be

2
src/emu/schedule.h
View File

@ -39,7 +39,7 @@
//**************************************************************************
// timer callbacks look like this
typedef delegate<void (void *, int32_t)> timer_expired_delegate;
typedef named_delegate<void (void *, int32_t)> timer_expired_delegate;
// ======================> emu_timer

12
src/emu/sound.cpp
View File

@ -72,7 +72,7 @@ sound_stream::sound_stream(device_t &device, int inputs, int outputs, int sample
throw emu_fatalerror("Attempted to create a sound_stream with a non-sound device");
if(m_callback.isnull())
m_callback = stream_update_delegate(FUNC(device_sound_interface::sound_stream_update),(device_sound_interface *)sound);
m_callback = stream_update_delegate(&device_sound_interface::sound_stream_update,(device_sound_interface *)sound);
// create a unique tag for saving
std::string state_tag = string_format("%d", m_device.machine().sound().m_stream_list.size());
@ -835,11 +835,11 @@ sound_manager::sound_manager(running_machine &machine)
#endif
// register callbacks
machine.configuration().config_register("mixer", config_saveload_delegate(FUNC(sound_manager::config_load), this), config_saveload_delegate(FUNC(sound_manager::config_save), this));
machine.add_notifier(MACHINE_NOTIFY_PAUSE, machine_notify_delegate(FUNC(sound_manager::pause), this));
machine.add_notifier(MACHINE_NOTIFY_RESUME, machine_notify_delegate(FUNC(sound_manager::resume), this));
machine.add_notifier(MACHINE_NOTIFY_RESET, machine_notify_delegate(FUNC(sound_manager::reset), this));
machine.add_notifier(MACHINE_NOTIFY_EXIT, machine_notify_delegate(FUNC(sound_manager::stop_recording), this));
machine.configuration().config_register("mixer", config_saveload_delegate(&sound_manager::config_load, this), config_saveload_delegate(&sound_manager::config_save, this));
machine.add_notifier(MACHINE_NOTIFY_PAUSE, machine_notify_delegate(&sound_manager::pause, this));
machine.add_notifier(MACHINE_NOTIFY_RESUME, machine_notify_delegate(&sound_manager::resume, this));
machine.add_notifier(MACHINE_NOTIFY_RESET, machine_notify_delegate(&sound_manager::reset, this));
machine.add_notifier(MACHINE_NOTIFY_EXIT, machine_notify_delegate(&sound_manager::stop_recording, this));
// register global states
machine.save().save_item(NAME(m_last_update));

2
src/emu/uiinput.cpp
View File

@ -45,7 +45,7 @@ ui_input_manager::ui_input_manager(running_machine &machine)
m_current_mouse_y = -1;
/* add a frame callback to poll inputs */
machine.add_notifier(MACHINE_NOTIFY_FRAME, machine_notify_delegate(FUNC(ui_input_manager::frame_update), this));
machine.add_notifier(MACHINE_NOTIFY_FRAME, machine_notify_delegate(&ui_input_manager::frame_update, this));
}

2
src/emu/video.cpp
View File

@ -116,7 +116,7 @@ video_manager::video_manager(running_machine &machine)
{
// request a callback upon exiting
machine.add_notifier(MACHINE_NOTIFY_EXIT, machine_notify_delegate(FUNC(video_manager::exit), this));
machine.add_notifier(MACHINE_NOTIFY_EXIT, machine_notify_delegate(&video_manager::exit, this));
machine.save().register_postload(save_prepost_delegate(FUNC(video_manager::postload), this));
// extract initial execution state from global configuration settings

2
src/frontend/mame/cheat.cpp
View File

@ -1070,7 +1070,7 @@ cheat_manager::cheat_manager(running_machine &machine)
m_justify.resize(UI_TARGET_FONT_ROWS*2);
// request a callback
machine.add_notifier(MACHINE_NOTIFY_FRAME, machine_notify_delegate(FUNC(cheat_manager::frame_update), this));
machine.add_notifier(MACHINE_NOTIFY_FRAME, machine_notify_delegate(&cheat_manager::frame_update, this));
// create a global symbol table
m_symtable.add("frame", symbol_table::READ_ONLY, &m_framecount);

12
src/frontend/mame/luaengine.cpp
View File

@ -670,12 +670,12 @@ void lua_engine::on_frame_done()
void lua_engine::attach_notifiers()
{
machine().add_notifier(MACHINE_NOTIFY_RESET, machine_notify_delegate(FUNC(lua_engine::on_machine_prestart), this), true);
machine().add_notifier(MACHINE_NOTIFY_RESET, machine_notify_delegate(FUNC(lua_engine::on_machine_start), this));
machine().add_notifier(MACHINE_NOTIFY_EXIT, machine_notify_delegate(FUNC(lua_engine::on_machine_stop), this));
machine().add_notifier(MACHINE_NOTIFY_PAUSE, machine_notify_delegate(FUNC(lua_engine::on_machine_pause), this));
machine().add_notifier(MACHINE_NOTIFY_RESUME, machine_notify_delegate(FUNC(lua_engine::on_machine_resume), this));
machine().add_notifier(MACHINE_NOTIFY_FRAME, machine_notify_delegate(FUNC(lua_engine::on_machine_frame), this));
machine().add_notifier(MACHINE_NOTIFY_RESET, machine_notify_delegate(&lua_engine::on_machine_prestart, this), true);
machine().add_notifier(MACHINE_NOTIFY_RESET, machine_notify_delegate(&lua_engine::on_machine_start, this));
machine().add_notifier(MACHINE_NOTIFY_EXIT, machine_notify_delegate(&lua_engine::on_machine_stop, this));
machine().add_notifier(MACHINE_NOTIFY_PAUSE, machine_notify_delegate(&lua_engine::on_machine_pause, this));
machine().add_notifier(MACHINE_NOTIFY_RESUME, machine_notify_delegate(&lua_engine::on_machine_resume, this));
machine().add_notifier(MACHINE_NOTIFY_FRAME, machine_notify_delegate(&lua_engine::on_machine_frame, this));
}
//-------------------------------------------------

2
src/frontend/mame/mame.cpp
View File

@ -269,7 +269,7 @@ ui_manager* mame_machine_manager::create_ui(running_machine& machine)
m_ui = std::make_unique<mame_ui_manager>(machine);
m_ui->init();
machine.add_notifier(MACHINE_NOTIFY_RESET, machine_notify_delegate(FUNC(mame_machine_manager::reset), this));
machine.add_notifier(MACHINE_NOTIFY_RESET, machine_notify_delegate(&mame_machine_manager::reset, this));
m_ui->set_startup_text("Initializing...", true);

2
src/frontend/mame/ui/menu.cpp
View File

@ -191,7 +191,7 @@ void menu::init(running_machine &machine, ui_options &mopt)
auto const ins(s_global_states.emplace(&machine, std::make_shared<global_state>(machine, mopt)));
assert(ins.second); // calling init twice is bad
if (ins.second)
machine.add_notifier(MACHINE_NOTIFY_EXIT, machine_notify_delegate(FUNC(menu::exit), &machine)); // add an exit callback to free memory
machine.add_notifier(MACHINE_NOTIFY_EXIT, machine_notify_delegate(&menu::exit, &machine)); // add an exit callback to free memory
else
ins.first->second->stack_reset();
}

2
src/frontend/mame/ui/ui.cpp
View File

@ -208,7 +208,7 @@ void mame_ui_manager::init()
m_mouse_show = machine().system().flags & MACHINE_CLICKABLE_ARTWORK ? true : false;
// request a callback upon exiting
machine().add_notifier(MACHINE_NOTIFY_EXIT, machine_notify_delegate(FUNC(mame_ui_manager::exit), this));
machine().add_notifier(MACHINE_NOTIFY_EXIT, machine_notify_delegate(&mame_ui_manager::exit, this));
// create mouse bitmap
bitmap_argb32 *ui_mouse_bitmap = auto_alloc(machine(), bitmap_argb32(32, 32));

2
src/frontend/mame/ui/viewgfx.cpp
View File

@ -140,7 +140,7 @@ void ui_gfx_init(running_machine &machine)
uint8_t rotate = machine.system().flags & ORIENTATION_MASK;
// make sure we clean up after ourselves
machine.add_notifier(MACHINE_NOTIFY_EXIT, machine_notify_delegate(FUNC(ui_gfx_exit), &machine));
machine.add_notifier(MACHINE_NOTIFY_EXIT, machine_notify_delegate(&ui_gfx_exit, &machine));
// initialize our global state
memset(state, 0, sizeof(*state));

4
src/ldplayer/ldplayer.cpp
View File

@ -641,7 +641,7 @@ MACHINE_CONFIG_END
static MACHINE_CONFIG_DERIVED_CLASS( ldv1000, ldplayer_ntsc, ldv1000_state )
MCFG_LASERDISC_LDV1000_ADD("laserdisc")
MCFG_LASERDISC_GET_DISC(laserdisc_get_disc_delegate(FUNC(ldplayer_state::get_disc_static), device))
MCFG_LASERDISC_GET_DISC(laserdisc_get_disc_delegate(&ldplayer_state::get_disc_static, device))
MCFG_LASERDISC_SCREEN_ADD_NTSC("screen", "laserdisc")
MCFG_SPEAKER_STANDARD_STEREO("lspeaker", "rspeaker")
@ -653,7 +653,7 @@ MACHINE_CONFIG_END
static MACHINE_CONFIG_DERIVED_CLASS( pr8210, ldplayer_ntsc, pr8210_state )
MCFG_LASERDISC_PR8210_ADD("laserdisc")
MCFG_LASERDISC_GET_DISC(laserdisc_get_disc_delegate(FUNC(ldplayer_state::get_disc_static), device))
MCFG_LASERDISC_GET_DISC(laserdisc_get_disc_delegate(&ldplayer_state::get_disc_static, device))
MCFG_LASERDISC_SCREEN_ADD_NTSC("screen", "laserdisc")
MCFG_SPEAKER_STANDARD_STEREO("lspeaker", "rspeaker")

39
src/lib/util/delegate.h
View File

@ -116,8 +116,6 @@
#define USE_DELEGATE_TYPE DELEGATE_TYPE_COMPATIBLE
#endif
#define USE_STATIC_DELEGATE 1
#if defined(FORCE_COMPATIBLE)
#undef USE_DELEGATE_TYPE
#undef MEMBER_ABI
@ -424,7 +422,6 @@ public:
delegate_base()
: m_function(nullptr),
m_object(nullptr),
m_name(nullptr),
m_latebinder(nullptr),
m_raw_function(nullptr),
m_std_func(nullptr){ }
@ -433,7 +430,6 @@ public:
delegate_base(const delegate_base &src)
: m_function(src.m_function),
m_object(nullptr),
m_name(src.m_name),
m_latebinder(src.m_latebinder),
m_raw_function(src.m_raw_function),
m_raw_mfp(src.m_raw_mfp),
@ -446,7 +442,6 @@ public:
delegate_base(const delegate_base &src, delegate_late_bind &object)
: m_function(src.m_function),
m_object(nullptr),
m_name(src.m_name),
m_latebinder(src.m_latebinder),
m_raw_function(src.m_raw_function),
m_raw_mfp(src.m_raw_mfp),
@ -457,10 +452,9 @@ public:
// construct from member function with object pointer
template<class _FunctionClass>
delegate_base(typename traits<_FunctionClass>::member_func_type funcptr, const char *name, _FunctionClass *object)
delegate_base(typename traits<_FunctionClass>::member_func_type funcptr, _FunctionClass *object)
: m_function(nullptr),
m_object(nullptr),
m_name(name),
m_latebinder(&late_bind_helper<_FunctionClass>),
m_raw_function(nullptr),
m_raw_mfp(funcptr, object, static_cast<_ReturnType *>(nullptr), static_cast<generic_static_func>(nullptr)),
@ -470,10 +464,9 @@ public:
}
template<class _FunctionClass>
delegate_base(typename traits<_FunctionClass>::const_member_func_type funcptr, const char *name, _FunctionClass *object)
delegate_base(typename traits<_FunctionClass>::const_member_func_type funcptr, _FunctionClass *object)
: m_function(nullptr),
m_object(nullptr),
m_name(name),
m_latebinder(&late_bind_helper<_FunctionClass>),
m_raw_function(nullptr),
m_raw_mfp(funcptr, object, static_cast<_ReturnType *>(nullptr), static_cast<generic_static_func>(nullptr)),
@ -484,10 +477,9 @@ public:
// construct from static function with object pointer
template<class _FunctionClass>
delegate_base(typename traits<_FunctionClass>::static_func_type funcptr, const char *name, _FunctionClass *object)
delegate_base(typename traits<_FunctionClass>::static_func_type funcptr, _FunctionClass *object)
: m_function(reinterpret_cast<generic_static_func>(funcptr)),
m_object(nullptr),
m_name(name),
m_latebinder(&late_bind_helper<_FunctionClass>),
m_raw_function(reinterpret_cast<generic_static_func>(funcptr)),
m_std_func(nullptr)
@ -497,10 +489,9 @@ public:
// construct from static reference function with object reference
template<class _FunctionClass>
delegate_base(typename traits<_FunctionClass>::static_ref_func_type funcptr, const char *name, _FunctionClass *object)
delegate_base(typename traits<_FunctionClass>::static_ref_func_type funcptr, _FunctionClass *object)
: m_function(reinterpret_cast<generic_static_func>(funcptr)),
m_object(nullptr),
m_name(name),
m_latebinder(&late_bind_helper<_FunctionClass>),
m_raw_function(reinterpret_cast<generic_static_func>(funcptr)),
m_std_func(nullptr)
@ -509,10 +500,9 @@ public:
}
// construct from static reference function with object reference
delegate_base(functional_type funcptr, const char *name)
delegate_base(functional_type funcptr)
: m_function(nullptr),
m_object(nullptr),
m_name(name),
m_latebinder(nullptr),
m_raw_function(nullptr),
m_std_func(funcptr)
@ -527,7 +517,6 @@ public:
{
m_function = src.m_function;
m_object = nullptr;
m_name = src.m_name;
m_latebinder = src.m_latebinder;
m_raw_function = src.m_raw_function;
m_raw_mfp = src.m_raw_mfp;
@ -556,8 +545,7 @@ public:
}
// getters
bool has_object() const { return (object() != nullptr) || (m_std_func); }
const char *name() const { return m_name; }
bool has_object() const { return (object() != nullptr); }
// helpers
bool isnull() const { return (m_raw_function == nullptr && m_raw_mfp.isnull() && !m_std_func); }
@ -597,7 +585,6 @@ protected:
// internal state
generic_static_func m_function; // resolved static function pointer
delegate_generic_class * m_object; // resolved object to the post-cast object
const char * m_name; // name string
late_bind_func m_latebinder; // late binding helper
generic_static_func m_raw_function; // raw static function pointer
delegate_mfp m_raw_mfp; // raw member function pointer
@ -622,15 +609,13 @@ class delegate<_ReturnType (Params...)> : public delegate_base<_ReturnType, Para
public:
// create a standard set of constructors
delegate() : basetype() { }
delegate(const basetype &src) : basetype(src) { }
explicit delegate(const basetype &src) : basetype(src) { }
delegate(const basetype &src, delegate_late_bind &object) : basetype(src, object) { }
template<class _FunctionClass> delegate(typename basetype::template traits<_FunctionClass>::member_func_type funcptr, const char *name, _FunctionClass *object) : basetype(funcptr, name, object) { }
template<class _FunctionClass> delegate(typename basetype::template traits<_FunctionClass>::const_member_func_type funcptr, const char *name, _FunctionClass *object) : basetype(funcptr, name, object) { }
delegate(std::function<_ReturnType(Params...)> funcptr) : basetype(funcptr, "") { }
#ifdef USE_STATIC_DELEGATE
template<class _FunctionClass> delegate(typename basetype::template traits<_FunctionClass>::static_func_type funcptr, const char *name, _FunctionClass *object) : basetype(funcptr, name, object) { }
template<class _FunctionClass> delegate(typename basetype::template traits<_FunctionClass>::static_ref_func_type funcptr, const char *name, _FunctionClass *object) : basetype(funcptr, name, object) { }
#endif
template<class _FunctionClass> delegate(typename basetype::template traits<_FunctionClass>::member_func_type funcptr, _FunctionClass *object) : basetype(funcptr, object) { }
template<class _FunctionClass> delegate(typename basetype::template traits<_FunctionClass>::const_member_func_type funcptr, _FunctionClass *object) : basetype(funcptr, object) { }
explicit delegate(std::function<_ReturnType(Params...)> funcptr) : basetype(funcptr) { }
template<class _FunctionClass> delegate(typename basetype::template traits<_FunctionClass>::static_func_type funcptr, _FunctionClass *object) : basetype(funcptr, object) { }
template<class _FunctionClass> delegate(typename basetype::template traits<_FunctionClass>::static_ref_func_type funcptr,_FunctionClass *object) : basetype(funcptr, object) { }
delegate &operator=(const basetype &src) { *static_cast<basetype *>(this) = src; return *this; }
};

2
src/mame/drivers/a2600.cpp
View File

@ -383,7 +383,7 @@ MACHINE_START_MEMBER(a2600_state,a2600)
case A26_F6:
case A26_DPC:
m_maincpu->space(AS_PROGRAM).install_readwrite_handler(0x1000, 0x1fff, read8_delegate(FUNC(vcs_cart_slot_device::read_rom),(vcs_cart_slot_device*)m_cart), write8_delegate(FUNC(vcs_cart_slot_device::write_bank),(vcs_cart_slot_device*)m_cart));
m_maincpu->space(AS_PROGRAM).set_direct_update_handler(direct_update_delegate(FUNC(vcs_cart_slot_device::cart_opbase),(vcs_cart_slot_device*)m_cart));
m_maincpu->space(AS_PROGRAM).set_direct_update_handler(direct_update_delegate(&vcs_cart_slot_device::cart_opbase,(vcs_cart_slot_device*)m_cart));
break;
case A26_FE:
m_maincpu->space(AS_PROGRAM).install_readwrite_handler(0x1000, 0x1fff, read8_delegate(FUNC(vcs_cart_slot_device::read_rom),(vcs_cart_slot_device*)m_cart), write8_delegate(FUNC(vcs_cart_slot_device::write_ram),(vcs_cart_slot_device*)m_cart));

8
src/mame/drivers/abc80x.cpp
View File

@ -1608,7 +1608,7 @@ DIRECT_UPDATE_MEMBER( abc800c_state::direct_update_handler )
DRIVER_INIT_MEMBER(abc800c_state,driver_init)
{
m_maincpu->space(AS_PROGRAM).set_direct_update_handler(direct_update_delegate(FUNC(abc800c_state::direct_update_handler), this));
m_maincpu->space(AS_PROGRAM).set_direct_update_handler(direct_update_delegate(&abc800c_state::direct_update_handler, this));
}
@ -1642,7 +1642,7 @@ DIRECT_UPDATE_MEMBER( abc800m_state::direct_update_handler )
DRIVER_INIT_MEMBER(abc800m_state,driver_init)
{
m_maincpu->space(AS_PROGRAM).set_direct_update_handler(direct_update_delegate(FUNC(abc800m_state::direct_update_handler), this));
m_maincpu->space(AS_PROGRAM).set_direct_update_handler(direct_update_delegate(&abc800m_state::direct_update_handler, this));
}
@ -1666,7 +1666,7 @@ DIRECT_UPDATE_MEMBER( abc802_state::direct_update_handler )
DRIVER_INIT_MEMBER(abc802_state,driver_init)
{
m_maincpu->space(AS_PROGRAM).set_direct_update_handler(direct_update_delegate(FUNC(abc802_state::direct_update_handler), this));
m_maincpu->space(AS_PROGRAM).set_direct_update_handler(direct_update_delegate(&abc802_state::direct_update_handler, this));
}
@ -1700,7 +1700,7 @@ DIRECT_UPDATE_MEMBER( abc806_state::direct_update_handler )
DRIVER_INIT_MEMBER(abc806_state,driver_init)
{
m_maincpu->space(AS_PROGRAM).set_direct_update_handler(direct_update_delegate(FUNC(abc806_state::direct_update_handler), this));
m_maincpu->space(AS_PROGRAM).set_direct_update_handler(direct_update_delegate(&abc806_state::direct_update_handler, this));
}

2
src/mame/drivers/atarisy4.cpp
View File

@ -302,7 +302,7 @@ void atarisy4_renderer::draw_polygon(uint16_t color)
rectangle clip;
vertex_t v1, v2, v3;
atarisy4_polydata &extradata = object_data_alloc();
render_delegate rd_scan = render_delegate(FUNC(atarisy4_renderer::draw_scanline), this);
render_delegate rd_scan = render_delegate(&atarisy4_renderer::draw_scanline, this);
clip.set(0, 511, 0, 511);

2
src/mame/drivers/atm.cpp
View File

@ -147,7 +147,7 @@ MACHINE_RESET_MEMBER(atm_state,atm)
{
m_beta->enable();
}
space.set_direct_update_handler(direct_update_delegate(FUNC(atm_state::atm_direct), this));
space.set_direct_update_handler(direct_update_delegate(&atm_state::atm_direct, this));
memset(messram,0,128*1024);

14
src/mame/drivers/cobra.cpp
View File

@ -1060,7 +1060,7 @@ void cobra_state::cobra_video_exit()
void cobra_state::video_start()
{
machine().add_notifier(MACHINE_NOTIFY_EXIT, machine_notify_delegate(FUNC(cobra_state::cobra_video_exit), this));
machine().add_notifier(MACHINE_NOTIFY_EXIT, machine_notify_delegate(&cobra_state::cobra_video_exit, this));
m_renderer = std::make_unique<cobra_renderer>(*m_screen);
m_renderer->gfx_init();
@ -2531,7 +2531,7 @@ void cobra_renderer::gfx_fifo_exec()
{
if (w2 & 0x00200000)
{
render_delegate rd = render_delegate(FUNC(cobra_renderer::render_texture_scan), this);
render_delegate rd = render_delegate(&cobra_renderer::render_texture_scan, this);
for (int i=2; i < units; i++)
{
render_triangle(visarea, rd, 8, vert[i-2], vert[i-1], vert[i]);
@ -2539,7 +2539,7 @@ void cobra_renderer::gfx_fifo_exec()
}
else
{
render_delegate rd = render_delegate(FUNC(cobra_renderer::render_color_scan), this);
render_delegate rd = render_delegate(&cobra_renderer::render_color_scan, this);
for (int i=2; i < units; i++)
{
render_triangle(visarea, rd, 5, vert[i-2], vert[i-1], vert[i]);
@ -3331,7 +3331,7 @@ DRIVER_INIT_MEMBER(cobra_state, cobra)
8192,
"GFXFIFO_IN",
GFXFIFO_IN_VERBOSE != 0,
cobra_fifo::event_delegate(FUNC(cobra_state::gfxfifo_in_event_callback), this))
cobra_fifo::event_delegate(&cobra_state::gfxfifo_in_event_callback, this))
);
m_gfxfifo_out = auto_alloc(machine(),
@ -3339,7 +3339,7 @@ DRIVER_INIT_MEMBER(cobra_state, cobra)
8192,
"GFXFIFO_OUT",
GFXFIFO_OUT_VERBOSE != 0,
cobra_fifo::event_delegate(FUNC(cobra_state::gfxfifo_out_event_callback), this))
cobra_fifo::event_delegate(&cobra_state::gfxfifo_out_event_callback, this))
);
m_m2sfifo = auto_alloc(machine(),
@ -3347,7 +3347,7 @@ DRIVER_INIT_MEMBER(cobra_state, cobra)
2048,
"M2SFIFO",
M2SFIFO_VERBOSE != 0,
cobra_fifo::event_delegate(FUNC(cobra_state::m2sfifo_event_callback), this))
cobra_fifo::event_delegate(&cobra_state::m2sfifo_event_callback, this))
);
m_s2mfifo = auto_alloc(machine(),
@ -3355,7 +3355,7 @@ DRIVER_INIT_MEMBER(cobra_state, cobra)
2048,
"S2MFIFO",
S2MFIFO_VERBOSE != 0,
cobra_fifo::event_delegate(FUNC(cobra_state::s2mfifo_event_callback), this))
cobra_fifo::event_delegate(&cobra_state::s2mfifo_event_callback, this))
);
m_maincpu->ppc_set_dcstore_callback(write32_delegate(FUNC(cobra_state::main_cpu_dc_store),this));

2
src/mame/drivers/elwro800.cpp
View File

@ -507,7 +507,7 @@ MACHINE_RESET_MEMBER(elwro800_state,elwro800)
// this is a reset of ls175 in mmu
elwro800jr_mmu_w(0);
m_maincpu->space(AS_PROGRAM).set_direct_update_handler(direct_update_delegate(FUNC(elwro800_state::elwro800_direct_handler), this));
m_maincpu->space(AS_PROGRAM).set_direct_update_handler(direct_update_delegate(&elwro800_state::elwro800_direct_handler, this));
}
INTERRUPT_GEN_MEMBER(elwro800_state::elwro800jr_interrupt)

2
src/mame/drivers/firefox.cpp
View File

@ -512,7 +512,7 @@ void firefox_state::machine_start()
m_nvram_1c = machine().device<x2212_device>("nvram_1c");
m_nvram_1d = machine().device<x2212_device>("nvram_1d");
m_laserdisc->set_data_ready_callback(phillips_22vp931_device::data_ready_delegate(FUNC(firefox_state::firq_gen), this));
m_laserdisc->set_data_ready_callback(phillips_22vp931_device::data_ready_delegate(&firefox_state::firq_gen, this));
m_control_num = 0;
m_sprite_bank = 0;

2
src/mame/drivers/gba.cpp
View File

@ -1452,7 +1452,7 @@ DIRECT_UPDATE_MEMBER(gba_state::gba_direct)
DRIVER_INIT_MEMBER(gba_state,gbadv)
{
m_maincpu->space(AS_PROGRAM).set_direct_update_handler(direct_update_delegate(FUNC(gba_state::gba_direct), this));
m_maincpu->space(AS_PROGRAM).set_direct_update_handler(direct_update_delegate(&gba_state::gba_direct, this));
}

4
src/mame/drivers/gottlieb.cpp
View File

@ -1803,7 +1803,7 @@ static MACHINE_CONFIG_DERIVED( g2laser, gottlieb_core )
MCFG_SOUND_ROUTE(ALL_OUTPUTS, "speaker", 1.0)
MCFG_LASERDISC_PR8210_ADD("laserdisc")
MCFG_LASERDISC_AUDIO(laserdisc_audio_delegate(FUNC(gottlieb_state::laserdisc_audio_process), (gottlieb_state*)owner))
MCFG_LASERDISC_AUDIO(laserdisc_audio_delegate(gottlieb_state::laserdisc_audio_process, (gottlieb_state*)owner))
MCFG_LASERDISC_OVERLAY_DRIVER(GOTTLIEB_VIDEO_HCOUNT, GOTTLIEB_VIDEO_VCOUNT, gottlieb_state, screen_update_gottlieb)
MCFG_LASERDISC_OVERLAY_CLIP(0, GOTTLIEB_VIDEO_HBLANK-1, 0, GOTTLIEB_VIDEO_VBLANK-8)
MCFG_LASERDISC_OVERLAY_PALETTE("palette")
@ -1896,7 +1896,7 @@ static MACHINE_CONFIG_DERIVED( cobram3, gottlieb_core )
MCFG_SOUND_ROUTE(ALL_OUTPUTS, "speaker", 1.0)
MCFG_LASERDISC_PR8210_ADD("laserdisc")
MCFG_LASERDISC_AUDIO(laserdisc_audio_delegate(FUNC(gottlieb_state::laserdisc_audio_process), (gottlieb_state*)owner))
MCFG_LASERDISC_AUDIO(laserdisc_audio_delegate(gottlieb_state::laserdisc_audio_process, (gottlieb_state*)owner))
MCFG_LASERDISC_OVERLAY_DRIVER(GOTTLIEB_VIDEO_HCOUNT, GOTTLIEB_VIDEO_VCOUNT, gottlieb_state, screen_update_gottlieb)
MCFG_LASERDISC_OVERLAY_CLIP(0, GOTTLIEB_VIDEO_HBLANK-1, 0, GOTTLIEB_VIDEO_VBLANK-8)
MCFG_LASERDISC_OVERLAY_PALETTE("palette")

8
src/mame/drivers/hp64k.cpp
View File

@ -864,11 +864,11 @@ void hp64k_state::hp64k_update_drv_ctrl(void)
if (new_drive != m_current_floppy) {
m_fdc->set_floppy(new_drive);
floppy0->setup_index_pulse_cb(floppy_image_device::index_pulse_cb(FUNC(hp64k_state::hp64k_floppy_idx_cb) , this));
floppy1->setup_index_pulse_cb(floppy_image_device::index_pulse_cb(FUNC(hp64k_state::hp64k_floppy_idx_cb) , this));
floppy0->setup_index_pulse_cb(floppy_image_device::index_pulse_cb(&hp64k_state::hp64k_floppy_idx_cb, this));
floppy1->setup_index_pulse_cb(floppy_image_device::index_pulse_cb(&hp64k_state::hp64k_floppy_idx_cb, this));
floppy0->setup_wpt_cb(floppy_image_device::wpt_cb(FUNC(hp64k_state::hp64k_floppy_wpt_cb) , this));
floppy1->setup_wpt_cb(floppy_image_device::wpt_cb(FUNC(hp64k_state::hp64k_floppy_wpt_cb) , this));
floppy0->setup_wpt_cb(floppy_image_device::wpt_cb(&hp64k_state::hp64k_floppy_wpt_cb, this));
floppy1->setup_wpt_cb(floppy_image_device::wpt_cb(&hp64k_state::hp64k_floppy_wpt_cb, this));
m_current_floppy = new_drive;
}

4
src/mame/drivers/konamigq.cpp
View File

@ -316,8 +316,8 @@ static MACHINE_CONFIG_START( konamigq, konamigq_state )
MCFG_RAM_MODIFY("maincpu:ram")
MCFG_RAM_DEFAULT_SIZE("4M")
MCFG_PSX_DMA_CHANNEL_READ( "maincpu", 5, psx_dma_read_delegate( FUNC( konamigq_state::scsi_dma_read ), (konamigq_state *) owner ) )
MCFG_PSX_DMA_CHANNEL_WRITE( "maincpu", 5, psx_dma_write_delegate( FUNC( konamigq_state::scsi_dma_write ), (konamigq_state *) owner ) )
MCFG_PSX_DMA_CHANNEL_READ( "maincpu", 5, psx_dma_read_delegate(&konamigq_state::scsi_dma_read, (konamigq_state *) owner ) )
MCFG_PSX_DMA_CHANNEL_WRITE( "maincpu", 5, psx_dma_write_delegate(&konamigq_state::scsi_dma_write, (konamigq_state *) owner ) )
MCFG_CPU_ADD("soundcpu", M68000, XTAL_32MHz/4) /* 8MHz - measured */
MCFG_CPU_PROGRAM_MAP(konamigq_sound_map)

4
src/mame/drivers/konamigv.cpp
View File

@ -325,8 +325,8 @@ static MACHINE_CONFIG_START( konamigv, konamigv_state )
MCFG_RAM_MODIFY("maincpu:ram")
MCFG_RAM_DEFAULT_SIZE("2M")
MCFG_PSX_DMA_CHANNEL_READ( "maincpu", 5, psx_dma_read_delegate( FUNC( konamigv_state::scsi_dma_read ), (konamigv_state *) owner ) )
MCFG_PSX_DMA_CHANNEL_WRITE( "maincpu", 5, psx_dma_write_delegate( FUNC( konamigv_state::scsi_dma_write ), (konamigv_state *) owner ) )
MCFG_PSX_DMA_CHANNEL_READ( "maincpu", 5, psx_dma_read_delegate(&konamigv_state::scsi_dma_read, (konamigv_state *) owner ) )
MCFG_PSX_DMA_CHANNEL_WRITE( "maincpu", 5, psx_dma_write_delegate(&konamigv_state::scsi_dma_write, (konamigv_state *) owner ) )
MCFG_DEVICE_ADD("mb89371", MB89371, 0)
MCFG_EEPROM_SERIAL_93C46_ADD("eeprom")

6
src/mame/drivers/ksys573.cpp
View File

@ -2025,8 +2025,8 @@ static MACHINE_CONFIG_START( konami573, ksys573_state )
MCFG_RAM_MODIFY( "maincpu:ram" )
MCFG_RAM_DEFAULT_SIZE( "4M" )
MCFG_PSX_DMA_CHANNEL_READ( "maincpu", 5, psx_dma_read_delegate( FUNC( ksys573_state::cdrom_dma_read ), (ksys573_state *) owner ) )
MCFG_PSX_DMA_CHANNEL_WRITE( "maincpu", 5, psx_dma_write_delegate( FUNC( ksys573_state::cdrom_dma_write ), (ksys573_state *) owner ) )
MCFG_PSX_DMA_CHANNEL_READ( "maincpu", 5, psx_dma_read_delegate(&ksys573_state::cdrom_dma_read, (ksys573_state *) owner ) )
MCFG_PSX_DMA_CHANNEL_WRITE( "maincpu", 5, psx_dma_write_delegate(&ksys573_state::cdrom_dma_write, (ksys573_state *) owner ) )
MCFG_MACHINE_RESET_OVERRIDE( ksys573_state, konami573 )
@ -2064,7 +2064,7 @@ static MACHINE_CONFIG_START( konami573, ksys573_state )
/* video hardware */
MCFG_PSXGPU_ADD( "maincpu", "gpu", CXD8561Q, 0x200000, XTAL_53_693175MHz )
MCFG_PSXGPU_VBLANK_CALLBACK( vblank_state_delegate( FUNC( ksys573_state::sys573_vblank ), (ksys573_state *) owner ) )
MCFG_PSXGPU_VBLANK_CALLBACK(vblank_state_delegate(&ksys573_state::sys573_vblank, (ksys573_state *) owner ))
/* sound hardware */
MCFG_SPEAKER_STANDARD_STEREO( "lspeaker", "rspeaker" )

2
src/mame/drivers/mc1000.cpp
View File

@ -586,7 +586,7 @@ DIRECT_UPDATE_MEMBER(mc1000_state::mc1000_direct_update_handler)
DRIVER_INIT_MEMBER(mc1000_state,mc1000)
{
m_maincpu->space(AS_PROGRAM).set_direct_update_handler(direct_update_delegate(FUNC(mc1000_state::mc1000_direct_update_handler), this));
m_maincpu->space(AS_PROGRAM).set_direct_update_handler(direct_update_delegate(&mc1000_state::mc1000_direct_update_handler, this));
}
/* System Drivers */

2
src/mame/drivers/mediagx.cpp
View File

@ -973,7 +973,7 @@ void mediagx_state::install_speedups(const speedup_entry *entries, int count)
}
#ifdef MAME_DEBUG
machine().add_notifier(MACHINE_NOTIFY_EXIT, machine_notify_delegate(FUNC(mediagx_state::report_speedups), this));
machine().add_notifier(MACHINE_NOTIFY_EXIT, machine_notify_delegate(&mediagx_state::report_speedups, this));
#endif
}

2
src/mame/drivers/mpf1.cpp
View File

@ -475,7 +475,7 @@ DIRECT_UPDATE_MEMBER(mpf1_state::mpf1_direct_update_handler)
DRIVER_INIT_MEMBER(mpf1_state,mpf1)
{
m_maincpu->space(AS_PROGRAM).set_direct_update_handler(direct_update_delegate(FUNC(mpf1_state::mpf1_direct_update_handler), this));
m_maincpu->space(AS_PROGRAM).set_direct_update_handler(direct_update_delegate(&mpf1_state::mpf1_direct_update_handler, this));
}
COMP( 1979, mpf1, 0, 0, mpf1, mpf1, mpf1_state, mpf1, "Multitech", "Micro Professor 1", 0)

2
src/mame/drivers/mpz80.cpp
View File

@ -794,7 +794,7 @@ DIRECT_UPDATE_MEMBER(mpz80_state::mpz80_direct_update_handler)
DRIVER_INIT_MEMBER(mpz80_state,mpz80)
{
address_space &program = machine().device<cpu_device>(Z80_TAG)->space(AS_PROGRAM);
program.set_direct_update_handler(direct_update_delegate(FUNC(mpz80_state::mpz80_direct_update_handler), this));
program.set_direct_update_handler(direct_update_delegate(&mpz80_state::mpz80_direct_update_handler, this));
}

4
src/mame/drivers/namcos12.cpp
View File

@ -1677,7 +1677,7 @@ static MACHINE_CONFIG_START( coh700, namcos12_state )
MCFG_RAM_MODIFY("maincpu:ram")
MCFG_RAM_DEFAULT_SIZE("4M")
MCFG_PSX_DMA_CHANNEL_READ( "maincpu", 5, psx_dma_read_delegate( FUNC( namcos12_state::namcos12_rom_read ), (namcos12_state *) owner ) )
MCFG_PSX_DMA_CHANNEL_READ( "maincpu", 5, psx_dma_read_delegate(&namcos12_state::namcos12_rom_read, (namcos12_state *) owner ))
MCFG_CPU_ADD("sub", H83002, 16934400) // frequency based on research (superctr)
MCFG_CPU_PROGRAM_MAP(s12h8rwmap)
@ -1700,7 +1700,7 @@ static MACHINE_CONFIG_START( coh700, namcos12_state )
/* video hardware */
MCFG_PSXGPU_ADD( "maincpu", "gpu", CXD8654Q, 0x200000, XTAL_53_693175MHz )
MCFG_PSXGPU_VBLANK_CALLBACK( vblank_state_delegate( FUNC( namcos12_state::namcos12_sub_irq ), (namcos12_state *) owner ) )
MCFG_PSXGPU_VBLANK_CALLBACK(vblank_state_delegate(&namcos12_state::namcos12_sub_irq, (namcos12_state *) owner ) )
/* sound hardware */
MCFG_SPEAKER_STANDARD_STEREO("lspeaker", "rspeaker")

8
src/mame/drivers/namcos23.cpp
View File

@ -2284,13 +2284,13 @@ void namcos23_renderer::render_flush(bitmap_rgb32& bitmap)
// We should probably split the polygons into triangles ourselves to insure everything is being rendered properly
if (p->vertex_count == 3)
render_triangle(scissor, render_delegate(FUNC(namcos23_renderer::render_scanline), this), 4, p->pv[0], p->pv[1], p->pv[2]);
render_triangle(scissor, render_delegate(&namcos23_renderer::render_scanline, this), 4, p->pv[0], p->pv[1], p->pv[2]);
else if (p->vertex_count == 4)
render_polygon<4>(scissor, render_delegate(FUNC(namcos23_renderer::render_scanline), this), 4, p->pv);
render_polygon<4>(scissor, render_delegate(&namcos23_renderer::render_scanline, this), 4, p->pv);
else if (p->vertex_count == 5)
render_polygon<5>(scissor, render_delegate(FUNC(namcos23_renderer::render_scanline), this), 4, p->pv);
render_polygon<5>(scissor, render_delegate(&namcos23_renderer::render_scanline, this), 4, p->pv);
else if (p->vertex_count == 6)
render_polygon<6>(scissor, render_delegate(FUNC(namcos23_renderer::render_scanline), this), 4, p->pv);
render_polygon<6>(scissor, render_delegate(&namcos23_renderer::render_scanline, this), 4, p->pv);
}
render.poly_count = 0;
}

2
src/mame/drivers/osi.cpp
View File

@ -690,7 +690,7 @@ void c1pmf_state::machine_start()
// drive select logic missing
if (m_floppy0->get_device())
m_floppy0->get_device()->setup_index_pulse_cb(floppy_image_device::index_pulse_cb(FUNC(sb2m600_state::floppy_index_callback), this));
m_floppy0->get_device()->setup_index_pulse_cb(floppy_image_device::index_pulse_cb(&sb2m600_state::floppy_index_callback, this));
}
// disk format: 1 head, 36 tracks (? - manual displays a directory listing with 40 tracks),

4
src/mame/drivers/pc88va.cpp
View File

@ -1646,11 +1646,11 @@ void pc88va_state::machine_start()
floppy_image_device *floppy;
floppy = machine().device<floppy_connector>("upd765:0")->get_device();
if(floppy)
floppy->setup_ready_cb(floppy_image_device::ready_cb(FUNC(pc88va_state::pc88va_fdc_update_ready), this));
floppy->setup_ready_cb(floppy_image_device::ready_cb(&pc88va_state::pc88va_fdc_update_ready, this));
floppy = machine().device<floppy_connector>("upd765:1")->get_device();
if(floppy)
floppy->setup_ready_cb(floppy_image_device::ready_cb(FUNC(pc88va_state::pc88va_fdc_update_ready), this));
floppy->setup_ready_cb(floppy_image_device::ready_cb(&pc88va_state::pc88va_fdc_update_ready, this));
machine().device<floppy_connector>("upd765:0")->get_device()->set_rpm(300);
machine().device<floppy_connector>("upd765:1")->get_device()->set_rpm(300);

2
src/mame/drivers/pdp1.cpp
View File

@ -647,7 +647,7 @@ void pdp1_state::machine_start()
dst = memregion("gfx1")->base();
memcpy(dst, fontdata6x8, pdp1_fontdata_size);
machine().add_notifier(MACHINE_NOTIFY_EXIT, machine_notify_delegate(FUNC(pdp1_state::pdp1_machine_stop),this));
machine().add_notifier(MACHINE_NOTIFY_EXIT, machine_notify_delegate(&pdp1_state::pdp1_machine_stop,this));
m_tape_reader.timer = machine().scheduler().timer_alloc(timer_expired_delegate(FUNC(pdp1_state::reader_callback),this));
m_tape_puncher.timer = machine().scheduler().timer_alloc(timer_expired_delegate(FUNC(pdp1_state::puncher_callback),this));

2
src/mame/drivers/pentagon.cpp
View File

@ -212,7 +212,7 @@ MACHINE_RESET_MEMBER(pentagon_state,pentagon)
if (strcmp(machine().system().name, "pent1024")==0)
m_beta->enable();
}
space.set_direct_update_handler(direct_update_delegate(FUNC(pentagon_state::pentagon_direct), this));
space.set_direct_update_handler(direct_update_delegate(&pentagon_state::pentagon_direct, this));
memset(messram,0,128*1024);

8
src/mame/drivers/peoplepc.cpp
View File

@ -180,10 +180,10 @@ void peoplepc_state::machine_start()
m_dma0pg = 0;
// FIXME: cheat as there no docs about how or obvious ports that set to control the motor
m_flop0->get_device()->setup_load_cb(floppy_image_device::load_cb(FUNC(peoplepc_state::floppy_load), this));
m_flop0->get_device()->setup_unload_cb(floppy_image_device::unload_cb(FUNC(peoplepc_state::floppy_unload), this));
m_flop1->get_device()->setup_load_cb(floppy_image_device::load_cb(FUNC(peoplepc_state::floppy_load), this));
m_flop1->get_device()->setup_unload_cb(floppy_image_device::unload_cb(FUNC(peoplepc_state::floppy_unload), this));
m_flop0->get_device()->setup_load_cb(floppy_image_device::load_cb(&peoplepc_state::floppy_load, this));
m_flop0->get_device()->setup_unload_cb(floppy_image_device::unload_cb(&peoplepc_state::floppy_unload, this));
m_flop1->get_device()->setup_load_cb(floppy_image_device::load_cb(&peoplepc_state::floppy_load, this));
m_flop1->get_device()->setup_unload_cb(floppy_image_device::unload_cb(&peoplepc_state::floppy_unload, this));
}
static ADDRESS_MAP_START( peoplepc_map, AS_PROGRAM, 16, peoplepc_state )

8
src/mame/drivers/psx.cpp
View File

@ -124,8 +124,8 @@ static MACHINE_CONFIG_START( psj, psx1_state )
MCFG_PSXCD_ADD(PSXCD_TAG, "cdrom")
MCFG_PSXCD_IRQ_HANDLER(DEVWRITELINE("maincpu:irq", psxirq_device, intin2))
MCFG_PSX_DMA_CHANNEL_READ( "maincpu", 3, psx_dma_read_delegate( FUNC( psx1_state::cd_dma_read ), (psx1_state *) owner ) )
MCFG_PSX_DMA_CHANNEL_WRITE( "maincpu", 3, psx_dma_write_delegate( FUNC( psx1_state::cd_dma_write ), (psx1_state *) owner ) )
MCFG_PSX_DMA_CHANNEL_READ( "maincpu", 3, psx_dma_read_delegate(&psx1_state::cd_dma_read, (psx1_state *) owner ) )
MCFG_PSX_DMA_CHANNEL_WRITE( "maincpu", 3, psx_dma_write_delegate(&psx1_state::cd_dma_write, (psx1_state *) owner ) )
MACHINE_CONFIG_END
static MACHINE_CONFIG_DERIVED( psu, psj )
@ -170,8 +170,8 @@ static MACHINE_CONFIG_START( pse, psx1_state )
MCFG_PSXCD_ADD(PSXCD_TAG, "cdrom")
MCFG_PSXCD_IRQ_HANDLER(DEVWRITELINE("maincpu:irq", psxirq_device, intin2))
MCFG_PSX_DMA_CHANNEL_READ( "maincpu", 3, psx_dma_read_delegate( FUNC( psx1_state::cd_dma_read ), (psx1_state *) owner ) )
MCFG_PSX_DMA_CHANNEL_WRITE( "maincpu", 3, psx_dma_write_delegate( FUNC( psx1_state::cd_dma_write ), (psx1_state *) owner ) )
MCFG_PSX_DMA_CHANNEL_READ( "maincpu", 3, psx_dma_read_delegate(&psx1_state::cd_dma_read, (psx1_state *) owner ) )
MCFG_PSX_DMA_CHANNEL_WRITE( "maincpu", 3, psx_dma_write_delegate(&psx1_state::cd_dma_write, (psx1_state *) owner ) )
MACHINE_CONFIG_END
ROM_START( psj )

2
src/mame/drivers/rollext.cpp
View File

@ -153,7 +153,7 @@ void rollext_renderer::process_display_list(uint32_t* disp_ram)
{
const rectangle& visarea = screen().visible_area();
render_delegate rd = render_delegate(FUNC(rollext_renderer::render_texture_scan), this);
render_delegate rd = render_delegate(&rollext_renderer::render_texture_scan, this);
int num = disp_ram[0xffffc/4];

2
src/mame/drivers/sage2.cpp
View File

@ -557,7 +557,7 @@ DIRECT_UPDATE_MEMBER(sage2_state::sage2_direct_update_handler)
DRIVER_INIT_MEMBER(sage2_state,sage2)
{
address_space &program = machine().device<cpu_device>(M68000_TAG)->space(AS_PROGRAM);
program.set_direct_update_handler(direct_update_delegate(FUNC(sage2_state::sage2_direct_update_handler), this));
program.set_direct_update_handler(direct_update_delegate(&sage2_state::sage2_direct_update_handler, this));
}

2
src/mame/drivers/saturn.cpp
View File

@ -727,7 +727,7 @@ MACHINE_START_MEMBER(sat_console_state, saturn)
save_item(NAME(m_smpc.SR));
save_item(NAME(m_smpc.SMEM));
machine().add_notifier(MACHINE_NOTIFY_EXIT, machine_notify_delegate(FUNC(sat_console_state::stvcd_exit), this));
machine().add_notifier(MACHINE_NOTIFY_EXIT, machine_notify_delegate(&sat_console_state::stvcd_exit, this));
m_smpc.rtc_data[0] = DectoBCD(systime.local_time.year /100);
m_smpc.rtc_data[1] = DectoBCD(systime.local_time.year %100);

2
src/mame/drivers/scorpion.cpp
View File

@ -196,7 +196,7 @@ MACHINE_RESET_MEMBER(scorpion_state,scorpion)
space.install_write_handler(0x0000, 0x3fff, write8_delegate(FUNC(scorpion_state::scorpion_0000_w),this));
m_beta->disable();
space.set_direct_update_handler(direct_update_delegate(FUNC(scorpion_state::scorpion_direct), this));
space.set_direct_update_handler(direct_update_delegate(&scorpion_state::scorpion_direct, this));
memset(messram,0,256*1024);

2
src/mame/drivers/segahang.cpp
View File

@ -1965,7 +1965,7 @@ DRIVER_INIT_MEMBER(segahang_state,sharrier)
{
DRIVER_INIT_CALL(generic);
m_sharrier_video = true;
m_i8751_vblank_hook = i8751_sim_delegate(FUNC(segahang_state::sharrier_i8751_sim), this);
m_i8751_vblank_hook = i8751_sim_delegate(&segahang_state::sharrier_i8751_sim, this);
}
DRIVER_INIT_MEMBER(segahang_state,enduror)

6
src/mame/drivers/segas16a.cpp
View File

@ -3665,7 +3665,7 @@ DRIVER_INIT_MEMBER(segas16a_state,aceattaca)
DRIVER_INIT_MEMBER(segas16a_state,dumpmtmt)
{
DRIVER_INIT_CALL(generic);
m_i8751_vblank_hook = i8751_sim_delegate(FUNC(segas16a_state::dumpmtmt_i8751_sim), this);
m_i8751_vblank_hook = i8751_sim_delegate(&segas16a_state::dumpmtmt_i8751_sim, this);
}
DRIVER_INIT_MEMBER(segas16a_state,mjleague)
@ -3683,7 +3683,7 @@ DRIVER_INIT_MEMBER(segas16a_state,passsht16a)
DRIVER_INIT_MEMBER(segas16a_state,quartet)
{
DRIVER_INIT_CALL(generic);
m_i8751_vblank_hook = i8751_sim_delegate(FUNC(segas16a_state::quartet_i8751_sim), this);
m_i8751_vblank_hook = i8751_sim_delegate(&segas16a_state::quartet_i8751_sim, this);
}
@ -3697,7 +3697,7 @@ DRIVER_INIT_MEMBER(segas16a_state,sjryukoa)
{
DRIVER_INIT_CALL(generic);
m_custom_io_r = read16_delegate(FUNC(segas16a_state::sjryuko_custom_io_r), this);
m_lamp_changed_w = lamp_changed_delegate(FUNC(segas16a_state::sjryuko_lamp_changed_w), this);
m_lamp_changed_w = lamp_changed_delegate(&segas16a_state::sjryuko_lamp_changed_w, this);
}

Some files were not shown because too many files have changed in this diff Show More