Previous

199869 Revisions

Next

r18154 Wednesday 26th September, 2012 at 10:07:49 UTC by Aaron Giles
Moved device_delegates into their own files. Employed a non-templatized helper class so that the code can live co-located, rather than invading device.h. Changed the read/write delegates to derive from device_delegate. Updated the address map macros to create these properly. Removed remnants of the old AM_BASE/SIZE macros from the memory system.

[src/emu]

addrmap.c addrmap.h delegate.h devcb.h devdelegate.c* devdelegate.h* device.h dimemory.c emu.h emu.mak emucore.c emucore.h memory.c memory.h

trunk/src/emu/device.h

r18153	r18154
992	992	return (tag[0] == ':') ? subdevice(tag) : NULL;
993	993	}
994	994
995
996		//-------------------------------------------------
997		//  bind_relative_to - perform a late binding of
998		//  a device_delegate
999		//-------------------------------------------------
1000
1001		template<typename _Signature>
1002		void device_delegate<_Signature>::bind_relative_to(device_t &search_root)
1003		{
1004		if (!basetype::isnull())
1005		{
1006		device_t *device = search_root.subdevice(m_device_name);
1007		if (device == NULL)
1008		throw emu_fatalerror("Unable to locate device '%s' relative to '%s'\n", m_device_name, search_root.tag());
1009		basetype::late_bind(*device);
1010		}
1011		}
1012
1013	995	#endif   /* __DEVINTRF_H__ */

trunk/src/emu/memory.c

r18153	r18154
1828	1828	}
1829	1829
1830	1830	// validate adjusted addresses against implicit regions
1831		if (entry->m_region != NULL && entry->m_share == NULL && entry->m_baseptr == NULL)
	1831	if (entry->m_region != NULL && entry->m_share == NULL)
1832	1832	{
1833	1833	// determine full tag
1834	1834	astring fulltag;
r18153	r18154
1903	1903	void address_space::populate_map_entry(const address_map_entry &entry, read_or_write readorwrite)
1904	1904	{
1905	1905	const map_handler_data &data = (readorwrite == ROW_READ) ? entry.m_read : entry.m_write;
1906		device_t *target_device;
1907	1906	astring fulltag;
1908	1907
1909	1908	// based on the handler type, alter the bits, name, funcptr, and object
r18153	r18154
1931	1930	break;
1932	1931
1933	1932	case AMH_DEVICE_DELEGATE:
1934		target_device = device().siblingdevice(data.m_tag);
1935		if (target_device == NULL)
1936		throw emu_fatalerror("Attempted to map a non-existent device '%s' in space %s of device '%s'\n", data.m_tag.cstr(), m_name, m_device.tag());
1937
1938	1933	if (readorwrite == ROW_READ)
1939	1934	switch (data.m_bits)
1940	1935	{
1941		case 8:      install_read_handler(entry.m_addrstart, entry.m_addrend, entry.m_addrmask, entry.m_addrmirror, read8_delegate(entry.m_rproto8, *target_device), data.m_mask);      break;
1942		case 16:   install_read_handler(entry.m_addrstart, entry.m_addrend, entry.m_addrmask, entry.m_addrmirror, read16_delegate(entry.m_rproto16, *target_device), data.m_mask);      break;
1943		case 32:   install_read_handler(entry.m_addrstart, entry.m_addrend, entry.m_addrmask, entry.m_addrmirror, read32_delegate(entry.m_rproto32, *target_device), data.m_mask);      break;
1944		case 64:   install_read_handler(entry.m_addrstart, entry.m_addrend, entry.m_addrmask, entry.m_addrmirror, read64_delegate(entry.m_rproto64, *target_device), data.m_mask);      break;
	1936	case 8:      install_read_handler(entry.m_addrstart, entry.m_addrend, entry.m_addrmask, entry.m_addrmirror, read8_delegate(entry.m_rproto8, *entry.m_read.m_devbase), data.m_mask); break;
	1937	case 16:   install_read_handler(entry.m_addrstart, entry.m_addrend, entry.m_addrmask, entry.m_addrmirror, read16_delegate(entry.m_rproto16, *entry.m_read.m_devbase), data.m_mask); break;
	1938	case 32:   install_read_handler(entry.m_addrstart, entry.m_addrend, entry.m_addrmask, entry.m_addrmirror, read32_delegate(entry.m_rproto32, *entry.m_read.m_devbase), data.m_mask); break;
	1939	case 64:   install_read_handler(entry.m_addrstart, entry.m_addrend, entry.m_addrmask, entry.m_addrmirror, read64_delegate(entry.m_rproto64, *entry.m_read.m_devbase), data.m_mask); break;
1945	1940	}
1946	1941	else
1947	1942	switch (data.m_bits)
1948	1943	{
1949		case 8:      install_write_handler(entry.m_addrstart, entry.m_addrend, entry.m_addrmask, entry.m_addrmirror, write8_delegate(entry.m_wproto8, *target_device), data.m_mask);      break;
1950		case 16:   install_write_handler(entry.m_addrstart, entry.m_addrend, entry.m_addrmask, entry.m_addrmirror, write16_delegate(entry.m_wproto16, *target_device), data.m_mask);   break;
1951		case 32:   install_write_handler(entry.m_addrstart, entry.m_addrend, entry.m_addrmask, entry.m_addrmirror, write32_delegate(entry.m_wproto32, *target_device), data.m_mask);   break;
1952		case 64:   install_write_handler(entry.m_addrstart, entry.m_addrend, entry.m_addrmask, entry.m_addrmirror, write64_delegate(entry.m_wproto64, *target_device), data.m_mask);   break;
	1944	case 8:      install_write_handler(entry.m_addrstart, entry.m_addrend, entry.m_addrmask, entry.m_addrmirror, write8_delegate(entry.m_wproto8, *entry.m_write.m_devbase), data.m_mask); break;
	1945	case 16:   install_write_handler(entry.m_addrstart, entry.m_addrend, entry.m_addrmask, entry.m_addrmirror, write16_delegate(entry.m_wproto16, *entry.m_write.m_devbase), data.m_mask); break;
	1946	case 32:   install_write_handler(entry.m_addrstart, entry.m_addrend, entry.m_addrmask, entry.m_addrmirror, write32_delegate(entry.m_wproto32, *entry.m_write.m_devbase), data.m_mask); break;
	1947	case 64:   install_write_handler(entry.m_addrstart, entry.m_addrend, entry.m_addrmask, entry.m_addrmirror, write64_delegate(entry.m_wproto64, *entry.m_write.m_devbase), data.m_mask); break;
1953	1948	}
1954	1949	break;
1955	1950
r18153	r18154
1974	1969
1975	1970	case AMH_PORT:
1976	1971	install_readwrite_port(entry.m_addrstart, entry.m_addrend, entry.m_addrmask, entry.m_addrmirror,
1977		(readorwrite == ROW_READ) ? data.m_tag.cstr() : NULL,
1978		(readorwrite == ROW_WRITE) ? data.m_tag.cstr() : NULL);
	1972	(readorwrite == ROW_READ) ? data.m_tag : NULL,
	1973	(readorwrite == ROW_WRITE) ? data.m_tag : NULL);
1979	1974	break;
1980	1975
1981	1976	case AMH_BANK:
1982	1977	install_bank_generic(entry.m_addrstart, entry.m_addrend, entry.m_addrmask, entry.m_addrmirror,
1983		(readorwrite == ROW_READ) ? data.m_tag.cstr() : NULL,
1984		(readorwrite == ROW_WRITE) ? data.m_tag.cstr() : NULL);
	1978	(readorwrite == ROW_READ) ? data.m_tag : NULL,
	1979	(readorwrite == ROW_WRITE) ? data.m_tag : NULL);
1985	1980	break;
1986	1981
1987	1982	case AMH_DEVICE_SUBMAP:
1988		throw emu_fatalerror("Internal mapping error: leftover mapping of '%s'.\n", data.m_tag.cstr());
	1983	throw emu_fatalerror("Internal mapping error: leftover mapping of '%s'.\n", data.m_tag);
1989	1984	}
1990	1985	}
1991	1986
r18153	r18154
2067	2062
2068	2063	void address_space::locate_memory()
2069	2064	{
2070		// fill in base/size entries
2071		for (const address_map_entry *entry = m_map->m_entrylist.first(); entry != NULL; entry = entry->next())
2072		{
2073		if (entry->m_baseptr != NULL)
2074		*entry->m_baseptr = entry->m_memory;
2075		if (entry->m_baseptroffs_plus1 != 0)
2076		*(void **)(reinterpret_cast<UINT8 *>(machine().driver_data()) + entry->m_baseptroffs_plus1 - 1) = entry->m_memory;
2077		if (entry->m_sizeptr != NULL)
2078		*entry->m_sizeptr = entry->m_byteend - entry->m_bytestart + 1;
2079		if (entry->m_sizeptroffs_plus1 != 0)
2080		*(size_t *)(reinterpret_cast<UINT8 *>(machine().driver_data()) + entry->m_sizeptroffs_plus1 - 1) = entry->m_byteend - entry->m_bytestart + 1;
2081		}
2082
2083	2065	// once this is done, find the starting bases for the banks
2084	2066	for (memory_bank *bank = manager().m_banklist.first(); bank != NULL; bank = bank->next())
2085	2067	if (bank->base() == NULL && bank->references_space(*this, ROW_READWRITE))
r18153	r18154
2713	2695
2714	2696	bool address_space::needs_backing_store(const address_map_entry *entry)
2715	2697	{
2716		// if we are asked to provide a base pointer, then yes, we do need backing
2717		if (entry->m_baseptr != NULL || entry->m_baseptroffs_plus1 != 0)
2718		return true;
2719
2720	2698	// if we are sharing, and we don't have a pointer yet, create one
2721	2699	if (entry->m_share != NULL)
2722	2700	{

trunk/src/emu/memory.h

r18153	r18154
105	105	typedef UINT32   offs_t;
106	106
107	107	// address map constructors are functions that build up an address_map
108		typedef void (*address_map_constructor)(address_map &map, const device_t &devconfig);
	108	typedef void (*address_map_constructor)(address_map &map, device_t &devconfig);
109	109
110	110	// submap retriever delegate
111		typedef delegate<void (address_map &, const device_t &)> address_map_delegate;
	111	typedef delegate<void (address_map &, device_t &)> address_map_delegate;
112	112
113	113
114	114	// legacy space read/write handlers
r18153	r18154
162	162	// ======================> read_delegate
163	163
164	164	// declare delegates for each width
165		typedef delegate<UINT8 (address_space &, offs_t, UINT8)> read8_delegate;
166		typedef delegate<UINT16 (address_space &, offs_t, UINT16)> read16_delegate;
167		typedef delegate<UINT32 (address_space &, offs_t, UINT32)> read32_delegate;
168		typedef delegate<UINT64 (address_space &, offs_t, UINT64)> read64_delegate;
	165	typedef device_delegate<UINT8 (address_space &, offs_t, UINT8)> read8_delegate;
	166	typedef device_delegate<UINT16 (address_space &, offs_t, UINT16)> read16_delegate;
	167	typedef device_delegate<UINT32 (address_space &, offs_t, UINT32)> read32_delegate;
	168	typedef device_delegate<UINT64 (address_space &, offs_t, UINT64)> read64_delegate;
169	169
170	170
171	171	// ======================> write_delegate
172	172
173	173	// declare delegates for each width
174		typedef delegate<void (address_space &, offs_t, UINT8, UINT8)> write8_delegate;
175		typedef delegate<void (address_space &, offs_t, UINT16, UINT16)> write16_delegate;
176		typedef delegate<void (address_space &, offs_t, UINT32, UINT32)> write32_delegate;
177		typedef delegate<void (address_space &, offs_t, UINT64, UINT64)> write64_delegate;
	174	typedef device_delegate<void (address_space &, offs_t, UINT8, UINT8)> write8_delegate;
	175	typedef device_delegate<void (address_space &, offs_t, UINT16, UINT16)> write16_delegate;
	176	typedef device_delegate<void (address_space &, offs_t, UINT32, UINT32)> write32_delegate;
	177	typedef device_delegate<void (address_space &, offs_t, UINT64, UINT64)> write64_delegate;
178	178
179	179
180	180	// ======================> direct_read_data

trunk/src/emu/emu.h

r18153	r18154
67	67	#include "hash.h"
68	68	#include "fileio.h" // remove me once NVRAM is implemented as device
69	69	#include "delegate.h"
	70	#include "devdelegate.h"
70	71
71	72	// memory and address spaces
72	73	#include "memory.h"
r18153	r18154
81	82	class machine_config;
82	83	typedef device_t * (*machine_config_constructor)(machine_config &config, device_t *owner);
83	84
84		// device_delegate is a delegate that wraps with a device tag and can be easily
85		// late bound without replicating logic everywhere
86		template<typename _Signature>
87		class device_delegate : public delegate<_Signature>
88		{
89		typedef delegate<_Signature> basetype;
90
91		public:
92		// provide same set of constructors as the base class, with additional device name
93		// parameter
94		device_delegate() : basetype(), m_device_name(NULL) { }
95		device_delegate(const basetype &src) : basetype(src), m_device_name(src.m_device_name) { }
96		device_delegate(const basetype &src, delegate_late_bind &object) : basetype(src, object), m_device_name(src.m_device_name) { }
97		template<class _FunctionClass> device_delegate(typename basetype::template traits<_FunctionClass>::member_func_type funcptr, const char *name, const char *devname) : basetype(funcptr, name, (_FunctionClass *)0), m_device_name(devname) { }
98		template<class _FunctionClass> device_delegate(typename basetype::template traits<_FunctionClass>::member_func_type funcptr, const char *name, const char *devname, _FunctionClass *object) : basetype(funcptr, name, (_FunctionClass *)0), m_device_name(devname) { }
99		template<class _FunctionClass> device_delegate(typename basetype::template traits<_FunctionClass>::static_func_type funcptr, const char *name, const char *devname, _FunctionClass *object) : basetype(funcptr, name, (_FunctionClass *)0), m_device_name(devname) { }
100		template<class _FunctionClass> device_delegate(typename basetype::template traits<_FunctionClass>::static_ref_func_type funcptr, const char *name, const char *devname, _FunctionClass *object) : basetype(funcptr, name, (_FunctionClass *)0), m_device_name(devname) { }
101		device_delegate(typename basetype::template traits<device_t>::static_func_type funcptr, const char *name) : basetype(funcptr, name, (device_t *)0), m_device_name(NULL) { }
102		device_delegate(typename basetype::template traits<device_t>::static_ref_func_type funcptr, const char *name) : basetype(funcptr, name, (device_t *)0), m_device_name(NULL) { }
103		device_delegate &operator=(const basetype &src) { *static_cast<basetype *>(this) = src; m_device_name = src.m_device_name; return *this; }
104
105		// perform the binding
106		void bind_relative_to(device_t &search_root);
107
108		private:
109		// internal state
110		const char *m_device_name;
111		};
112
113	85	// I/O
114	86	#include "input.h"
115	87	#include "ioport.h"

trunk/src/emu/delegate.h

r18153	r18154
448	448	template<class _FunctionClass>
449	449	static delegate_generic_class *late_bind_helper(delegate_late_bind &object)
450	450	{
451		return reinterpret_cast<delegate_generic_class *>(dynamic_cast<_FunctionClass *>(&object));
	451	_FunctionClass *result = dynamic_cast<_FunctionClass *>(&object);
	452	return reinterpret_cast<delegate_generic_class *>(result);
452	453	}
453	454
454	455	// internal state
r18153	r18154
636	637	template<class _FunctionClass>
637	638	static delegate_generic_class *late_bind_helper(delegate_late_bind &object)
638	639	{
639		return reinterpret_cast<delegate_generic_class *>(dynamic_cast<_FunctionClass *>(&object));
	640	_FunctionClass *result = dynamic_cast<_FunctionClass *>(&object);
	641	return reinterpret_cast<delegate_generic_class *>(result);
640	642	}
641	643
642	644	// internal state
r18153	r18154
761	763	delegate &operator=(const basetype &src) { *static_cast<basetype *>(this) = src; return *this; }
762	764	};
763	765
764		// Some useful delegates
765
766		typedef delegate<void (bool state)> line_cb_t;
767
768	766	#endif   /* __DELEGATE_H__ */

trunk/src/emu/dimemory.c

r18153	r18154
241	241	int alignunit = datawidth / 8;
242	242
243	243	// construct the maps
244		::address_map *map = global_alloc(::address_map(device(), spacenum));
	244	::address_map *map = global_alloc(::address_map(const_cast<device_t &>(device()), spacenum));
245	245
246	246	// if this is an empty map, just skip it
247	247	if (map->m_entrylist.first() == NULL)
r18153	r18154
323	323	}
324	324
325	325	// make sure all devices exist
326		if (entry->m_read.m_type == AMH_DEVICE_DELEGATE && entry->m_read.m_tag && device().siblingdevice(entry->m_read.m_tag) == NULL)
327		mame_printf_error("%s space memory map entry references nonexistant device '%s'\n", spaceconfig->m_name, entry->m_read.m_tag.cstr());
328		if (entry->m_write.m_type == AMH_DEVICE_DELEGATE && entry->m_write.m_tag && device().siblingdevice(entry->m_write.m_tag) == NULL)
329		mame_printf_error("%s space memory map entry references nonexistant device '%s'\n", spaceconfig->m_name, entry->m_write.m_tag.cstr());
	326	if (entry->m_read.m_type == AMH_DEVICE_DELEGATE && entry->m_read.m_tag != NULL)
	327	{
	328	astring temp(entry->m_read.m_tag);
	329	if (device().siblingdevice(temp) == NULL)
	330	mame_printf_error("%s space memory map entry references nonexistant device '%s'\n", spaceconfig->m_name, entry->m_read.m_tag);
	331	}
	332	if (entry->m_write.m_type == AMH_DEVICE_DELEGATE && entry->m_write.m_tag != NULL)
	333	{
	334	astring temp(entry->m_write.m_tag);
	335	if (device().siblingdevice(temp) == NULL)
	336	mame_printf_error("%s space memory map entry references nonexistant device '%s'\n", spaceconfig->m_name, entry->m_write.m_tag);
	337	}
330	338
331	339	// make sure ports exist
332	340	//              if ((entry->m_read.m_type == AMH_PORT && entry->m_read.m_tag != NULL && portlist.find(entry->m_read.m_tag) == NULL) ||
333	341	//                  (entry->m_write.m_type == AMH_PORT && entry->m_write.m_tag != NULL && portlist.find(entry->m_write.m_tag) == NULL))
334		//                  mame_printf_error("%s space memory map entry references nonexistant port tag '%s'\n", spaceconfig->m_name, entry->m_read.m_tag.cstr());
	342	//                  mame_printf_error("%s space memory map entry references nonexistant port tag '%s'\n", spaceconfig->m_name, entry->m_read.m_tag);
335	343
336	344	// validate bank and share tags
337	345	if (entry->m_read.m_type == AMH_BANK)

trunk/src/emu/devdelegate.c

r0	r18154
	1	/***************************************************************************
	2
	3	devdelegate.c
	4
	5	Delegates that are late-bound to MAME devices.
	6
	7	****************************************************************************
	8
	9	Copyright Aaron Giles
	10	All rights reserved.
	11
	12	Redistribution and use in source and binary forms, with or without
	13	modification, are permitted provided that the following conditions are
	14	met:
	15
	16	* Redistributions of source code must retain the above copyright
	17	notice, this list of conditions and the following disclaimer.
	18	* Redistributions in binary form must reproduce the above copyright
	19	notice, this list of conditions and the following disclaimer in
	20	the documentation and/or other materials provided with the
	21	distribution.
	22	* Neither the name 'MAME' nor the names of its contributors may be
	23	used to endorse or promote products derived from this software
	24	without specific prior written permission.
	25
	26	THIS SOFTWARE IS PROVIDED BY AARON GILES ''AS IS'' AND ANY EXPRESS OR
	27	IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED
	28	WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE
	29	DISCLAIMED. IN NO EVENT SHALL AARON GILES BE LIABLE FOR ANY DIRECT,
	30	INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES
	31	(INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR
	32	SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION)
	33	HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT,
	34	STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING
	35	IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE
	36	POSSIBILITY OF SUCH DAMAGE.
	37
	38	***************************************************************************/
	39
	40	#include "emu.h"
	41
	42
	43	//-------------------------------------------------
	44	//  bound_object - use the device name to locate
	45	//   a device relative to the given search root;
	46	//   fatal error if not found
	47	//-------------------------------------------------
	48
	49	delegate_late_bind &device_delegate_helper::bound_object(device_t &search_root)
	50	{
	51	device_t *device = search_root.subdevice(m_device_name);
	52	if (device == NULL)
	53	throw emu_fatalerror("Unable to locate device '%s' relative to '%s'\n", m_device_name, search_root.tag());
	54	return *device;
	55	}
	56
	57
	58	//-------------------------------------------------
	59	//  safe_tag - return a tag string or (unknown) if
	60	//   the object is not valid
	61	//-------------------------------------------------
	62
	63	const char *device_delegate_helper::safe_tag(device_t *object)
	64	{
	65	return (object != NULL) ? object->tag() : "(unknown)";
	66	}

trunk/src/emu/devdelegate.h

r0	r18154
	1	/***************************************************************************
	2
	3	devdelegate.h
	4
	5	Delegates that are late-bound to MAME devices.
	6
	7	****************************************************************************
	8
	9	Copyright Aaron Giles
	10	All rights reserved.
	11
	12	Redistribution and use in source and binary forms, with or without
	13	modification, are permitted provided that the following conditions are
	14	met:
	15
	16	* Redistributions of source code must retain the above copyright
	17	notice, this list of conditions and the following disclaimer.
	18	* Redistributions in binary form must reproduce the above copyright
	19	notice, this list of conditions and the following disclaimer in
	20	the documentation and/or other materials provided with the
	21	distribution.
	22	* Neither the name 'MAME' nor the names of its contributors may be
	23	used to endorse or promote products derived from this software
	24	without specific prior written permission.
	25
	26	THIS SOFTWARE IS PROVIDED BY AARON GILES ''AS IS'' AND ANY EXPRESS OR
	27	IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED
	28	WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE
	29	DISCLAIMED. IN NO EVENT SHALL AARON GILES BE LIABLE FOR ANY DIRECT,
	30	INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES
	31	(INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR
	32	SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION)
	33	HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT,
	34	STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING
	35	IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE
	36	POSSIBILITY OF SUCH DAMAGE.
	37
	38	***************************************************************************/
	39
	40	#pragma once
	41
	42	#ifndef __DEVDELEGATE_H__
	43	#define __DEVDELEGATE_H__
	44
	45	#include "delegate.h"
	46
	47
	48	//**************************************************************************
	49	//  TYPE DEFINITIONS
	50	//**************************************************************************
	51
	52	// ======================> device_delegate_helper
	53
	54	// device_delegate_helper does non-template work
	55	class device_delegate_helper
	56	{
	57	protected:
	58	// constructor
	59	device_delegate_helper(const char *devname) : m_device_name(devname) { }
	60
	61	// internal helpers
	62	delegate_late_bind &bound_object(device_t &search_root);
	63	static const char *safe_tag(device_t *object);
	64
	65	// internal state
	66	const char *m_device_name;
	67	};
	68
	69
	70	// ======================> device_delegate
	71
	72	// device_delegate is a delegate that wraps with a device tag and can be easily
	73	// late bound without replicating logic everywhere
	74	template<typename _Signature>
	75	class device_delegate : public delegate<_Signature>, device_delegate_helper
	76	{
	77	typedef device_delegate<_Signature> thistype;
	78	typedef delegate<_Signature> basetype;
	79
	80	public:
	81	// provide the same constructors as the base class
	82	device_delegate() : basetype(), device_delegate_helper(NULL) { }
	83	device_delegate(const basetype &src) : basetype(src), device_delegate_helper(src.m_device_name) { }
	84	device_delegate(const basetype &src, delegate_late_bind &object) : basetype(src, object), device_delegate_helper(src.m_device_name) { }
	85	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))) { }
	86	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))) { }
	87	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))) { }
	88	device_delegate &operator=(const thistype &src) { *static_cast<basetype *>(this) = src; m_device_name = src.m_device_name; return *this; }
	89
	90	// provide additional constructors that take a device name string
	91	template<class _FunctionClass> device_delegate(typename basetype::template traits<_FunctionClass>::member_func_type funcptr, const char *name, const char *devname) : basetype(funcptr, name, (_FunctionClass *)0), device_delegate_helper(devname) { }
	92	template<class _FunctionClass> device_delegate(typename basetype::template traits<_FunctionClass>::member_func_type funcptr, const char *name, const char *devname, _FunctionClass *object) : basetype(funcptr, name, (_FunctionClass *)0), device_delegate_helper(devname) { }
	93	template<class _FunctionClass> device_delegate(typename basetype::template traits<_FunctionClass>::static_func_type funcptr, const char *name, const char *devname, _FunctionClass *object) : basetype(funcptr, name, (_FunctionClass *)0), device_delegate_helper(devname) { }
	94	template<class _FunctionClass> device_delegate(typename basetype::template traits<_FunctionClass>::static_ref_func_type funcptr, const char *name, const char *devname, _FunctionClass *object) : basetype(funcptr, name, (_FunctionClass *)0), device_delegate_helper(devname) { }
	95	device_delegate(typename basetype::template traits<device_t>::static_func_type funcptr, const char *name) : basetype(funcptr, name, (device_t *)0), device_delegate_helper(NULL) { }
	96	device_delegate(typename basetype::template traits<device_t>::static_ref_func_type funcptr, const char *name) : basetype(funcptr, name, (device_t *)0), device_delegate_helper(NULL) { }
	97
	98	// and constructors that provide a search root
	99	device_delegate(const thistype &src, device_t &search_root) : basetype(src), device_delegate_helper(src.m_device_name) { bind_relative_to(search_root); }
	100
	101	// perform the binding
	102	void bind_relative_to(device_t &search_root) { if (!basetype::isnull()) basetype::late_bind(bound_object(search_root)); }
	103	};
	104
	105
	106	#endif   /* __DEVDELEGATE_H__ */

trunk/src/emu/emu.mak

r18153	r18154
54	54	$(EMUOBJ)/crsshair.o \
55	55	$(EMUOBJ)/debugger.o \
56	56	$(EMUOBJ)/delegate.o \
	57	$(EMUOBJ)/devdelegate.o \
57	58	$(EMUOBJ)/devcb.o \
58	59	$(EMUOBJ)/devcpu.o \
59	60	$(EMUOBJ)/device.o \

trunk/src/emu/emucore.c

r18153	r18154
18	18	src_type.name(), dst_type.name());
19	19	}
20	20
21		void report_bad_device_cast(const device_t *dev, const std::type_info &dst_type)
	21	void report_bad_device_cast(const device_t *dev, const std::type_info &src_type, const std::type_info &dst_type)
22	22	{
23	23	throw emu_fatalerror("Error: bad downcast<> or device<>.  Tried to convert the device %s of type %s to a %s, which are incompatible.\n",
24		dev->tag(), dev->name(), dst_type.name());
	24	dev->tag(), src_type.name(), dst_type.name());
25	25	}

trunk/src/emu/emucore.h

r18153	r18154
335	335	class device_t;
336	336
337	337	void report_bad_cast(const std::type_info &src_type, const std::type_info &dst_type);
338		void report_bad_device_cast(const device_t *dev, const std::type_info &dst_type);
	338	void report_bad_device_cast(const device_t *dev, const std::type_info &src_type, const std::type_info &dst_type);
339	339
340	340	// template function for casting from a base class to a derived class that is checked
341	341	// in debug builds and fast in release builds
r18153	r18154
346	346	if (dynamic_cast<_Dest>(src) != src)
347	347	{
348	348	if (dynamic_cast<const device_t *>(src) != NULL)
349		report_bad_device_cast(dynamic_cast<const device_t *>(src), typeid(_Dest));
	349	report_bad_device_cast(dynamic_cast<const device_t *>(src), typeid(src), typeid(_Dest));
350	350	else
351	351	report_bad_cast(typeid(src), typeid(_Dest));
352	352	}
r18153	r18154
361	361	if (&dynamic_cast<_Dest>(src) != &src)
362	362	{
363	363	if (dynamic_cast<const device_t *>(&src) != NULL)
364		report_bad_device_cast(dynamic_cast<const device_t *>(&src), typeid(_Dest));
	364	report_bad_device_cast(dynamic_cast<const device_t *>(&src), typeid(src), typeid(_Dest));
365	365	else
366	366	report_bad_cast(typeid(src), typeid(_Dest));
367	367	}

trunk/src/emu/addrmap.c

r18153	r18154
56	56	m_addrmirror(0),
57	57	m_addrmask(0),
58	58	m_share(NULL),
59		m_baseptr(NULL),
60		m_sizeptr(NULL),
61		m_baseptroffs_plus1(0),
62		m_sizeptroffs_plus1(0),
63	59	m_region(NULL),
64	60	m_rgnoffs(0),
65	61	m_rspace8(NULL),
r18153	r18154
96	92	//  an I/O port
97	93	//-------------------------------------------------
98	94
99		void address_map_entry::set_read_port(const device_t &device, const char *tag)
	95	void address_map_entry::set_read_port(device_t &device, const char *tag)
100	96	{
101	97	m_read.m_type = AMH_PORT;
102		device.subtag(m_read.m_tag, tag);
	98	m_read.m_tag = tag;
	99	m_read.m_devbase = &device;
103	100	}
104	101
105	102
r18153	r18154
108	105	//  an I/O port
109	106	//-------------------------------------------------
110	107
111		void address_map_entry::set_write_port(const device_t &device, const char *tag)
	108	void address_map_entry::set_write_port(device_t &device, const char *tag)
112	109	{
113	110	m_write.m_type = AMH_PORT;
114		device.subtag(m_write.m_tag, tag);
	111	m_write.m_tag = tag;
	112	m_write.m_devbase = &device;
115	113	}
116	114
117	115
r18153	r18154
120	118	//  reading and writing an I/O port
121	119	//-------------------------------------------------
122	120
123		void address_map_entry::set_readwrite_port(const device_t &device, const char *tag)
	121	void address_map_entry::set_readwrite_port(device_t &device, const char *tag)
124	122	{
125	123	m_read.m_type = AMH_PORT;
126		device.subtag(m_read.m_tag, tag);
	124	m_read.m_tag = tag;
	125	m_read.m_devbase = &device;
127	126	m_write.m_type = AMH_PORT;
128		device.subtag(m_write.m_tag, tag);
	127	m_write.m_tag = tag;
	128	m_write.m_devbase = &device;
129	129	}
130	130
131	131
r18153	r18154
134	134	//  from a memory bank
135	135	//-------------------------------------------------
136	136
137		void address_map_entry::set_read_bank(const device_t &device, const char *tag)
	137	void address_map_entry::set_read_bank(device_t &device, const char *tag)
138	138	{
139	139	m_read.m_type = AMH_BANK;
140		device.subtag(m_read.m_tag, tag);
	140	m_read.m_tag = tag;
	141	m_read.m_devbase = &device;
141	142	}
142	143
143	144
r18153	r18154
146	147	//  to a memory bank
147	148	//-------------------------------------------------
148	149
149		void address_map_entry::set_write_bank(const device_t &device, const char *tag)
	150	void address_map_entry::set_write_bank(device_t &device, const char *tag)
150	151	{
151	152	m_write.m_type = AMH_BANK;
152		device.subtag(m_write.m_tag, tag);
	153	m_write.m_tag = tag;
	154	m_write.m_devbase = &device;
153	155	}
154	156
155	157
r18153	r18154
158	160	//  reading and writing to a memory bank
159	161	//-------------------------------------------------
160	162
161		void address_map_entry::set_readwrite_bank(const device_t &device, const char *tag)
	163	void address_map_entry::set_readwrite_bank(device_t &device, const char *tag)
162	164	{
163	165	m_read.m_type = AMH_BANK;
164		device.subtag(m_read.m_tag, tag);
	166	m_read.m_tag = tag;
	167	m_read.m_devbase = &device;
165	168	m_write.m_type = AMH_BANK;
166		device.subtag(m_write.m_tag, tag);
	169	m_write.m_tag = tag;
	170	m_write.m_devbase = &device;
167	171	}
168	172
169	173
r18153	r18154
172	176	//  retrieve a submap from a device
173	177	//-------------------------------------------------
174	178
175		void address_map_entry::set_submap(const device_t &device, const char *tag, address_map_delegate func, int bits, UINT64 mask)
	179	void address_map_entry::set_submap(device_t &device, const char *tag, address_map_delegate func, int bits, UINT64 mask)
176	180	{
177	181	if(!bits)
178	182	bits = m_map.m_databits;
r18153	r18154
180	184	assert(unitmask_is_appropriate(bits, mask, func.name()));
181	185
182	186	m_read.m_type = AMH_DEVICE_SUBMAP;
183		device.subtag(m_read.m_tag, tag);
	187	m_read.m_tag = tag;
	188	m_read.m_devbase = &device;
184	189	m_read.m_mask = mask;
185	190	m_write.m_type = AMH_DEVICE_SUBMAP;
186		device.subtag(m_write.m_tag, tag);
	191	m_write.m_tag = tag;
	192	m_write.m_devbase = &device;
187	193	m_write.m_mask = mask;
188	194	m_submap_delegate = func;
189	195	m_submap_bits = bits;
r18153	r18154
226	232	}
227	233
228	234
229		void address_map_entry::internal_set_handler(const device_t &device, const char *tag, read8_delegate func, UINT64 unitmask)
	235	void address_map_entry::internal_set_handler(device_t &device, read8_delegate func, UINT64 unitmask)
230	236	{
231	237	assert(!func.isnull());
232	238	assert(unitmask_is_appropriate(8, unitmask, func.name()));
r18153	r18154
234	240	m_read.m_bits = 8;
235	241	m_read.m_mask = unitmask;
236	242	m_read.m_name = func.name();
237		device.subtag(m_read.m_tag, tag);
	243	m_read.m_devbase = &device;
238	244	m_rproto8 = func;
239	245	}
240	246
241	247
242		void address_map_entry::internal_set_handler(const device_t &device, const char *tag, write8_delegate func, UINT64 unitmask)
	248	void address_map_entry::internal_set_handler(device_t &device, write8_delegate func, UINT64 unitmask)
243	249	{
244	250	assert(!func.isnull());
245	251	assert(unitmask_is_appropriate(8, unitmask, func.name()));
r18153	r18154
247	253	m_write.m_bits = 8;
248	254	m_write.m_mask = unitmask;
249	255	m_write.m_name = func.name();
250		device.subtag(m_write.m_tag, tag);
	256	m_write.m_devbase = &device;
251	257	m_wproto8 = func;
252	258	}
253	259
254	260
255		void address_map_entry::internal_set_handler(const device_t &device, const char *tag, read8_delegate rfunc, write8_delegate wfunc, UINT64 unitmask)
	261	void address_map_entry::internal_set_handler(device_t &device, read8_delegate rfunc, write8_delegate wfunc, UINT64 unitmask)
256	262	{
257		internal_set_handler(device, tag, rfunc, unitmask);
258		internal_set_handler(device, tag, wfunc, unitmask);
	263	internal_set_handler(device, rfunc, unitmask);
	264	internal_set_handler(device, wfunc, unitmask);
259	265	}
260	266
261	267
r18153	r18154
295	301	}
296	302
297	303
298		void address_map_entry::internal_set_handler(const device_t &device, const char *tag, read16_delegate func, UINT64 unitmask)
	304	void address_map_entry::internal_set_handler(device_t &device, read16_delegate func, UINT64 unitmask)
299	305	{
300	306	assert(!func.isnull());
301	307	assert(unitmask_is_appropriate(16, unitmask, func.name()));
r18153	r18154
303	309	m_read.m_bits = 16;
304	310	m_read.m_mask = unitmask;
305	311	m_read.m_name = func.name();
306		device.subtag(m_read.m_tag, tag);
	312	m_read.m_devbase = &device;
307	313	m_rproto16 = func;
308	314	}
309	315
310	316
311		void address_map_entry::internal_set_handler(const device_t &device, const char *tag, write16_delegate func, UINT64 unitmask)
	317	void address_map_entry::internal_set_handler(device_t &device, write16_delegate func, UINT64 unitmask)
312	318	{
313	319	assert(!func.isnull());
314	320	assert(unitmask_is_appropriate(16, unitmask, func.name()));
r18153	r18154
316	322	m_write.m_bits = 16;
317	323	m_write.m_mask = unitmask;
318	324	m_write.m_name = func.name();
319		device.subtag(m_write.m_tag, tag);
	325	m_write.m_devbase = &device;
320	326	m_wproto16 = func;
321	327	}
322	328
323	329
324		void address_map_entry::internal_set_handler(const device_t &device, const char *tag, read16_delegate rfunc, write16_delegate wfunc, UINT64 unitmask)
	330	void address_map_entry::internal_set_handler(device_t &device, read16_delegate rfunc, write16_delegate wfunc, UINT64 unitmask)
325	331	{
326		internal_set_handler(device, tag, rfunc, unitmask);
327		internal_set_handler(device, tag, wfunc, unitmask);
	332	internal_set_handler(device, rfunc, unitmask);
	333	internal_set_handler(device, wfunc, unitmask);
328	334	}
329	335
330	336
r18153	r18154
364	370	}
365	371
366	372
367		void address_map_entry::internal_set_handler(const device_t &device, const char *tag, read32_delegate func, UINT64 unitmask)
	373	void address_map_entry::internal_set_handler(device_t &device, read32_delegate func, UINT64 unitmask)
368	374	{
369	375	assert(!func.isnull());
370	376	assert(unitmask_is_appropriate(32, unitmask, func.name()));
r18153	r18154
372	378	m_read.m_bits = 32;
373	379	m_read.m_mask = unitmask;
374	380	m_read.m_name = func.name();
375		device.subtag(m_read.m_tag, tag);
	381	m_read.m_devbase = &device;
376	382	m_rproto32 = func;
377	383	}
378	384
379	385
380		void address_map_entry::internal_set_handler(const device_t &device, const char *tag, write32_delegate func, UINT64 unitmask)
	386	void address_map_entry::internal_set_handler(device_t &device, write32_delegate func, UINT64 unitmask)
381	387	{
382	388	assert(!func.isnull());
383	389	assert(unitmask_is_appropriate(32, unitmask, func.name()));
r18153	r18154
385	391	m_write.m_bits = 32;
386	392	m_write.m_mask = unitmask;
387	393	m_write.m_name = func.name();
388		device.subtag(m_write.m_tag, tag);
	394	m_write.m_devbase = &device;
389	395	m_wproto32 = func;
390	396	}
391	397
392	398
393		void address_map_entry::internal_set_handler(const device_t &device, const char *tag, read32_delegate rfunc, write32_delegate wfunc, UINT64 unitmask)
	399	void address_map_entry::internal_set_handler(device_t &device, read32_delegate rfunc, write32_delegate wfunc, UINT64 unitmask)
394	400	{
395		internal_set_handler(device, tag, rfunc, unitmask);
396		internal_set_handler(device, tag, wfunc, unitmask);
	401	internal_set_handler(device, rfunc, unitmask);
	402	internal_set_handler(device, wfunc, unitmask);
397	403	}
398	404
399	405
r18153	r18154
433	439	}
434	440
435	441
436		void address_map_entry::internal_set_handler(const device_t &device, const char *tag, read64_delegate func, UINT64 unitmask)
	442	void address_map_entry::internal_set_handler(device_t &device, read64_delegate func, UINT64 unitmask)
437	443	{
438	444	assert(!func.isnull());
439	445	assert(unitmask_is_appropriate(64, unitmask, func.name()));
r18153	r18154
441	447	m_read.m_bits = 64;
442	448	m_read.m_mask = 0;
443	449	m_read.m_name = func.name();
444		device.subtag(m_read.m_tag, tag);
	450	m_read.m_devbase = &device;
445	451	m_rproto64 = func;
446	452	}
447	453
448	454
449		void address_map_entry::internal_set_handler(const device_t &device, const char *tag, write64_delegate func, UINT64 unitmask)
	455	void address_map_entry::internal_set_handler(device_t &device, write64_delegate func, UINT64 unitmask)
450	456	{
451	457	assert(!func.isnull());
452	458	assert(unitmask_is_appropriate(64, unitmask, func.name()));
r18153	r18154
454	460	m_write.m_bits = 64;
455	461	m_write.m_mask = 0;
456	462	m_write.m_name = func.name();
457		device.subtag(m_write.m_tag, tag);
	463	m_write.m_devbase = &device;
458	464	m_wproto64 = func;
459	465	}
460	466
461	467
462		void address_map_entry::internal_set_handler(const device_t &device, const char *tag, read64_delegate rfunc, write64_delegate wfunc, UINT64 unitmask)
	468	void address_map_entry::internal_set_handler(device_t &device, read64_delegate rfunc, write64_delegate wfunc, UINT64 unitmask)
463	469	{
464		internal_set_handler(device, tag, rfunc, unitmask);
465		internal_set_handler(device, tag, wfunc, unitmask);
	470	internal_set_handler(device, rfunc, unitmask);
	471	internal_set_handler(device, wfunc, unitmask);
466	472	}
467	473
468	474
r18153	r18154
552	558	//  address_map - constructor
553	559	//-------------------------------------------------
554	560
555		address_map::address_map(const device_t &device, address_spacenum spacenum)
	561	address_map::address_map(device_t &device, address_spacenum spacenum)
556	562	: m_spacenum(spacenum),
557	563	m_databits(0xff),
558	564	m_unmapval(0),
r18153	r18154
587	593	//  address_map - constructor in the submap case
588	594	//-------------------------------------------------
589	595
590		address_map::address_map(const device_t &device, address_map_entry *entry)
	596	address_map::address_map(device_t &device, address_map_entry *entry)
591	597	: m_spacenum(AS_PROGRAM),
592	598	m_databits(0xff),
593	599	m_unmapval(0),
594	600	m_globalmask(0)
595	601	{
596	602	// Retrieve the submap
597		entry->m_submap_delegate.late_bind(const_cast<device_t &>(device));
	603	entry->m_submap_delegate.late_bind(device);
598	604	entry->m_submap_delegate(*this, device);
599	605	}
600	606
r18153	r18154
604	610	//  address_map - constructor dynamic device mapping case
605	611	//----------------------------------------------------------
606	612
607		address_map::address_map(const address_space &space, offs_t start, offs_t end, int bits, UINT64 unitmask, const device_t &device, address_map_delegate submap_delegate)
	613	address_map::address_map(const address_space &space, offs_t start, offs_t end, int bits, UINT64 unitmask, device_t &device, address_map_delegate submap_delegate)
608	614	: m_spacenum(space.spacenum()),
609	615	m_databits(space.data_width()),
610	616	m_unmapval(space.unmap()),

trunk/src/emu/addrmap.h

r18153	r18154
81	81	: m_type(AMH_NONE),
82	82	m_bits(0),
83	83	m_mask(0),
84		m_name(NULL) { }
	84	m_name(NULL),
	85	m_devbase(NULL),
	86	m_tag(NULL) { }
85	87
86	88	map_handler_type      m_type;            // type of the handler
87	89	UINT8               m_bits;            // width of the handler in bits, or 0 for default
88	90	UINT64               m_mask;            // mask for which lanes apply
89	91	const char *         m_name;            // name of the handler
90		astring               m_tag;            // path to the target tag
	92	device_t *            m_devbase;         // pointer to "base" device
	93	const char *         m_tag;            // tag for I/O ports and banks
91	94	};
92	95
93	96
r18153	r18154
110	113	void set_write_type(map_handler_type _type) { m_write.m_type = _type; }
111	114	void set_region(const char *tag, offs_t offset) { m_region = tag; m_rgnoffs = offset; }
112	115	void set_share(const char *tag) { assert(m_share == NULL); m_share = tag; }
113		void set_sizeptr(size_t *_sizeptr) { m_sizeptr = _sizeptr; }
114		void set_member_baseptr(FPTR offs) { m_baseptroffs_plus1 = offs + 1; }
115		void set_member_sizeptr(FPTR offs) { m_sizeptroffs_plus1 = offs + 1; }
116	116
117	117	// mask setting
118	118	void set_mask(offs_t _mask);
119	119
120	120	// I/O port configuration
121		void set_read_port(const device_t &device, const char *tag);
122		void set_write_port(const device_t &device, const char *tag);
123		void set_readwrite_port(const device_t &device, const char *tag);
	121	void set_read_port(device_t &device, const char *tag);
	122	void set_write_port(device_t &device, const char *tag);
	123	void set_readwrite_port(device_t &device, const char *tag);
124	124
125	125	// memory bank configuration
126		void set_read_bank(const device_t &device, const char *tag);
127		void set_write_bank(const device_t &device, const char *tag);
128		void set_readwrite_bank(const device_t &device, const char *tag);
	126	void set_read_bank(device_t &device, const char *tag);
	127	void set_write_bank(device_t &device, const char *tag);
	128	void set_readwrite_bank(device_t &device, const char *tag);
129	129
130	130	// submap referencing
131		void set_submap(const device_t &device, const char *tag, address_map_delegate func, int bits, UINT64 mask);
	131	void set_submap(device_t &device, const char *tag, address_map_delegate func, int bits, UINT64 mask);
132	132
133	133	// public state
134	134	address_map_entry *      m_next;               // pointer to the next entry
r18153	r18154
143	143	map_handler_data      m_read;               // data for read handler
144	144	map_handler_data      m_write;            // data for write handler
145	145	const char *         m_share;            // tag of a shared memory block
146		void **               m_baseptr;            // receives pointer to memory (optional)
147		size_t *            m_sizeptr;            // receives size of area in bytes (optional)
148		UINT32               m_baseptroffs_plus1;   // offset of base pointer within driver_data, plus 1
149		UINT32               m_sizeptroffs_plus1;   // offset of size pointer within driver_data, plus 1
150	146	const char *         m_region;            // tag of region containing the memory backing this entry
151	147	offs_t               m_rgnoffs;            // offset within the region
152	148
r18153	r18154
179	175	offs_t               m_bytemask;            // byte-adjusted mask bits
180	176
181	177	protected:
182		// internal base pointer setting (derived classes provide typed versions)
183		void internal_set_baseptr(void **_baseptr) { m_baseptr = _baseptr; }
184
185	178	// internal handler setters for 8-bit functions
186	179	void internal_set_handler(read8_space_func func, const char *string, UINT64 mask);
187	180	void internal_set_handler(write8_space_func func, const char *string, UINT64 mask);
188	181	void internal_set_handler(read8_space_func rfunc, const char *rstring, write8_space_func wfunc,  const char *wstring, UINT64 mask);
189		void internal_set_handler(const device_t &device, const char *tag, read8_delegate func, UINT64 mask);
190		void internal_set_handler(const device_t &device, const char *tag, write8_delegate func, UINT64 mask);
191		void internal_set_handler(const device_t &device, const char *tag, read8_delegate rfunc, write8_delegate wfunc, UINT64 mask);
	182	void internal_set_handler(device_t &device, read8_delegate func, UINT64 mask);
	183	void internal_set_handler(device_t &device, write8_delegate func, UINT64 mask);
	184	void internal_set_handler(device_t &device, read8_delegate rfunc, write8_delegate wfunc, UINT64 mask);
192	185
193	186	// internal handler setters for 16-bit functions
194	187	void internal_set_handler(read16_space_func func, const char *string, UINT64 mask);
195	188	void internal_set_handler(write16_space_func func, const char *string, UINT64 mask);
196	189	void internal_set_handler(read16_space_func rfunc, const char *rstring, write16_space_func wfunc, const char *wstring, UINT64 mask);
197		void internal_set_handler(const device_t &device, const char *tag, read16_delegate func, UINT64 mask);
198		void internal_set_handler(const device_t &device, const char *tag, write16_delegate func, UINT64 mask);
199		void internal_set_handler(const device_t &device, const char *tag, read16_delegate rfunc, write16_delegate wfunc, UINT64 mask);
	190	void internal_set_handler(device_t &device, read16_delegate func, UINT64 mask);
	191	void internal_set_handler(device_t &device, write16_delegate func, UINT64 mask);
	192	void internal_set_handler(device_t &device, read16_delegate rfunc, write16_delegate wfunc, UINT64 mask);
200	193
201	194	// internal handler setters for 32-bit functions
202	195	void internal_set_handler(read32_space_func func, const char *string, UINT64 mask);
203	196	void internal_set_handler(write32_space_func func, const char *string, UINT64 mask);
204	197	void internal_set_handler(read32_space_func rfunc, const char *rstring, write32_space_func wfunc, const char *wstring, UINT64 mask);
205		void internal_set_handler(const device_t &device, const char *tag, read32_delegate func, UINT64 mask);
206		void internal_set_handler(const device_t &device, const char *tag, write32_delegate func, UINT64 mask);
207		void internal_set_handler(const device_t &device, const char *tag, read32_delegate rfunc, write32_delegate wfunc, UINT64 mask);
	198	void internal_set_handler(device_t &device, read32_delegate func, UINT64 mask);
	199	void internal_set_handler(device_t &device, write32_delegate func, UINT64 mask);
	200	void internal_set_handler(device_t &device, read32_delegate rfunc, write32_delegate wfunc, UINT64 mask);
208	201
209	202	// internal handler setters for 64-bit functions
210	203	void internal_set_handler(read64_space_func func, const char *string, UINT64 mask);
211	204	void internal_set_handler(write64_space_func func, const char *string, UINT64 mask);
212	205	void internal_set_handler(read64_space_func rfunc, const char *rstring, write64_space_func wfunc, const char *wstring, UINT64 mask);
213		void internal_set_handler(const device_t &device, const char *tag, read64_delegate func, UINT64 mask);
214		void internal_set_handler(const device_t &device, const char *tag, write64_delegate func, UINT64 mask);
215		void internal_set_handler(const device_t &device, const char *tag, read64_delegate rfunc, write64_delegate wfunc, UINT64 mask);
	206	void internal_set_handler(device_t &device, read64_delegate func, UINT64 mask);
	207	void internal_set_handler(device_t &device, write64_delegate func, UINT64 mask);
	208	void internal_set_handler(device_t &device, read64_delegate rfunc, write64_delegate wfunc, UINT64 mask);
216	209
217	210	private:
218	211	// helper functions
r18153	r18154
228	221	public:
229	222	address_map_entry8(address_map &map, offs_t start, offs_t end);
230	223
231		void set_baseptr(UINT8 **baseptr) { internal_set_baseptr(reinterpret_cast<void **>(baseptr)); }
232
233	224	// native-size handlers
234	225	void set_handler(read8_space_func func, const char *string) { internal_set_handler(func, string, 0); }
235	226	void set_handler(write8_space_func func, const char *string) { internal_set_handler(func, string, 0); }
236	227	void set_handler(read8_space_func rfunc, const char *rstring, write8_space_func wfunc, const char *wstring) { internal_set_handler(rfunc, rstring, wfunc, wstring, 0); }
237		void set_handler(const device_t &device, const char *tag, read8_delegate func) { internal_set_handler(device, tag, func, 0); }
238		void set_handler(const device_t &device, const char *tag, write8_delegate func) { internal_set_handler(device, tag, func, 0); }
239		void set_handler(const device_t &device, const char *tag, read8_delegate rfunc, write8_delegate wfunc) { internal_set_handler(device, tag, rfunc, wfunc, 0); }
	228	void set_handler(device_t &device, read8_delegate func) { internal_set_handler(device, func, 0); }
	229	void set_handler(device_t &device, write8_delegate func) { internal_set_handler(device, func, 0); }
	230	void set_handler(device_t &device, read8_delegate rfunc, write8_delegate wfunc) { internal_set_handler(device, rfunc, wfunc, 0); }
240	231	};
241	232
242	233
r18153	r18154
248	239	public:
249	240	address_map_entry16(address_map &map, offs_t start, offs_t end);
250	241
251		void set_baseptr(UINT16 **baseptr) { internal_set_baseptr(reinterpret_cast<void **>(baseptr)); }
252
253	242	// native-size handlers
254	243	void set_handler(read16_space_func func, const char *string) { internal_set_handler(func, string, 0); }
255	244	void set_handler(write16_space_func func, const char *string) { internal_set_handler(func, string, 0); }
256	245	void set_handler(read16_space_func rfunc, const char *rstring, write16_space_func wfunc, const char *wstring) { internal_set_handler(rfunc, rstring, wfunc, wstring, 0); }
257		void set_handler(const device_t &device, const char *tag, read16_delegate func) { internal_set_handler(device, tag, func, 0); }
258		void set_handler(const device_t &device, const char *tag, write16_delegate func) { internal_set_handler(device, tag, func, 0); }
259		void set_handler(const device_t &device, const char *tag, read16_delegate rfunc, write16_delegate wfunc) { internal_set_handler(device, tag, rfunc, wfunc, 0); }
	246	void set_handler(device_t &device, read16_delegate func) { internal_set_handler(device, func, 0); }
	247	void set_handler(device_t &device, write16_delegate func) { internal_set_handler(device, func, 0); }
	248	void set_handler(device_t &device, read16_delegate rfunc, write16_delegate wfunc) { internal_set_handler(device, rfunc, wfunc, 0); }
260	249
261	250	// 8-bit handlers
262	251	void set_handler(read8_space_func func, const char *string, UINT16 mask) { internal_set_handler(func, string, mask); }
263	252	void set_handler(write8_space_func func, const char *string, UINT16 mask) { internal_set_handler(func, string, mask); }
264	253	void set_handler(read8_space_func rfunc, const char *rstring, write8_space_func wfunc, const char *wstring, UINT16 mask) { internal_set_handler(rfunc, rstring, wfunc, wstring, mask); }
265		void set_handler(const device_t &device, const char *tag, read8_delegate func, UINT16 mask) { internal_set_handler(device, tag, func, mask); }
266		void set_handler(const device_t &device, const char *tag, write8_delegate func, UINT16 mask) { internal_set_handler(device, tag, func, mask); }
267		void set_handler(const device_t &device, const char *tag, read8_delegate rfunc, write8_delegate wfunc, UINT16 mask) { internal_set_handler(device, tag, rfunc, wfunc, mask); }
	254	void set_handler(device_t &device, read8_delegate func, UINT16 mask) { internal_set_handler(device, func, mask); }
	255	void set_handler(device_t &device, write8_delegate func, UINT16 mask) { internal_set_handler(device, func, mask); }
	256	void set_handler(device_t &device, read8_delegate rfunc, write8_delegate wfunc, UINT16 mask) { internal_set_handler(device, rfunc, wfunc, mask); }
268	257	};
269	258
270	259
r18153	r18154
276	265	public:
277	266	address_map_entry32(address_map &map, offs_t start, offs_t end);
278	267
279		void set_baseptr(UINT32 **baseptr) { internal_set_baseptr(reinterpret_cast<void **>(baseptr)); }
280
281	268	// native-size handlers
282	269	void set_handler(read32_space_func func, const char *string) { internal_set_handler(func, string, 0); }
283	270	void set_handler(write32_space_func func, const char *string) { internal_set_handler(func, string, 0); }
284	271	void set_handler(read32_space_func rfunc, const char *rstring, write32_space_func wfunc, const char *wstring) { internal_set_handler(rfunc, rstring, wfunc, wstring, 0); }
285		void set_handler(const device_t &device, const char *tag, read32_delegate func) { internal_set_handler(device, tag, func, 0); }
286		void set_handler(const device_t &device, const char *tag, write32_delegate func) { internal_set_handler(device, tag, func, 0); }
287		void set_handler(const device_t &device, const char *tag, read32_delegate rfunc, write32_delegate wfunc) { internal_set_handler(device, tag, rfunc, wfunc, 0); }
	272	void set_handler(device_t &device, read32_delegate func) { internal_set_handler(device, func, 0); }
	273	void set_handler(device_t &device, write32_delegate func) { internal_set_handler(device, func, 0); }
	274	void set_handler(device_t &device, read32_delegate rfunc, write32_delegate wfunc) { internal_set_handler(device, rfunc, wfunc, 0); }
288	275
289	276	// 16-bit handlers
290	277	void set_handler(read16_space_func func, const char *string, UINT32 mask) { internal_set_handler(func, string, mask); }
291	278	void set_handler(write16_space_func func, const char *string, UINT32 mask) { internal_set_handler(func, string, mask); }
292	279	void set_handler(read16_space_func rfunc, const char *rstring, write16_space_func wfunc, const char *wstring, UINT32 mask) { internal_set_handler(rfunc, rstring, wfunc, wstring, mask); }
293		void set_handler(const device_t &device, const char *tag, read16_delegate func, UINT32 mask) { internal_set_handler(device, tag, func, mask); }
294		void set_handler(const device_t &device, const char *tag, write16_delegate func, UINT32 mask) { internal_set_handler(device, tag, func, mask); }
295		void set_handler(const device_t &device, const char *tag, read16_delegate rfunc, write16_delegate wfunc, UINT32 mask) { internal_set_handler(device, tag, rfunc, wfunc, mask); }
	280	void set_handler(device_t &device, read16_delegate func, UINT32 mask) { internal_set_handler(device, func, mask); }
	281	void set_handler(device_t &device, write16_delegate func, UINT32 mask) { internal_set_handler(device, func, mask); }
	282	void set_handler(device_t &device, read16_delegate rfunc, write16_delegate wfunc, UINT32 mask) { internal_set_handler(device, rfunc, wfunc, mask); }
296	283
297	284	// 8-bit handlers
298	285	void set_handler(read8_space_func func, const char *string, UINT32 mask) { internal_set_handler(func, string, mask); }
299	286	void set_handler(write8_space_func func, const char *string, UINT32 mask) { internal_set_handler(func, string, mask); }
300	287	void set_handler(read8_space_func rfunc, const char *rstring, write8_space_func wfunc, const char *wstring, UINT32 mask) { internal_set_handler(rfunc, rstring, wfunc, wstring, mask); }
301		void set_handler(const device_t &device, const char *tag, read8_delegate func, UINT32 mask) { internal_set_handler(device, tag, func, mask); }
302		void set_handler(const device_t &device, const char *tag, write8_delegate func, UINT32 mask) { internal_set_handler(device, tag, func, mask); }
303		void set_handler(const device_t &device, const char *tag, read8_delegate rfunc, write8_delegate wfunc, UINT32 mask) { internal_set_handler(device, tag, rfunc, wfunc, mask); }
	288	void set_handler(device_t &device, read8_delegate func, UINT32 mask) { internal_set_handler(device, func, mask); }
	289	void set_handler(device_t &device, write8_delegate func, UINT32 mask) { internal_set_handler(device, func, mask); }
	290	void set_handler(device_t &device, read8_delegate rfunc, write8_delegate wfunc, UINT32 mask) { internal_set_handler(device, rfunc, wfunc, mask); }
304	291	};
305	292
306	293
r18153	r18154
312	299	public:
313	300	address_map_entry64(address_map &map, offs_t start, offs_t end);
314	301
315		void set_baseptr(UINT64 **baseptr) { internal_set_baseptr(reinterpret_cast<void **>(baseptr)); }
316
317	302	// native-size handlers
318	303	void set_handler(read64_space_func func, const char *string) { internal_set_handler(func, string, 0); }
319	304	void set_handler(write64_space_func func, const char *string) { internal_set_handler(func, string, 0); }
320	305	void set_handler(read64_space_func rfunc, const char *rstring, write64_space_func wfunc, const char *wstring) { internal_set_handler(rfunc, rstring, wfunc, wstring, 0); }
321		void set_handler(const device_t &device, const char *tag, read64_delegate func) { internal_set_handler(device, tag, func, 0); }
322		void set_handler(const device_t &device, const char *tag, write64_delegate func) { internal_set_handler(device, tag, func, 0); }
323		void set_handler(const device_t &device, const char *tag, read64_delegate rfunc, write64_delegate wfunc) { internal_set_handler(device, tag, rfunc, wfunc, 0); }
	306	void set_handler(device_t &device, read64_delegate func) { internal_set_handler(device, func, 0); }
	307	void set_handler(device_t &device, write64_delegate func) { internal_set_handler(device, func, 0); }
	308	void set_handler(device_t &device, read64_delegate rfunc, write64_delegate wfunc) { internal_set_handler(device, rfunc, wfunc, 0); }
324	309
325	310	// 32-bit handlers
326	311	void set_handler(read32_space_func func, const char *string, UINT64 mask) { internal_set_handler(func, string, mask); }
327	312	void set_handler(write32_space_func func, const char *string, UINT64 mask) { internal_set_handler(func, string, mask); }
328	313	void set_handler(read32_space_func rfunc, const char *rstring, write32_space_func wfunc, const char *wstring, UINT64 mask) { internal_set_handler(rfunc, rstring, wfunc, wstring, mask); }
329		void set_handler(const device_t &device, const char *tag, read32_delegate func, UINT64 mask) { internal_set_handler(device, tag, func, mask); }
330		void set_handler(const device_t &device, const char *tag, write32_delegate func, UINT64 mask) { internal_set_handler(device, tag, func, mask); }
331		void set_handler(const device_t &device, const char *tag, read32_delegate rfunc, write32_delegate wfunc, UINT64 mask) { internal_set_handler(device, tag, rfunc, wfunc, mask); }
	314	void set_handler(device_t &device, read32_delegate func, UINT64 mask) { internal_set_handler(device, func, mask); }
	315	void set_handler(device_t &device, write32_delegate func, UINT64 mask) { internal_set_handler(device, func, mask); }
	316	void set_handler(device_t &device, read32_delegate rfunc, write32_delegate wfunc, UINT64 mask) { internal_set_handler(device, rfunc, wfunc, mask); }
332	317
333	318	// 16-bit handlers
334	319	void set_handler(read16_space_func func, const char *string, UINT64 mask) { internal_set_handler(func, string, mask); }
335	320	void set_handler(write16_space_func func, const char *string, UINT64 mask) { internal_set_handler(func, string, mask); }
336	321	void set_handler(read16_space_func rfunc, const char *rstring, write16_space_func wfunc, const char *wstring, UINT64 mask) { internal_set_handler(rfunc, rstring, wfunc, wstring, mask); }
337		void set_handler(const device_t &device, const char *tag, read16_delegate func, UINT64 mask) { internal_set_handler(device, tag, func, mask); }
338		void set_handler(const device_t &device, const char *tag, write16_delegate func, UINT64 mask) { internal_set_handler(device, tag, func, mask); }
339		void set_handler(const device_t &device, const char *tag, read16_delegate rfunc, write16_delegate wfunc, UINT64 mask) { internal_set_handler(device, tag, rfunc, wfunc, mask); }
	322	void set_handler(device_t &device, read16_delegate func, UINT64 mask) { internal_set_handler(device, func, mask); }
	323	void set_handler(device_t &device, write16_delegate func, UINT64 mask) { internal_set_handler(device, func, mask); }
	324	void set_handler(device_t &device, read16_delegate rfunc, write16_delegate wfunc, UINT64 mask) { internal_set_handler(device, rfunc, wfunc, mask); }
340	325
341	326	// 8-bit handlers
342	327	void set_handler(read8_space_func func, const char *string, UINT64 mask) { internal_set_handler(func, string, mask); }
343	328	void set_handler(write8_space_func func, const char *string, UINT64 mask) { internal_set_handler(func, string, mask); }
344	329	void set_handler(read8_space_func rfunc, const char *rstring, write8_space_func wfunc, const char *wstring, UINT64 mask) { internal_set_handler(rfunc, rstring, wfunc, wstring, mask); }
345		void set_handler(const device_t &device, const char *tag, read8_delegate func, UINT64 mask) { internal_set_handler(device, tag, func, mask); }
346		void set_handler(const device_t &device, const char *tag, write8_delegate func, UINT64 mask) { internal_set_handler(device, tag, func, mask); }
347		void set_handler(const device_t &device, const char *tag, read8_delegate rfunc, write8_delegate wfunc, UINT64 mask) { internal_set_handler(device, tag, rfunc, wfunc, mask); }
	330	void set_handler(device_t &device, read8_delegate func, UINT64 mask) { internal_set_handler(device, func, mask); }
	331	void set_handler(device_t &device, write8_delegate func, UINT64 mask) { internal_set_handler(device, func, mask); }
	332	void set_handler(device_t &device, read8_delegate rfunc, write8_delegate wfunc, UINT64 mask) { internal_set_handler(device, rfunc, wfunc, mask); }
348	333	};
349	334
350	335
r18153	r18154
355	340	{
356	341	public:
357	342	// construction/destruction
358		address_map(const device_t &device, address_spacenum spacenum);
359		address_map(const device_t &device, address_map_entry *entry);
360		address_map(const address_space &space, offs_t start, offs_t end, int bits, UINT64 unitmask, const device_t &device, address_map_delegate submap_delegate);
	343	address_map(device_t &device, address_spacenum spacenum);
	344	address_map(device_t &device, address_map_entry *entry);
	345	address_map(const address_space &space, offs_t start, offs_t end, int bits, UINT64 unitmask, device_t &device, address_map_delegate submap_delegate);
361	346	~address_map();
362	347
363	348	// configuration
r18153	r18154
395	380	#define ADDRESS_MAP_NAME(_name) construct_address_map_##_name
396	381
397	382	#define ADDRESS_MAP_START(_name, _space, _bits, _class) \
398		void ADDRESS_MAP_NAME(_name)(address_map &map, const device_t &device) \
	383	void ADDRESS_MAP_NAME(_name)(address_map &map, device_t &device) \
399	384	{ \
400	385	typedef read##_bits##_delegate read_delegate; \
401	386	typedef write##_bits##_delegate write_delegate; \
r18153	r18154
405	390	typedef _class drivdata_class; \
406	391
407	392	#define DEVICE_ADDRESS_MAP_START(_name, _bits, _class) \
408		void _class :: _name(address_map &map, const device_t &device) \
	393	void _class :: _name(address_map &map, device_t &device) \
409	394	{ \
410	395	typedef read##_bits##_delegate read_delegate; \
411	396	typedef write##_bits##_delegate write_delegate; \
r18153	r18154
419	404
420	405	// use this to declare external references to an address map
421	406	#define ADDRESS_MAP_EXTERN(_name, _bits) \
422		extern void ADDRESS_MAP_NAME(_name)(address_map &map, const device_t &device)
	407	extern void ADDRESS_MAP_NAME(_name)(address_map &map, device_t &device)
423	408
424	409	// use this to declare an address map as a member of a modern device class
425	410	#define DECLARE_ADDRESS_MAP(_name, _bits) \
426		void _name(address_map &map, const device_t &device)
	411	void _name(address_map &map, device_t &device)
427	412
428	413
429	414	// global controls
r18153	r18154
495	480
496	481	// legacy device reads
497	482	#define AM_DEVREAD_LEGACY(_tag, _handler) \
498		curentry->set_handler(device, _tag, read_delegate(&_handler, #_handler, (device_t *)0)); \
	483	curentry->set_handler(device, read_delegate(&_handler, #_handler, _tag, (device_t *)0)); \
499	484
500	485	#define AM_DEVREAD8_LEGACY(_tag, _handler, _unitmask) \
501		curentry->set_handler(device, _tag, read8_delegate(&_handler, #_handler, (device_t *)0), _unitmask); \
	486	curentry->set_handler(device, read8_delegate(&_handler, #_handler, _tag, (device_t *)0), _unitmask); \
502	487
503	488
504	489
505	490
506	491	// legacy device writes
507	492	#define AM_DEVWRITE_LEGACY(_tag, _handler) \
508		curentry->set_handler(device, _tag, write_delegate(&_handler, #_handler, (device_t *)0)); \
	493	curentry->set_handler(device, write_delegate(&_handler, #_handler, _tag, (device_t *)0)); \
509	494
510	495	#define AM_DEVWRITE8_LEGACY(_tag, _handler, _unitmask) \
511		curentry->set_handler(device, _tag, write8_delegate(&_handler, #_handler, (device_t *)0), _unitmask); \
	496	curentry->set_handler(device, write8_delegate(&_handler, #_handler, _tag, (device_t *)0), _unitmask); \
512	497
513	498	#define AM_DEVWRITE16_LEGACY(_tag, _handler, _unitmask) \
514		curentry->set_handler(device, _tag, write16_delegate(&_handler, #_handler, (device_t *)0), _unitmask); \
	499	curentry->set_handler(device, write16_delegate(&_handler, #_handler, _tag, (device_t *)0), _unitmask); \
515	500
516	501
517	502
518	503	// legacy device reads/writes
519	504	#define AM_DEVREADWRITE_LEGACY(_tag, _rhandler, _whandler) \
520		curentry->set_handler(device, _tag, read_delegate(&_rhandler, #_rhandler, (device_t *)0), write_delegate(&_whandler, #_whandler, (device_t *)0)); \
	505	curentry->set_handler(device, read_delegate(&_rhandler, #_rhandler, _tag, (device_t *)0), write_delegate(&_whandler, #_whandler, _tag, (device_t *)0)); \
521	506
522	507	#define AM_DEVREADWRITE8_LEGACY(_tag, _rhandler, _whandler, _unitmask) \
523		curentry->set_handler(device, _tag, read8_delegate(&_rhandler, #_rhandler, (device_t *)0), write8_delegate(&_whandler, #_whandler, (device_t *)0), _unitmask); \
	508	curentry->set_handler(device, read8_delegate(&_rhandler, #_rhandler, _tag, (device_t *)0), write8_delegate(&_whandler, #_whandler, _tag, (device_t *)0), _unitmask); \
524	509
525	510	#define AM_DEVREADWRITE16_LEGACY(_tag, _rhandler, _whandler, _unitmask) \
526		curentry->set_handler(device, _tag, read16_delegate(&_rhandler, #_rhandler, (device_t *)0), write16_delegate(&_whandler, #_whandler, (device_t *)0), _unitmask); \
	511	curentry->set_handler(device, read16_delegate(&_rhandler, #_rhandler, _tag, (device_t *)0), write16_delegate(&_whandler, #_whandler, _tag, (device_t *)0), _unitmask); \
527	512
528	513	#define AM_DEVREADWRITE32_LEGACY(_tag, _rhandler, _whandler, _unitmask) \
529		curentry->set_handler(device, _tag, read32_delegate(&_rhandler, #_rhandler, (device_t *)0), write32_delegate(&_whandler, #_whandler, (device_t *)0), _unitmask); \
	514	curentry->set_handler(device, read32_delegate(&_rhandler, #_rhandler, _tag, (device_t *)0), write32_delegate(&_whandler, #_whandler, _tag, (device_t *)0), _unitmask); \
530	515
531	516
532	517	// driver data reads
533	518	#define AM_READ(_handler) \
534		curentry->set_handler(device, DEVICE_SELF, read_delegate(&drivdata_class::_handler, "driver_data::" #_handler, (drivdata_class *)0)); \
	519	curentry->set_handler(device, read_delegate(&drivdata_class::_handler, "driver_data::" #_handler, DEVICE_SELF, (drivdata_class *)0)); \
535	520
536	521	#define AM_READ8(_handler, _unitmask) \
537		curentry->set_handler(device, DEVICE_SELF, read8_delegate(&drivdata_class::_handler, "driver_data::" #_handler, (drivdata_class *)0), _unitmask); \
	522	curentry->set_handler(device, read8_delegate(&drivdata_class::_handler, "driver_data::" #_handler, DEVICE_SELF, (drivdata_class *)0), _unitmask); \
538	523
539	524	#define AM_READ16(_handler, _unitmask) \
540		curentry->set_handler(device, DEVICE_SELF, read16_delegate(&drivdata_class::_handler, "driver_data::" #_handler, (drivdata_class *)0), _unitmask); \
	525	curentry->set_handler(device, read16_delegate(&drivdata_class::_handler, "driver_data::" #_handler, DEVICE_SELF, (drivdata_class *)0), _unitmask); \
541	526
542	527	#define AM_READ32(_handler, _unitmask) \
543		curentry->set_handler(device, DEVICE_SELF, read32_delegate(&drivdata_class::_handler, "driver_data::" #_handler, (drivdata_class *)0), _unitmask); \
	528	curentry->set_handler(device, read32_delegate(&drivdata_class::_handler, "driver_data::" #_handler, DEVICE_SELF, (drivdata_class *)0), _unitmask); \
544	529
545	530
546	531	// driver data writes
547	532	#define AM_WRITE(_handler) \
548		curentry->set_handler(device, DEVICE_SELF, write_delegate(&drivdata_class::_handler, "driver_data::" #_handler, (drivdata_class *)0)); \
	533	curentry->set_handler(device, write_delegate(&drivdata_class::_handler, "driver_data::" #_handler, DEVICE_SELF, (drivdata_class *)0)); \
549	534
550	535	#define AM_WRITE8(_handler, _unitmask) \
551		curentry->set_handler(device, DEVICE_SELF, write8_delegate(&drivdata_class::_handler, "driver_data::" #_handler, (drivdata_class *)0), _unitmask); \
	536	curentry->set_handler(device, write8_delegate(&drivdata_class::_handler, "driver_data::" #_handler, DEVICE_SELF, (drivdata_class *)0), _unitmask); \
552	537
553	538	#define AM_WRITE16(_handler, _unitmask) \
554		curentry->set_handler(device, DEVICE_SELF, write16_delegate(&drivdata_class::_handler, "driver_data::" #_handler, (drivdata_class *)0), _unitmask); \
	539	curentry->set_handler(device, write16_delegate(&drivdata_class::_handler, "driver_data::" #_handler, DEVICE_SELF, (drivdata_class *)0), _unitmask); \
555	540
556	541	#define AM_WRITE32(_handler, _unitmask) \
557		curentry->set_handler(device, DEVICE_SELF, write32_delegate(&drivdata_class::_handler, "driver_data::" #_handler, (drivdata_class *)0), _unitmask); \
	542	curentry->set_handler(device, write32_delegate(&drivdata_class::_handler, "driver_data::" #_handler, DEVICE_SELF, (drivdata_class *)0), _unitmask); \
558	543
559	544
560	545	// driver data reads/writes
561	546	#define AM_READWRITE(_rhandler, _whandler) \
562		curentry->set_handler(device, DEVICE_SELF, read_delegate(&drivdata_class::_rhandler, "driver_data::" #_rhandler, (drivdata_class *)0), write_delegate(&drivdata_class::_whandler, "driver_data::" #_whandler, (drivdata_class *)0)); \
	547	curentry->set_handler(device, read_delegate(&drivdata_class::_rhandler, "driver_data::" #_rhandler, DEVICE_SELF, (drivdata_class *)0), write_delegate(&drivdata_class::_whandler, "driver_data::" #_whandler, DEVICE_SELF, (drivdata_class *)0)); \
563	548
564	549	#define AM_READWRITE8(_rhandler, _whandler, _unitmask) \
565		curentry->set_handler(device, DEVICE_SELF, read8_delegate(&drivdata_class::_rhandler, "driver_data::" #_rhandler, (drivdata_class *)0), write8_delegate(&drivdata_class::_whandler, "driver_data::" #_whandler, (drivdata_class *)0), _unitmask); \
	550	curentry->set_handler(device, read8_delegate(&drivdata_class::_rhandler, "driver_data::" #_rhandler, DEVICE_SELF, (drivdata_class *)0), write8_delegate(&drivdata_class::_whandler, "driver_data::" #_whandler, DEVICE_SELF, (drivdata_class *)0), _unitmask); \
566	551
567	552	#define AM_READWRITE16(_rhandler, _whandler, _unitmask) \
568		curentry->set_handler(device, DEVICE_SELF, read16_delegate(&drivdata_class::_rhandler, "driver_data::" #_rhandler, (drivdata_class *)0), write16_delegate(&drivdata_class::_whandler, "driver_data::" #_whandler, (drivdata_class *)0), _unitmask); \
	553	curentry->set_handler(device, read16_delegate(&drivdata_class::_rhandler, "driver_data::" #_rhandler, DEVICE_SELF, (drivdata_class *)0), write16_delegate(&drivdata_class::_whandler, "driver_data::" #_whandler, DEVICE_SELF, (drivdata_class *)0), _unitmask); \
569	554
570	555	#define AM_READWRITE32(_rhandler, _whandler, _unitmask) \
571		curentry->set_handler(device, DEVICE_SELF, read32_delegate(&drivdata_class::_rhandler, "driver_data::" #_rhandler, (drivdata_class *)0), write32_delegate(&drivdata_class::_whandler, "driver_data::" #_whandler, (drivdata_class *)0), _unitmask); \
	556	curentry->set_handler(device, read32_delegate(&drivdata_class::_rhandler, "driver_data::" #_rhandler, DEVICE_SELF, (drivdata_class *)0), write32_delegate(&drivdata_class::_whandler, "driver_data::" #_whandler, DEVICE_SELF, (drivdata_class *)0), _unitmask); \
572	557
573	558
574	559	// device reads
575	560	#define AM_DEVREAD(_tag, _class, _handler) \
576		curentry->set_handler(device, _tag, read_delegate(&_class::_handler, #_class "::" #_handler, (_class *)0)); \
	561	curentry->set_handler(device, read_delegate(&_class::_handler, #_class "::" #_handler, _tag, (_class *)0)); \
577	562
578	563	#define AM_DEVREAD8(_tag, _class, _handler, _unitmask) \
579		curentry->set_handler(device, _tag, read8_delegate(&_class::_handler, #_class "::" #_handler, (_class *)0), _unitmask); \
	564	curentry->set_handler(device, read8_delegate(&_class::_handler, #_class "::" #_handler, _tag, (_class *)0), _unitmask); \
580	565
581	566	#define AM_DEVREAD16(_tag, _class, _handler, _unitmask) \
582		curentry->set_handler(device, _tag, read16_delegate(&_class::_handler, #_class "::" #_handler, (_class *)0), _unitmask); \
	567	curentry->set_handler(device, read16_delegate(&_class::_handler, #_class "::" #_handler, _tag, (_class *)0), _unitmask); \
583	568
584	569	#define AM_DEVREAD32(_tag, _class, _handler, _unitmask) \
585		curentry->set_handler(device, _tag, read32_delegate(&_class::_handler, #_class "::" #_handler, (_class *)0), _unitmask); \
	570	curentry->set_handler(device, read32_delegate(&_class::_handler, #_class "::" #_handler, _tag, (_class *)0), _unitmask); \
586	571
587	572
588	573	// device writes
589	574	#define AM_DEVWRITE(_tag, _class, _handler) \
590		curentry->set_handler(device, _tag, write_delegate(&_class::_handler, #_class "::" #_handler, (_class *)0)); \
	575	curentry->set_handler(device, write_delegate(&_class::_handler, #_class "::" #_handler, _tag, (_class *)0)); \
591	576
592	577	#define AM_DEVWRITE8(_tag, _class, _handler, _unitmask) \
593		curentry->set_handler(device, _tag, write8_delegate(&_class::_handler, #_class "::" #_handler, (_class *)0), _unitmask); \
	578	curentry->set_handler(device, write8_delegate(&_class::_handler, #_class "::" #_handler, _tag, (_class *)0), _unitmask); \
594	579
595	580	#define AM_DEVWRITE16(_tag, _class, _handler, _unitmask) \
596		curentry->set_handler(device, _tag, write16_delegate(&_class::_handler, #_class "::" #_handler, (_class *)0), _unitmask); \
	581	curentry->set_handler(device, write16_delegate(&_class::_handler, #_class "::" #_handler, _tag, (_class *)0), _unitmask); \
597	582
598	583	#define AM_DEVWRITE32(_tag, _class, _handler, _unitmask) \
599		curentry->set_handler(device, _tag, write32_delegate(&_class::_handler, #_class "::" #_handler, (_class *)0), _unitmask); \
	584	curentry->set_handler(device, write32_delegate(&_class::_handler, #_class "::" #_handler, _tag, (_class *)0), _unitmask); \
600	585
601	586
602	587	// device reads/writes
603	588	#define AM_DEVREADWRITE(_tag, _class, _rhandler, _whandler) \
604		curentry->set_handler(device, _tag, read_delegate(&_class::_rhandler, #_class "::" #_rhandler, (_class *)0), write_delegate(&_class::_whandler, #_class "::" #_whandler, (_class *)0)); \
	589	curentry->set_handler(device, read_delegate(&_class::_rhandler, #_class "::" #_rhandler, _tag, (_class *)0), write_delegate(&_class::_whandler, #_class "::" #_whandler, _tag, (_class *)0)); \
605	590
606	591	#define AM_DEVREADWRITE8(_tag, _class, _rhandler, _whandler, _unitmask) \
607		curentry->set_handler(device, _tag, read8_delegate(&_class::_rhandler, #_class "::" #_rhandler, (_class *)0), write8_delegate(&_class::_whandler, #_class "::" #_whandler, (_class *)0), _unitmask); \
	592	curentry->set_handler(device, read8_delegate(&_class::_rhandler, #_class "::" #_rhandler, _tag, (_class *)0), write8_delegate(&_class::_whandler, #_class "::" #_whandler, _tag, (_class *)0), _unitmask); \
608	593
609	594	#define AM_DEVREADWRITE16(_tag, _class, _rhandler, _whandler, _unitmask) \
610		curentry->set_handler(device, _tag, read16_delegate(&_class::_rhandler, #_class "::" #_rhandler, (_class *)0), write16_delegate(&_class::_whandler, #_class "::" #_whandler, (_class *)0), _unitmask); \
	595	curentry->set_handler(device, read16_delegate(&_class::_rhandler, #_class "::" #_rhandler, _tag, (_class *)0), write16_delegate(&_class::_whandler, #_class "::" #_whandler, _tag, (_class *)0), _unitmask); \
611	596
612	597	#define AM_DEVREADWRITE32(_tag, _class, _rhandler, _whandler, _unitmask) \
613		curentry->set_handler(device, _tag, read32_delegate(&_class::_rhandler, #_class "::" #_rhandler, (_class *)0), write32_delegate(&_class::_whandler, #_class "::" #_whandler, (_class *)0), _unitmask); \
	598	curentry->set_handler(device, read32_delegate(&_class::_rhandler, #_class "::" #_rhandler, _tag, (_class *)0), write32_delegate(&_class::_whandler, #_class "::" #_whandler, _tag, (_class *)0), _unitmask); \
614	599
615	600
616	601	// device mapping

trunk/src/emu/devcb.h

r18153	r18154
99	99	//  MACROS
100	100	//**************************************************************************
101	101
	102	// Some useful delegates
	103	typedef delegate<void (bool state)> line_cb_t;
	104
102	105	// static template for a read_line stub function that calls through a given READ_LINE_MEMBER
103	106	template<class _Class, int (_Class::*_Function)()>
104	107	int devcb_line_stub(device_t *device)

Previous

199869 Revisions

Next

---

© 1997-2024 The MAME Team