Massive memory system change. This is another step along the path toward

supporting cleaner implementations of drivers in the explicitly OO world.
Expect a follow-on of several more changes to clean up from this one, which
deliberately tried to avoid touching much driver code.

Converted address_space to a class, and moved most members behind accessor
methods, apart from space->machine and space->cpu. Removed external references
to 8le/8be/16le/16be/32le/32be/64le/64be. All external access is now done via
virtual functions read_byte()/read_word()/etc. Moved differentiation between
the endianness and the bus width internal to memory.c, and also added a new
axis to support small/large address spaces, which allows for faster lookups
on spaces smaller than 18 bits. 

Provided methods for most global memory operations within the new address_space 
class. These will be bulk converted in a future update, but for now there are
inline wrappers to hide this change from existing callers.

Created new module delegate.h which implements C++ delegates in a form that 
works for MAME. Details are in the opening comment. Delegates allow member 
functions of certain classes to be used as callbacks, which will hopefully 
be the beginning of the end of fetching the driver_data field in most 
callbacks. All classes that host delegates must derive from bindable_object.
Today, all devices and driver_data do implicitly via their base class.

Defined delegates for read/write handlers. The new delegates are always
passed an address_space reference, along with offset, data, and mask. Delegates
can refer to methods either in the driver_data class or in a device class.
To specify a callback in an address map, just use AM_READ_MEMBER(class, member).
In fact, all existing AM_ macros that take read/write handlers can now accept
delegates in their place. Delegates that are specified in an address map are
proto-delegates which have no object; they are bound to their object when
the corresponding address_space is created.

Added machine->m_nonspecific_space which can be passed as the required
address_space parameter to the new read/write methods in legacy situations 
where the space is not provided. Eventually this can go away but we will
need it for a while yet.

Added methods to the new address_space class to dynamically install delegates
just like you can dynamically install handlers today. Delegates installed this
way must be pre-bound to their object.

Moved beathead's read/write handlers into members of beathead_state as an
example of using the new delegates. This provides examples of both static (via
an address_map) and dynamic (via install_handler calls) mapping using delegates.

Added read/write member functions to okim6295_device as an example of using
delegates to call devices. Updated audio/williams.c as a single example of
calling the device via its member function callbacks. These will be bulk
updated in a future update, and the old global callbacks removed.

Changed the DIRECT_UPDATE_CALLBACKs into delegates as well. Updated all users
to the new function format. Added methods on direct_read_data for configuring the
parameters in a standard way to make the implementation clearer.

Created a simple_list template container class for managing the common
singly-linked lists we use all over in the project.

Many other internal changes in memory.c, mostly involving restructuring the code
into proper classes.

.gitattributes

@@ -575,6 +575,8 @@ src/emu/debugger.c svneol=native#text/plain
 src/emu/debugger.h svneol=native#text/plain
 src/emu/debugint/debugint.c svneol=native#text/plain
 src/emu/debugint/debugint.h svneol=native#text/plain
+src/emu/delegate.c svneol=native#text/plain
+src/emu/delegate.h svneol=native#text/plain
 src/emu/deprecat.h svneol=native#text/plain
 src/emu/devcb.c svneol=native#text/plain
 src/emu/devcb.h svneol=native#text/plain

src/emu/addrmap.c

@@ -41,31 +41,22 @@
 
 
 //**************************************************************************
-//  MACROS
+//  ADDRESS MAP ENTRY
 //**************************************************************************
 
-// maps a full 64-bit mask down to an 8-bit byte mask
+//-------------------------------------------------
-#define UNITMASK8(x) \
+//  set_tag - set the appropriate tag for a device
-	((((UINT64)(x) >> (63-7)) & 0x80) | \
+//-------------------------------------------------
-	 (((UINT64)(x) >> (55-6)) & 0x40) | \
-	 (((UINT64)(x) >> (47-5)) & 0x20) | \
-	 (((UINT64)(x) >> (39-4)) & 0x10) | \
-	 (((UINT64)(x) >> (31-3)) & 0x08) | \
-	 (((UINT64)(x) >> (23-2)) & 0x04) | \
-	 (((UINT64)(x) >> (15-1)) & 0x02) | \
-	 (((UINT64)(x) >> ( 7-0)) & 0x01))
 
-// maps a full 64-bit mask down to a 4-bit word mask
+inline void map_handler_data::set_tag(const device_config &devconfig, const char *tag)
-#define UNITMASK16(x) \
+{
-	((((UINT64)(x) >> (63-3)) & 0x08) | \
+	if (tag == NULL)
-	 (((UINT64)(x) >> (47-2)) & 0x04) | \
+		m_tag = NULL;
-	 (((UINT64)(x) >> (31-1)) & 0x02) | \
+	else if (strcmp(tag, DEVICE_SELF) == 0)
-	 (((UINT64)(x) >> (15-0)) & 0x01))
+		m_tag = devconfig.tag();
-
+	else
-// maps a full 64-bit mask down to a 2-bit dword mask
+		m_tag = devconfig.siblingtag(m_derived_tag, tag);
-#define UNITMASK32(x) \
+}
-	((((UINT64)(x) >> (63-1)) & 0x02) | \
-	 (((UINT64)(x) >> (31-0)) & 0x01))
 
 
 
@@ -93,6 +84,22 @@ address_map_entry::address_map_entry(address_map &map, offs_t start, offs_t end)
 	  m_gensizeptroffs_plus1(0),
 	  m_region(NULL),
 	  m_rgnoffs(0),
+	  m_rspace8(NULL),
+	  m_rspace16(NULL),
+	  m_rspace32(NULL),
+	  m_rspace64(NULL),
+	  m_rdevice8(NULL),
+	  m_rdevice16(NULL),
+	  m_rdevice32(NULL),
+	  m_rdevice64(NULL),
+	  m_wspace8(NULL),
+	  m_wspace16(NULL),
+	  m_wspace32(NULL),
+	  m_wspace64(NULL),
+	  m_wdevice8(NULL),
+	  m_wdevice16(NULL),
+	  m_wdevice32(NULL),
+	  m_wdevice64(NULL),
 	  m_memory(NULL),
 	  m_bytestart(0),
 	  m_byteend(0),
@@ -121,8 +128,8 @@ void address_map_entry::set_mask(offs_t _mask)
 
 void address_map_entry::set_read_port(const device_config &devconfig, const char *tag)
 {
-	m_read.type = AMH_PORT;
+	m_read.m_type = AMH_PORT;
-	m_read.tag = devconfig.siblingtag(m_read.derived_tag, tag);
+	m_read.set_tag(devconfig, tag);
 }
 
 
@@ -133,8 +140,8 @@ void address_map_entry::set_read_port(const device_config &devconfig, const char
 
 void address_map_entry::set_write_port(const device_config &devconfig, const char *tag)
 {
-	m_write.type = AMH_PORT;
+	m_write.m_type = AMH_PORT;
-	m_write.tag = devconfig.siblingtag(m_write.derived_tag, tag);
+	m_write.set_tag(devconfig, tag);
 }
 
 
@@ -145,10 +152,10 @@ void address_map_entry::set_write_port(const device_config &devconfig, const cha
 
 void address_map_entry::set_readwrite_port(const device_config &devconfig, const char *tag)
 {
-	m_read.type = AMH_PORT;
+	m_read.m_type = AMH_PORT;
-	m_read.tag = devconfig.siblingtag(m_read.derived_tag, tag);
+	m_read.set_tag(devconfig, tag);
-	m_write.type = AMH_PORT;
+	m_write.m_type = AMH_PORT;
-	m_write.tag = devconfig.siblingtag(m_write.derived_tag, tag);
+	m_write.set_tag(devconfig, tag);
 }
 
 
@@ -159,8 +166,8 @@ void address_map_entry::set_readwrite_port(const device_config &devconfig, const
 
 void address_map_entry::set_read_bank(const device_config &devconfig, const char *tag)
 {
-	m_read.type = AMH_BANK;
+	m_read.m_type = AMH_BANK;
-	m_read.tag = devconfig.siblingtag(m_read.derived_tag, tag);
+	m_read.set_tag(devconfig, tag);
 }
 
 
@@ -171,8 +178,8 @@ void address_map_entry::set_read_bank(const device_config &devconfig, const char
 
 void address_map_entry::set_write_bank(const device_config &devconfig, const char *tag)
 {
-	m_write.type = AMH_BANK;
+	m_write.m_type = AMH_BANK;
-	m_write.tag = devconfig.siblingtag(m_write.derived_tag, tag);
+	m_write.set_tag(devconfig, tag);
 }
 
 
@@ -183,10 +190,10 @@ void address_map_entry::set_write_bank(const device_config &devconfig, const cha
 
 void address_map_entry::set_readwrite_bank(const device_config &devconfig, const char *tag)
 {
-	m_read.type = AMH_BANK;
+	m_read.m_type = AMH_BANK; 
-	m_read.tag = devconfig.siblingtag(m_read.derived_tag, tag);
+	m_read.set_tag(devconfig, tag);
-	m_write.type = AMH_BANK;
+	m_write.m_type = AMH_BANK; 
-	m_write.tag = devconfig.siblingtag(m_write.derived_tag, tag);
+	m_write.set_tag(devconfig, tag);
 }
 
 
@@ -197,23 +204,25 @@ void address_map_entry::set_readwrite_bank(const device_config &devconfig, const
 
 void address_map_entry::internal_set_handler(read8_space_func func, const char *string, UINT64 unitmask)
 {
+	assert(func != NULL);
 	assert(unitmask_is_appropriate(8, unitmask, string));
-	m_read.type = AMH_HANDLER;
+	m_read.m_type = AMH_LEGACY_SPACE_HANDLER;
-	m_read.bits = (unitmask == 0) ? 0 : 8;
+	m_read.m_bits = 8;
-	m_read.mask = UNITMASK8(unitmask);
+	m_read.m_mask = unitmask;
-	m_read.handler.read.shandler8 = func;
+	m_read.m_name = string;
-	m_read.name = string;
+	m_rspace8 = func;
 }
 
 
 void address_map_entry::internal_set_handler(write8_space_func func, const char *string, UINT64 unitmask)
 {
+	assert(func != NULL);
 	assert(unitmask_is_appropriate(8, unitmask, string));
-	m_write.type = AMH_HANDLER;
+	m_write.m_type = AMH_LEGACY_SPACE_HANDLER;
-	m_write.bits = (unitmask == 0) ? 0 : 8;
+	m_write.m_bits = 8;
-	m_write.mask = UNITMASK8(unitmask);
+	m_write.m_mask = unitmask;
-	m_write.handler.write.shandler8 = func;
+	m_write.m_name = string;
-	m_write.name = string;
+	m_wspace8 = func;
 }
 
 
@@ -226,25 +235,27 @@ void address_map_entry::internal_set_handler(read8_space_func rfunc, const char
 
 void address_map_entry::internal_set_handler(const device_config &devconfig, const char *tag, read8_device_func func, const char *string, UINT64 unitmask)
 {
+	assert(func != NULL);
 	assert(unitmask_is_appropriate(8, unitmask, string));
-	m_read.type = AMH_DEVICE_HANDLER;
+	m_read.m_type = AMH_LEGACY_DEVICE_HANDLER;
-	m_read.bits = (unitmask == 0) ? 0 : 8;
+	m_read.m_bits = 8;
-	m_read.mask = UNITMASK8(unitmask);
+	m_read.m_mask = unitmask;
-	m_read.handler.read.dhandler8 = func;
+	m_read.m_name = string;
-	m_read.name = string;
+	m_read.set_tag(devconfig, tag);
-	m_read.tag = devconfig.siblingtag(m_read.derived_tag, tag);
+	m_rdevice8 = func;
 }
 
 
 void address_map_entry::internal_set_handler(const device_config &devconfig, const char *tag, write8_device_func func, const char *string, UINT64 unitmask)
 {
+	assert(func != NULL);
 	assert(unitmask_is_appropriate(8, unitmask, string));
-	m_write.type = AMH_DEVICE_HANDLER;
+	m_write.m_type = AMH_LEGACY_DEVICE_HANDLER;
-	m_write.bits = (unitmask == 0) ? 0 : 8;
+	m_write.m_bits = 8;
-	m_write.mask = UNITMASK8(unitmask);
+	m_write.m_mask = unitmask;
-	m_write.handler.write.dhandler8 = func;
+	m_write.m_name = string;
-	m_write.name = string;
+	m_write.set_tag(devconfig, tag);
-	m_write.tag = devconfig.siblingtag(m_write.derived_tag, tag);
+	m_wdevice8 = func;
 }
 
 
@@ -255,6 +266,39 @@ void address_map_entry::internal_set_handler(const device_config &devconfig, con
 }
 
 
+void address_map_entry::internal_set_handler(const device_config &devconfig, const char *tag, read8_proto_delegate func, UINT64 unitmask)
+{
+	assert(!func.isnull());
+	assert(unitmask_is_appropriate(8, unitmask, func.name()));
+	m_read.m_type = (tag == NULL) ? AMH_DRIVER_DELEGATE : AMH_DEVICE_DELEGATE;
+	m_read.m_bits = 8;
+	m_read.m_mask = unitmask;
+	m_read.m_name = func.name();
+	m_read.set_tag(devconfig, tag);
+	m_rproto8 = func;
+}
+
+
+void address_map_entry::internal_set_handler(const device_config &devconfig, const char *tag, write8_proto_delegate func, UINT64 unitmask)
+{
+	assert(!func.isnull());
+	assert(unitmask_is_appropriate(8, unitmask, func.name()));
+	m_write.m_type = (tag == NULL) ? AMH_DRIVER_DELEGATE : AMH_DEVICE_DELEGATE;;
+	m_write.m_bits = 8;
+	m_write.m_mask = unitmask;
+	m_write.m_name = func.name();
+	m_write.set_tag(devconfig, tag);
+	m_wproto8 = func;
+}
+
+
+void address_map_entry::internal_set_handler(const device_config &devconfig, const char *tag, read8_proto_delegate rfunc, write8_proto_delegate wfunc, UINT64 unitmask)
+{
+	internal_set_handler(devconfig, tag, rfunc, unitmask);
+	internal_set_handler(devconfig, tag, wfunc, unitmask);
+}
+
+
 //-------------------------------------------------
 //  internal_set_handler - handler setters for
 //  16-bit read/write handlers
@@ -262,23 +306,25 @@ void address_map_entry::internal_set_handler(const device_config &devconfig, con
 
 void address_map_entry::internal_set_handler(read16_space_func func, const char *string, UINT64 unitmask)
 {
+	assert(func != NULL);
 	assert(unitmask_is_appropriate(16, unitmask, string));
-	m_read.type = AMH_HANDLER;
+	m_read.m_type = AMH_LEGACY_SPACE_HANDLER;
-	m_read.bits = (unitmask == 0) ? 0 : 16;
+	m_read.m_bits = 16;
-	m_read.mask = UNITMASK16(unitmask);
+	m_read.m_mask = unitmask;
-	m_read.handler.read.shandler16 = func;
+	m_read.m_name = string;
-	m_read.name = string;
+	m_rspace16 = func;
 }
 
 
 void address_map_entry::internal_set_handler(write16_space_func func, const char *string, UINT64 unitmask)
 {
+	assert(func != NULL);
 	assert(unitmask_is_appropriate(16, unitmask, string));
-	m_write.type = AMH_HANDLER;
+	m_write.m_type = AMH_LEGACY_SPACE_HANDLER;
-	m_write.bits = (unitmask == 0) ? 0 : 16;
+	m_write.m_bits = 16;
-	m_write.mask = UNITMASK16(unitmask);
+	m_write.m_mask = unitmask;
-	m_write.handler.write.shandler16 = func;
+	m_write.m_name = string;
-	m_write.name = string;
+	m_wspace16 = func;
 }
 
 
@@ -291,25 +337,27 @@ void address_map_entry::internal_set_handler(read16_space_func rfunc, const char
 
 void address_map_entry::internal_set_handler(const device_config &devconfig, const char *tag, read16_device_func func, const char *string, UINT64 unitmask)
 {
+	assert(func != NULL);
 	assert(unitmask_is_appropriate(16, unitmask, string));
-	m_read.type = AMH_DEVICE_HANDLER;
+	m_read.m_type = AMH_LEGACY_DEVICE_HANDLER;
-	m_read.bits = (unitmask == 0) ? 0 : 16;
+	m_read.m_bits = 16;
-	m_read.mask = UNITMASK16(unitmask);
+	m_read.m_mask = unitmask;
-	m_read.handler.read.dhandler16 = func;
+	m_read.m_name = string;
-	m_read.name = string;
+	m_read.set_tag(devconfig, tag);
-	m_read.tag = devconfig.siblingtag(m_read.derived_tag, tag);
+	m_rdevice16 = func;
 }
 
 
 void address_map_entry::internal_set_handler(const device_config &devconfig, const char *tag, write16_device_func func, const char *string, UINT64 unitmask)
 {
+	assert(func != NULL);
 	assert(unitmask_is_appropriate(16, unitmask, string));
-	m_write.type = AMH_DEVICE_HANDLER;
+	m_write.m_type = AMH_LEGACY_DEVICE_HANDLER;
-	m_write.bits = (unitmask == 0) ? 0 : 16;
+	m_write.m_bits = 16;
-	m_write.mask = UNITMASK16(unitmask);
+	m_write.m_mask = unitmask;
-	m_write.handler.write.dhandler16 = func;
+	m_write.m_name = string;
-	m_write.name = string;
+	m_write.set_tag(devconfig, tag);
-	m_write.tag = devconfig.siblingtag(m_write.derived_tag, tag);
+	m_wdevice16 = func;
 }
 
 
@@ -320,6 +368,39 @@ void address_map_entry::internal_set_handler(const device_config &devconfig, con
 }
 
 
+void address_map_entry::internal_set_handler(const device_config &devconfig, const char *tag, read16_proto_delegate func, UINT64 unitmask)
+{
+	assert(!func.isnull());
+	assert(unitmask_is_appropriate(16, unitmask, func.name()));
+	m_read.m_type = (tag == NULL) ? AMH_DRIVER_DELEGATE : AMH_DEVICE_DELEGATE;;
+	m_read.m_bits = 16;
+	m_read.m_mask = unitmask;
+	m_read.m_name = func.name();
+	m_read.set_tag(devconfig, tag);
+	m_rproto16 = func;
+}
+
+
+void address_map_entry::internal_set_handler(const device_config &devconfig, const char *tag, write16_proto_delegate func, UINT64 unitmask)
+{
+	assert(!func.isnull());
+	assert(unitmask_is_appropriate(16, unitmask, func.name()));
+	m_write.m_type = (tag == NULL) ? AMH_DRIVER_DELEGATE : AMH_DEVICE_DELEGATE;;
+	m_write.m_bits = 16;
+	m_write.m_mask = unitmask;
+	m_write.m_name = func.name();
+	m_write.set_tag(devconfig, tag);
+	m_wproto16 = func;
+}
+
+
+void address_map_entry::internal_set_handler(const device_config &devconfig, const char *tag, read16_proto_delegate rfunc, write16_proto_delegate wfunc, UINT64 unitmask)
+{
+	internal_set_handler(devconfig, tag, rfunc, unitmask);
+	internal_set_handler(devconfig, tag, wfunc, unitmask);
+}
+
+
 //-------------------------------------------------
 //  internal_set_handler - handler setters for
 //  32-bit read/write handlers
@@ -327,23 +408,25 @@ void address_map_entry::internal_set_handler(const device_config &devconfig, con
 
 void address_map_entry::internal_set_handler(read32_space_func func, const char *string, UINT64 unitmask)
 {
+	assert(func != NULL);
 	assert(unitmask_is_appropriate(32, unitmask, string));
-	m_read.type = AMH_HANDLER;
+	m_read.m_type = AMH_LEGACY_SPACE_HANDLER;
-	m_read.bits = (unitmask == 0) ? 0 : 32;
+	m_read.m_bits = 32;
-	m_read.mask = UNITMASK32(unitmask);
+	m_read.m_mask = unitmask;
-	m_read.handler.read.shandler32 = func;
+	m_read.m_name = string;
-	m_read.name = string;
+	m_rspace32 = func;
 }
 
 
 void address_map_entry::internal_set_handler(write32_space_func func, const char *string, UINT64 unitmask)
 {
+	assert(func != NULL);
 	assert(unitmask_is_appropriate(32, unitmask, string));
-	m_write.type = AMH_HANDLER;
+	m_write.m_type = AMH_LEGACY_SPACE_HANDLER;
-	m_write.bits = (unitmask == 0) ? 0 : 32;
+	m_write.m_bits = 32;
-	m_write.mask = UNITMASK32(unitmask);
+	m_write.m_mask = unitmask;
-	m_write.handler.write.shandler32 = func;
+	m_write.m_name = string;
-	m_write.name = string;
+	m_wspace32 = func;
 }
 
 
@@ -356,25 +439,27 @@ void address_map_entry::internal_set_handler(read32_space_func rfunc, const char
 
 void address_map_entry::internal_set_handler(const device_config &devconfig, const char *tag, read32_device_func func, const char *string, UINT64 unitmask)
 {
+	assert(func != NULL);
 	assert(unitmask_is_appropriate(32, unitmask, string));
-	m_read.type = AMH_DEVICE_HANDLER;
+	m_read.m_type = AMH_LEGACY_DEVICE_HANDLER;
-	m_read.bits = (unitmask == 0) ? 0 : 32;
+	m_read.m_bits = 32;
-	m_read.mask = UNITMASK32(unitmask);
+	m_read.m_mask = unitmask;
-	m_read.handler.read.dhandler32 = func;
+	m_read.m_name = string;
-	m_read.name = string;
+	m_read.set_tag(devconfig, tag);
-	m_read.tag = devconfig.siblingtag(m_read.derived_tag, tag);
+	m_rdevice32 = func;
 }
 
 
 void address_map_entry::internal_set_handler(const device_config &devconfig, const char *tag, write32_device_func func, const char *string, UINT64 unitmask)
 {
+	assert(func != NULL);
 	assert(unitmask_is_appropriate(32, unitmask, string));
-	m_write.type = AMH_DEVICE_HANDLER;
+	m_write.m_type = AMH_LEGACY_DEVICE_HANDLER;
-	m_write.bits = (unitmask == 0) ? 0 : 32;
+	m_write.m_bits = 32;
-	m_write.mask = UNITMASK32(unitmask);
+	m_write.m_mask = unitmask;
-	m_write.handler.write.dhandler32 = func;
+	m_write.m_name = string;
-	m_write.name = string;
+	m_write.set_tag(devconfig, tag);
-	m_write.tag = devconfig.siblingtag(m_write.derived_tag, tag);
+	m_wdevice32 = func;
 }
 
 
@@ -385,6 +470,39 @@ void address_map_entry::internal_set_handler(const device_config &devconfig, con
 }
 
 
+void address_map_entry::internal_set_handler(const device_config &devconfig, const char *tag, read32_proto_delegate func, UINT64 unitmask)
+{
+	assert(!func.isnull());
+	assert(unitmask_is_appropriate(32, unitmask, func.name()));
+	m_read.m_type = (tag == NULL) ? AMH_DRIVER_DELEGATE : AMH_DEVICE_DELEGATE;;
+	m_read.m_bits = 32;
+	m_read.m_mask = unitmask;
+	m_read.m_name = func.name();
+	m_read.set_tag(devconfig, tag);
+	m_rproto32 = func;
+}
+
+
+void address_map_entry::internal_set_handler(const device_config &devconfig, const char *tag, write32_proto_delegate func, UINT64 unitmask)
+{
+	assert(!func.isnull());
+	assert(unitmask_is_appropriate(32, unitmask, func.name()));
+	m_write.m_type = (tag == NULL) ? AMH_DRIVER_DELEGATE : AMH_DEVICE_DELEGATE;;
+	m_write.m_bits = 32;
+	m_write.m_mask = unitmask;
+	m_write.m_name = func.name();
+	m_write.set_tag(devconfig, tag);
+	m_wproto32 = func;
+}
+
+
+void address_map_entry::internal_set_handler(const device_config &devconfig, const char *tag, read32_proto_delegate rfunc, write32_proto_delegate wfunc, UINT64 unitmask)
+{
+	internal_set_handler(devconfig, tag, rfunc, unitmask);
+	internal_set_handler(devconfig, tag, wfunc, unitmask);
+}
+
+
 //-------------------------------------------------
 //  internal_set_handler - handler setters for
 //  64-bit read/write handlers
@@ -392,23 +510,25 @@ void address_map_entry::internal_set_handler(const device_config &devconfig, con
 
 void address_map_entry::internal_set_handler(read64_space_func func, const char *string, UINT64 unitmask)
 {
+	assert(func != NULL);
 	assert(unitmask_is_appropriate(64, unitmask, string));
-	m_read.type = AMH_HANDLER;
+	m_read.m_type = AMH_LEGACY_SPACE_HANDLER;
-	m_read.bits = (unitmask == 0) ? 0 : 64;
+	m_read.m_bits = 64;
-	m_read.mask = 0;
+	m_read.m_mask = 0;
-	m_read.handler.read.shandler64 = func;
+	m_read.m_name = string;
-	m_read.name = string;
+	m_rspace64 = func;
 }
 
 
 void address_map_entry::internal_set_handler(write64_space_func func, const char *string, UINT64 unitmask)
 {
+	assert(func != NULL);
 	assert(unitmask_is_appropriate(64, unitmask, string));
-	m_write.type = AMH_HANDLER;
+	m_write.m_type = AMH_LEGACY_SPACE_HANDLER;
-	m_write.bits = (unitmask == 0) ? 0 : 64;
+	m_write.m_bits = 64;
-	m_write.mask = 0;
+	m_write.m_mask = 0;
-	m_write.handler.write.shandler64 = func;
+	m_write.m_name = string;
-	m_write.name = string;
+	m_wspace64 = func;
 }
 
 
@@ -421,25 +541,27 @@ void address_map_entry::internal_set_handler(read64_space_func rfunc, const char
 
 void address_map_entry::internal_set_handler(const device_config &devconfig, const char *tag, read64_device_func func, const char *string, UINT64 unitmask)
 {
+	assert(func != NULL);
 	assert(unitmask_is_appropriate(64, unitmask, string));
-	m_read.type = AMH_DEVICE_HANDLER;
+	m_read.m_type = AMH_LEGACY_DEVICE_HANDLER;
-	m_read.bits = (unitmask == 0) ? 0 : 64;
+	m_read.m_bits = 64;
-	m_read.mask = 0;
+	m_read.m_mask = 0;
-	m_read.handler.read.dhandler64 = func;
+	m_read.m_name = string;
-	m_read.name = string;
+	m_read.set_tag(devconfig, tag);
-	m_read.tag = devconfig.siblingtag(m_read.derived_tag, tag);
+	m_rdevice64 = func;
 }
 
 
 void address_map_entry::internal_set_handler(const device_config &devconfig, const char *tag, write64_device_func func, const char *string, UINT64 unitmask)
 {
+	assert(func != NULL);
 	assert(unitmask_is_appropriate(64, unitmask, string));
-	m_write.type = AMH_DEVICE_HANDLER;
+	m_write.m_type = AMH_LEGACY_DEVICE_HANDLER;
-	m_write.bits = (unitmask == 0) ? 0 : 64;
+	m_write.m_bits = 64;
-	m_write.mask = 0;
+	m_write.m_mask = 0;
-	m_write.handler.write.dhandler64 = func;
+	m_write.m_name = string;
-	m_write.name = string;
+	m_write.set_tag(devconfig, tag);
-	m_write.tag = devconfig.siblingtag(m_write.derived_tag, tag);
+	m_wdevice64 = func;
 }
 
 
@@ -450,6 +572,39 @@ void address_map_entry::internal_set_handler(const device_config &devconfig, con
 }
 
 
+void address_map_entry::internal_set_handler(const device_config &devconfig, const char *tag, read64_proto_delegate func, UINT64 unitmask)
+{
+	assert(!func.isnull());
+	assert(unitmask_is_appropriate(64, unitmask, func.name()));
+	m_read.m_type = (tag == NULL) ? AMH_DRIVER_DELEGATE : AMH_DEVICE_DELEGATE;;
+	m_read.m_bits = 64;
+	m_read.m_mask = 0;
+	m_read.m_name = func.name();
+	m_read.set_tag(devconfig, tag);
+	m_rproto64 = func;
+}
+
+
+void address_map_entry::internal_set_handler(const device_config &devconfig, const char *tag, write64_proto_delegate func, UINT64 unitmask)
+{
+	assert(!func.isnull());
+	assert(unitmask_is_appropriate(64, unitmask, func.name()));
+	m_write.m_type = (tag == NULL) ? AMH_DRIVER_DELEGATE : AMH_DEVICE_DELEGATE;;
+	m_write.m_bits = 64;
+	m_write.m_mask = 0;
+	m_write.m_name = func.name();
+	m_write.set_tag(devconfig, tag);
+	m_wproto64 = func;
+}
+
+
+void address_map_entry::internal_set_handler(const device_config &devconfig, const char *tag, read64_proto_delegate rfunc, write64_proto_delegate wfunc, UINT64 unitmask)
+{
+	internal_set_handler(devconfig, tag, rfunc, unitmask);
+	internal_set_handler(devconfig, tag, wfunc, unitmask);
+}
+
+
 //-------------------------------------------------
 //  unitmask_is_appropriate - verify that the
 //  provided unitmask is valid and expected
@@ -540,9 +695,7 @@ address_map::address_map(const device_config &devconfig, int spacenum)
 	: m_spacenum(spacenum),
 	  m_databits(0xff),
 	  m_unmapval(0),
-	  m_globalmask(0),
+	  m_globalmask(0)
-	  m_entrylist(NULL),
-	  m_tailptr(&m_entrylist)
 {
 	// get our memory interface
 	const device_config_memory_interface *memintf;
@@ -574,13 +727,6 @@ address_map::address_map(const device_config &devconfig, int spacenum)
 
 address_map::~address_map()
 {
-	// free all entries */
-	while (m_entrylist != NULL)
-	{
-		address_map_entry *entry = m_entrylist;
-		m_entrylist = entry->m_next;
-		global_free(entry);
-	}
 }
 
 
@@ -621,8 +767,7 @@ void address_map::set_global_mask(offs_t mask)
 address_map_entry8 *address_map::add(offs_t start, offs_t end, address_map_entry8 *ptr)
 {
 	ptr = global_alloc(address_map_entry8(*this, start, end));
-	*m_tailptr = ptr;
+	m_entrylist.append(*ptr);
-	m_tailptr = &ptr->m_next;
 	return ptr;
 }
 
@@ -630,8 +775,7 @@ address_map_entry8 *address_map::add(offs_t start, offs_t end, address_map_entry
 address_map_entry16 *address_map::add(offs_t start, offs_t end, address_map_entry16 *ptr)
 {
 	ptr = global_alloc(address_map_entry16(*this, start, end));
-	*m_tailptr = ptr;
+	m_entrylist.append(*ptr);
-	m_tailptr = &ptr->m_next;
 	return ptr;
 }
 
@@ -639,8 +783,7 @@ address_map_entry16 *address_map::add(offs_t start, offs_t end, address_map_entr
 address_map_entry32 *address_map::add(offs_t start, offs_t end, address_map_entry32 *ptr)
 {
 	ptr = global_alloc(address_map_entry32(*this, start, end));
-	*m_tailptr = ptr;
+	m_entrylist.append(*ptr);
-	m_tailptr = &ptr->m_next;
 	return ptr;
 }
 
@@ -648,244 +791,6 @@ address_map_entry32 *address_map::add(offs_t start, offs_t end, address_map_entr
 address_map_entry64 *address_map::add(offs_t start, offs_t end, address_map_entry64 *ptr)
 {
 	ptr = global_alloc(address_map_entry64(*this, start, end));
-	*m_tailptr = ptr;
+	m_entrylist.append(*ptr);
-	m_tailptr = &ptr->m_next;
 	return ptr;
 }
-
-
-
-#if 0
-
-// old code for reference
-
-/***************************************************************************
-    ADDRESS MAP HELPERS
-***************************************************************************/
-
-/*-------------------------------------------------
-    map_detokenize - detokenize an array of
-    address map tokens
--------------------------------------------------*/
-
-#define check_map(field) do { \
-	if (map->field != 0 && map->field != tmap.field) \
-		fatalerror("%s: %s included a mismatched address map (%s %d) for an existing map with %s %d!\n", driver->source_file, driver->name, #field, tmap.field, #field, map->field); \
-	} while (0)
-
-#define check_entry_handler(row) do { \
-	if (entry->row.type != AMH_NONE) \
-		fatalerror("%s: %s AM_RANGE(0x%x, 0x%x) %s handler already set!\n", driver->source_file, driver->name, entry->addrstart, entry->addrend, #row); \
-	} while (0)
-
-#define check_entry_field(field) do { \
-	if (entry->field != 0) \
-		fatalerror("%s: %s AM_RANGE(0x%x, 0x%x) setting %s already set!\n", driver->source_file, driver->name, entry->addrstart, entry->addrend, #field); \
-	} while (0)
-
-static void map_detokenize(memory_private *memdata, address_map *map, const game_driver *driver, const device_config *devconfig, const addrmap_token *tokens)
-{
-	address_map_entry **firstentryptr;
-	address_map_entry **entryptr;
-	address_map_entry *entry;
-	address_map tmap = {0};
-	UINT32 entrytype;
-	int maptype;
-
-	/* check the first token */
-	TOKEN_GET_UINT32_UNPACK3(tokens, entrytype, 8, tmap.spacenum, 8, tmap.databits, 8);
-	if (entrytype != ADDRMAP_TOKEN_START)
-		fatalerror("%s: %s Address map missing ADDRMAP_TOKEN_START!\n", driver->source_file, driver->name);
-	if (tmap.spacenum >= ADDRESS_SPACES)
-		fatalerror("%s: %s Invalid address space %d for memory map!\n", driver->source_file, driver->name, tmap.spacenum);
-	if (tmap.databits != 8 && tmap.databits != 16 && tmap.databits != 32 && tmap.databits != 64)
-		fatalerror("%s: %s Invalid data bits %d for memory map!\n", driver->source_file, driver->name, tmap.databits);
-	check_map(spacenum);
-	check_map(databits);
-
-	/* fill in the map values */
-	map->spacenum = tmap.spacenum;
-	map->databits = tmap.databits;
-
-	/* find the end of the list */
-	for (entryptr = &map->entrylist; *entryptr != NULL; entryptr = &(*entryptr)->next) ;
-	firstentryptr = entryptr;
-	entry = NULL;
-
-	/* loop over tokens until we hit the end */
-	while (entrytype != ADDRMAP_TOKEN_END)
-	{
-		/* unpack the token from the first entry */
-		TOKEN_GET_UINT32_UNPACK1(tokens, entrytype, 8);
-		switch (entrytype)
-		{
-			/* end */
-			case ADDRMAP_TOKEN_END:
-				break;
-
-			/* including */
-			case ADDRMAP_TOKEN_INCLUDE:
-				map_detokenize(memdata, map, driver, devconfig, TOKEN_GET_PTR(tokens, tokenptr));
-				for (entryptr = &map->entrylist; *entryptr != NULL; entryptr = &(*entryptr)->next) ;
-				entry = NULL;
-				break;
-
-			/* global flags */
-			case ADDRMAP_TOKEN_GLOBAL_MASK:
-				TOKEN_UNGET_UINT32(tokens);
-				TOKEN_GET_UINT64_UNPACK2(tokens, entrytype, 8, tmap.globalmask, 32);
-				check_map(globalmask);
-				map->globalmask = tmap.globalmask;
-				break;
-
-			case ADDRMAP_TOKEN_UNMAP_VALUE:
-				TOKEN_UNGET_UINT32(tokens);
-				TOKEN_GET_UINT32_UNPACK2(tokens, entrytype, 8, tmap.unmapval, 1);
-				check_map(unmapval);
-				map->unmapval = tmap.unmapval;
-				break;
-
-			/* start a new range */
-			case ADDRMAP_TOKEN_RANGE:
-				entry = *entryptr = global_alloc_clear(address_map_entry);
-				entryptr = &entry->next;
-				TOKEN_GET_UINT64_UNPACK2(tokens, entry->addrstart, 32, entry->addrend, 32);
-				break;
-
-			case ADDRMAP_TOKEN_MASK:
-				check_entry_field(addrmask);
-				TOKEN_UNGET_UINT32(tokens);
-				TOKEN_GET_UINT64_UNPACK2(tokens, entrytype, 8, entry->addrmask, 32);
-				break;
-
-			case ADDRMAP_TOKEN_MIRROR:
-				check_entry_field(addrmirror);
-				TOKEN_UNGET_UINT32(tokens);
-				TOKEN_GET_UINT64_UNPACK2(tokens, entrytype, 8, entry->addrmirror, 32);
-				if (entry->addrmirror != 0)
-				{
-					entry->addrstart &= ~entry->addrmirror;
-					entry->addrend &= ~entry->addrmirror;
-				}
-				break;
-
-			case ADDRMAP_TOKEN_READ:
-				check_entry_handler(read);
-				TOKEN_UNGET_UINT32(tokens);
-				TOKEN_GET_UINT32_UNPACK4(tokens, entrytype, 8, maptype, 8, entry->read.bits, 8, entry->read.mask, 8);
-				entry->read.type = (map_handler_type)maptype;
-				if (entry->read.type == AMH_HANDLER || entry->read.type == AMH_DEVICE_HANDLER)
-				{
-					entry->read.handler.read = TOKEN_GET_PTR(tokens, read);
-					entry->read.name = TOKEN_GET_STRING(tokens);
-				}
-				if (entry->read.type == AMH_DEVICE_HANDLER || entry->read.type == AMH_PORT || entry->read.type == AMH_BANK)
-					entry->read.tag = devconfig->siblingtag(entry->read.derived_tag, TOKEN_GET_STRING(tokens));
-				break;
-
-			case ADDRMAP_TOKEN_WRITE:
-				check_entry_handler(write);
-				TOKEN_UNGET_UINT32(tokens);
-				TOKEN_GET_UINT32_UNPACK4(tokens, entrytype, 8, maptype, 8, entry->write.bits, 8, entry->write.mask, 8);
-				entry->write.type = (map_handler_type)maptype;
-				if (entry->write.type == AMH_HANDLER || entry->write.type == AMH_DEVICE_HANDLER)
-				{
-					entry->write.handler.write = TOKEN_GET_PTR(tokens, write);
-					entry->write.name = TOKEN_GET_STRING(tokens);
-				}
-				if (entry->write.type == AMH_DEVICE_HANDLER || entry->write.type == AMH_PORT || entry->write.type == AMH_BANK)
-					entry->write.tag = devconfig->siblingtag(entry->write.derived_tag, TOKEN_GET_STRING(tokens));
-				break;
-
-			case ADDRMAP_TOKEN_READWRITE:
-				check_entry_handler(read);
-				check_entry_handler(write);
-				TOKEN_UNGET_UINT32(tokens);
-				TOKEN_GET_UINT32_UNPACK4(tokens, entrytype, 8, maptype, 8, entry->read.bits, 8, entry->read.mask, 8);
-				entry->write.type = entry->read.type = (map_handler_type)maptype;
-				entry->write.bits = entry->read.bits;
-				entry->write.mask = entry->read.mask;
-				if (entry->read.type == AMH_HANDLER || entry->read.type == AMH_DEVICE_HANDLER)
-				{
-					entry->read.handler.read = TOKEN_GET_PTR(tokens, read);
-					entry->read.name = TOKEN_GET_STRING(tokens);
-					entry->write.handler.write = TOKEN_GET_PTR(tokens, write);
-					entry->write.name = TOKEN_GET_STRING(tokens);
-				}
-				if (entry->read.type == AMH_DEVICE_HANDLER || entry->read.type == AMH_PORT || entry->read.type == AMH_BANK)
-				{
-					const char *basetag = TOKEN_GET_STRING(tokens);
-					entry->read.tag = devconfig->siblingtag(entry->read.derived_tag, basetag);
-					entry->write.tag = devconfig->siblingtag(entry->write.derived_tag, basetag);
-				}
-				break;
-
-			case ADDRMAP_TOKEN_REGION:
-				check_entry_field(region);
-				TOKEN_UNGET_UINT32(tokens);
-				TOKEN_GET_UINT64_UNPACK2(tokens, entrytype, 8, entry->rgnoffs, 32);
-				entry->region = devconfig->siblingtag(entry->region_string, TOKEN_GET_STRING(tokens));
-				break;
-
-			case ADDRMAP_TOKEN_SHARE:
-				check_entry_field(share);
-				entry->share = TOKEN_GET_STRING(tokens);
-				if (memdata != NULL)
-					memdata->sharemap.add(entry->share, UNMAPPED_SHARE_PTR, FALSE);
-				break;
-
-			case ADDRMAP_TOKEN_BASEPTR:
-				check_entry_field(baseptr);
-				entry->baseptr = (void **)TOKEN_GET_PTR(tokens, voidptr);
-				break;
-
-			case ADDRMAP_TOKEN_BASE_MEMBER:
-				check_entry_field(baseptroffs_plus1);
-				TOKEN_UNGET_UINT32(tokens);
-				TOKEN_GET_UINT32_UNPACK2(tokens, entrytype, 8, entry->baseptroffs_plus1, 24);
-				entry->baseptroffs_plus1++;
-				break;
-
-			case ADDRMAP_TOKEN_BASE_GENERIC:
-				check_entry_field(genbaseptroffs_plus1);
-				TOKEN_UNGET_UINT32(tokens);
-				TOKEN_GET_UINT32_UNPACK2(tokens, entrytype, 8, entry->genbaseptroffs_plus1, 24);
-				entry->genbaseptroffs_plus1++;
-				break;
-
-			case ADDRMAP_TOKEN_SIZEPTR:
-				check_entry_field(sizeptr);
-				entry->sizeptr = TOKEN_GET_PTR(tokens, sizeptr);
-				break;
-
-			case ADDRMAP_TOKEN_SIZE_MEMBER:
-				check_entry_field(sizeptroffs_plus1);
-				TOKEN_UNGET_UINT32(tokens);
-				TOKEN_GET_UINT32_UNPACK2(tokens, entrytype, 8, entry->sizeptroffs_plus1, 24);
-				entry->sizeptroffs_plus1++;
-				break;
-
-			case ADDRMAP_TOKEN_SIZE_GENERIC:
-				check_entry_field(gensizeptroffs_plus1);
-				TOKEN_UNGET_UINT32(tokens);
-				TOKEN_GET_UINT32_UNPACK2(tokens, entrytype, 8, entry->gensizeptroffs_plus1, 24);
-				entry->gensizeptroffs_plus1++;
-				break;
-
-			default:
-				fatalerror("Invalid token %d in address map\n", entrytype);
-				break;
-		}
-	}
-
-	/* post-process to apply the global mask */
-	if (map->globalmask != 0)
-		for (entry = map->entrylist; entry != NULL; entry = entry->next)
-		{
-			entry->addrstart &= map->globalmask;
-			entry->addrend &= map->globalmask;
-			entry->addrmask &= map->globalmask;
-		}
-}
-
-#endif

src/emu/addrmap.h

@@ -60,8 +60,10 @@ enum map_handler_type
 	AMH_ROM,
 	AMH_NOP,
 	AMH_UNMAP,
-	AMH_HANDLER,
+	AMH_DRIVER_DELEGATE,
-	AMH_DEVICE_HANDLER,
+	AMH_DEVICE_DELEGATE,
+	AMH_LEGACY_SPACE_HANDLER,
+	AMH_LEGACY_DEVICE_HANDLER,
 	AMH_PORT,
 	AMH_BANK
 };
@@ -72,67 +74,25 @@ enum map_handler_type
 //  TYPE DEFINITIONS
 //**************************************************************************
 
-// address map constructors are functions generated by tokens
-typedef void (*address_map_constructor)(address_map &map, const device_config &devconfig);
-
-
-// read_handler is a union of all the different read handler types
-union read_handler
-{
-	genf *					generic;			// generic function pointer
-	read8_space_func		shandler8;			// 8-bit space read handler
-	read16_space_func		shandler16;			// 16-bit space read handler
-	read32_space_func		shandler32;			// 32-bit space read handler
-	read64_space_func		shandler64;			// 64-bit space read handler
-	read8_device_func		dhandler8;			// 8-bit device read handler
-	read16_device_func		dhandler16;			// 16-bit device read handler
-	read32_device_func		dhandler32;			// 32-bit device read handler
-	read64_device_func		dhandler64;			// 64-bit device read handler
-};
-
-
-// write_handler is a union of all the different write handler types
-union write_handler
-{
-	genf *					generic;			// generic function pointer
-	write8_space_func		shandler8;			// 8-bit space write handler
-	write16_space_func		shandler16;			// 16-bit space write handler
-	write32_space_func		shandler32;			// 32-bit space write handler
-	write64_space_func		shandler64;			// 64-bit space write handler
-	write8_device_func		dhandler8;			// 8-bit device write handler
-	write16_device_func		dhandler16;			// 16-bit device write handler
-	write32_device_func		dhandler32;			// 32-bit device write handler
-	write64_device_func		dhandler64;			// 64-bit device write handler
-};
-
-
-// memory_handler is a union of all read and write handler types
-union memory_handler
-{
-	genf *					generic;			// generic function pointer
-	read_handler			read;				// read handler union
-	write_handler			write;				// write handler union
-};
-
-
 // address map handler data
 class map_handler_data
 {
 public:
 	map_handler_data()
-		: type(AMH_NONE),
+		: m_type(AMH_NONE),
-		  bits(0),
+		  m_bits(0),
-		  mask(0),
+		  m_mask(0),
-		  name(NULL),
+		  m_name(NULL),
-		  tag(NULL) { handler.generic = NULL; }
+		  m_tag(NULL) { }
 
-	map_handler_type		type;				// type of the handler
+	map_handler_type		m_type;				// type of the handler
-	UINT8					bits;				// width of the handler in bits, or 0 for default
+	UINT8					m_bits;				// width of the handler in bits, or 0 for default
-	UINT8					mask;				// mask for which lanes apply
+	UINT64					m_mask;				// mask for which lanes apply
-	memory_handler			handler;			// a memory handler
+	const char *			m_name;				// name of the handler
-	const char *			name;				// name of the handler
+	const char *			m_tag;				// tag pointing to a reference
-	const char *			tag;				// tag pointing to a reference
+	astring					m_derived_tag;		// string used to hold derived names
-	astring					derived_tag;		// string used to hold derived names
+
+	void set_tag(const device_config &devconfig, const char *tag);
 };
 
 
@@ -145,11 +105,14 @@ class address_map_entry
 public:
 	// construction/destruction
 	address_map_entry(address_map &map, offs_t start, offs_t end);
+	
+	// getters
+	address_map_entry *next() const { return m_next; }
 
 	// simple inline setters
 	void set_mirror(offs_t _mirror) { m_addrmirror = _mirror; }
-	void set_read_type(map_handler_type _type) { m_read.type = _type; }
+	void set_read_type(map_handler_type _type) { m_read.m_type = _type; }
-	void set_write_type(map_handler_type _type) { m_write.type = _type; }
+	void set_write_type(map_handler_type _type) { m_write.m_type = _type; }
 	void set_region(const char *tag, offs_t offset) { m_region = tag; m_rgnoffs = offset; }
 	void set_share(const char *tag) { m_share = tag; }
 	void set_sizeptr(size_t *_sizeptr) { m_sizeptr = _sizeptr; }
@@ -172,31 +135,59 @@ public:
 	void set_readwrite_bank(const device_config &devconfig, const char *tag);
 
 	// public state
-	address_map_entry *	m_next;					// pointer to the next entry
+	address_map_entry *		m_next;					// pointer to the next entry
-	address_map &		m_map;					// reference to our owning map
+	address_map &			m_map;					// reference to our owning map
-	astring				m_region_string;		// string used to hold derived names
+	astring					m_region_string;		// string used to hold derived names
 
-	offs_t				m_addrstart;			// start address
+	// basic information
-	offs_t				m_addrend;				// end address
+	offs_t					m_addrstart;			// start address
-	offs_t				m_addrmirror;			// mirror bits
+	offs_t					m_addrend;				// end address
-	offs_t				m_addrmask;				// mask bits
+	offs_t					m_addrmirror;			// mirror bits
-	map_handler_data	m_read;					// data for read handler
+	offs_t					m_addrmask;				// mask bits
-	map_handler_data	m_write;				// data for write handler
+	map_handler_data		m_read;					// data for read handler
-	const char *		m_share;				// tag of a shared memory block
+	map_handler_data		m_write;				// data for write handler
-	void **				m_baseptr;				// receives pointer to memory (optional)
+	const char *			m_share;				// tag of a shared memory block
-	size_t *			m_sizeptr;				// receives size of area in bytes (optional)
+	void **					m_baseptr;				// receives pointer to memory (optional)
-	UINT32				m_baseptroffs_plus1;	// offset of base pointer within driver_data, plus 1
+	size_t *				m_sizeptr;				// receives size of area in bytes (optional)
-	UINT32				m_sizeptroffs_plus1;	// offset of size pointer within driver_data, plus 1
+	UINT32					m_baseptroffs_plus1;	// offset of base pointer within driver_data, plus 1
-	UINT32				m_genbaseptroffs_plus1;	// offset of base pointer within generic_pointers, plus 1
+	UINT32					m_sizeptroffs_plus1;	// offset of size pointer within driver_data, plus 1
-	UINT32				m_gensizeptroffs_plus1;	// offset of size pointer within generic_pointers, plus 1
+	UINT32					m_genbaseptroffs_plus1;	// offset of base pointer within generic_pointers, plus 1
-	const char *		m_region;				// tag of region containing the memory backing this entry
+	UINT32					m_gensizeptroffs_plus1;	// offset of size pointer within generic_pointers, plus 1
-	offs_t				m_rgnoffs;				// offset within the region
+	const char *			m_region;				// tag of region containing the memory backing this entry
+	offs_t					m_rgnoffs;				// offset within the region
 
-	void *				m_memory;				// pointer to memory backing this entry
+	// handlers
-	offs_t				m_bytestart;			// byte-adjusted start address
+	read8_proto_delegate	m_rproto8;				// 8-bit read proto-delegate
-	offs_t				m_byteend;				// byte-adjusted end address
+	read16_proto_delegate	m_rproto16;				// 16-bit read proto-delegate
-	offs_t				m_bytemirror;			// byte-adjusted mirror bits
+	read32_proto_delegate	m_rproto32;				// 32-bit read proto-delegate
-	offs_t				m_bytemask;				// byte-adjusted mask bits
+	read64_proto_delegate	m_rproto64;				// 64-bit read proto-delegate
+	read8_space_func		m_rspace8;				// 8-bit legacy address space handler
+	read16_space_func		m_rspace16;				// 16-bit legacy address space handler
+	read32_space_func		m_rspace32;				// 32-bit legacy address space handler
+	read64_space_func		m_rspace64;				// 64-bit legacy address space handler
+	read8_device_func		m_rdevice8;				// 8-bit legacy device handler
+	read16_device_func		m_rdevice16;			// 16-bit legacy device handler
+	read32_device_func		m_rdevice32;			// 32-bit legacy device handler
+	read64_device_func		m_rdevice64;			// 64-bit legacy device handler
+	write8_proto_delegate	m_wproto8;				// 8-bit write proto-delegate
+	write16_proto_delegate	m_wproto16;				// 16-bit write proto-delegate
+	write32_proto_delegate	m_wproto32;				// 32-bit write proto-delegate
+	write64_proto_delegate	m_wproto64;				// 64-bit write proto-delegate
+	write8_space_func		m_wspace8;				// 8-bit legacy address space handler
+	write16_space_func		m_wspace16;				// 16-bit legacy address space handler
+	write32_space_func		m_wspace32;				// 32-bit legacy address space handler
+	write64_space_func		m_wspace64;				// 64-bit legacy address space handler
+	write8_device_func		m_wdevice8;				// 8-bit legacy device handler
+	write16_device_func		m_wdevice16;			// 16-bit legacy device handler
+	write32_device_func		m_wdevice32;			// 32-bit legacy device handler
+	write64_device_func		m_wdevice64;			// 64-bit legacy device handler
+
+	// information used during processing
+	void *					m_memory;				// pointer to memory backing this entry
+	offs_t					m_bytestart;			// byte-adjusted start address
+	offs_t					m_byteend;				// byte-adjusted end address
+	offs_t					m_bytemirror;			// byte-adjusted mirror bits
+	offs_t					m_bytemask;				// byte-adjusted mask bits
 
 protected:
 	// internal base pointer setting (derived classes provide typed versions)
@@ -205,10 +196,13 @@ protected:
 	// internal handler setters for 8-bit functions
 	void internal_set_handler(read8_space_func func, const char *string, UINT64 mask);
 	void internal_set_handler(write8_space_func func, const char *string, UINT64 mask);
-	void internal_set_handler(read8_space_func rfunc, const char *rstring,write8_space_func wfunc,  const char *wstring, UINT64 mask);
+	void internal_set_handler(read8_space_func rfunc, const char *rstring, write8_space_func wfunc,  const char *wstring, UINT64 mask);
 	void internal_set_handler(const device_config &devconfig, const char *tag, read8_device_func func, const char *string, UINT64 mask);
 	void internal_set_handler(const device_config &devconfig, const char *tag, write8_device_func func, const char *string, UINT64 mask);
 	void internal_set_handler(const device_config &devconfig, const char *tag, read8_device_func rfunc, const char *rstring, write8_device_func wfunc, const char *wstring, UINT64 mask);
+	void internal_set_handler(const device_config &devconfig, const char *tag, read8_proto_delegate func, UINT64 mask);
+	void internal_set_handler(const device_config &devconfig, const char *tag, write8_proto_delegate func, UINT64 mask);
+	void internal_set_handler(const device_config &devconfig, const char *tag, read8_proto_delegate rfunc, write8_proto_delegate wfunc, UINT64 mask);
 
 	// internal handler setters for 16-bit functions
 	void internal_set_handler(read16_space_func func, const char *string, UINT64 mask);
@@ -217,6 +211,9 @@ protected:
 	void internal_set_handler(const device_config &devconfig, const char *tag, read16_device_func func, const char *string, UINT64 mask);
 	void internal_set_handler(const device_config &devconfig, const char *tag, write16_device_func func, const char *string, UINT64 mask);
 	void internal_set_handler(const device_config &devconfig, const char *tag, read16_device_func rfunc, const char *rstring, write16_device_func wfunc, const char *wstring, UINT64 mask);
+	void internal_set_handler(const device_config &devconfig, const char *tag, read16_proto_delegate func, UINT64 mask);
+	void internal_set_handler(const device_config &devconfig, const char *tag, write16_proto_delegate func, UINT64 mask);
+	void internal_set_handler(const device_config &devconfig, const char *tag, read16_proto_delegate rfunc, write16_proto_delegate wfunc, UINT64 mask);
 
 	// internal handler setters for 32-bit functions
 	void internal_set_handler(read32_space_func func, const char *string, UINT64 mask);
@@ -225,6 +222,9 @@ protected:
 	void internal_set_handler(const device_config &devconfig, const char *tag, read32_device_func func, const char *string, UINT64 mask);
 	void internal_set_handler(const device_config &devconfig, const char *tag, write32_device_func func, const char *string, UINT64 mask);
 	void internal_set_handler(const device_config &devconfig, const char *tag, read32_device_func rfunc, const char *rstring, write32_device_func wfunc, const char *wstring, UINT64 mask);
+	void internal_set_handler(const device_config &devconfig, const char *tag, read32_proto_delegate func, UINT64 mask);
+	void internal_set_handler(const device_config &devconfig, const char *tag, write32_proto_delegate func, UINT64 mask);
+	void internal_set_handler(const device_config &devconfig, const char *tag, read32_proto_delegate rfunc, write32_proto_delegate wfunc, UINT64 mask);
 
 	// internal handler setters for 64-bit functions
 	void internal_set_handler(read64_space_func func, const char *string, UINT64 mask);
@@ -233,6 +233,9 @@ protected:
 	void internal_set_handler(const device_config &devconfig, const char *tag, read64_device_func func, const char *string, UINT64 mask);
 	void internal_set_handler(const device_config &devconfig, const char *tag, write64_device_func func, const char *string, UINT64 mask);
 	void internal_set_handler(const device_config &devconfig, const char *tag, read64_device_func rfunc, const char *rstring, write64_device_func wfunc, const char *wstring, UINT64 mask);
+	void internal_set_handler(const device_config &devconfig, const char *tag, read64_proto_delegate func, UINT64 mask);
+	void internal_set_handler(const device_config &devconfig, const char *tag, write64_proto_delegate func, UINT64 mask);
+	void internal_set_handler(const device_config &devconfig, const char *tag, read64_proto_delegate rfunc, write64_proto_delegate wfunc, UINT64 mask);
 
 private:
 	// helper functions
@@ -257,6 +260,9 @@ public:
 	void set_handler(const device_config &devconfig, const char *tag, read8_device_func func, const char *string) { internal_set_handler(devconfig, tag, func, string, 0); }
 	void set_handler(const device_config &devconfig, const char *tag, write8_device_func func, const char *string) { internal_set_handler(devconfig, tag, func, string, 0); }
 	void set_handler(const device_config &devconfig, const char *tag, read8_device_func rfunc, const char *rstring, write8_device_func wfunc, const char *wstring) { internal_set_handler(devconfig, tag, rfunc, rstring, wfunc, wstring, 0); }
+	void set_handler(const device_config &devconfig, const char *tag, read8_proto_delegate func) { internal_set_handler(devconfig, tag, func, 0); }
+	void set_handler(const device_config &devconfig, const char *tag, write8_proto_delegate func) { internal_set_handler(devconfig, tag, func, 0); }
+	void set_handler(const device_config &devconfig, const char *tag, read8_proto_delegate rfunc, write8_proto_delegate wfunc) { internal_set_handler(devconfig, tag, rfunc, wfunc, 0); }
 };
 
 
@@ -277,6 +283,9 @@ public:
 	void set_handler(const device_config &devconfig, const char *tag, read16_device_func func, const char *string) { internal_set_handler(devconfig, tag, func, string, 0); }
 	void set_handler(const device_config &devconfig, const char *tag, write16_device_func func, const char *string) { internal_set_handler(devconfig, tag, func, string, 0); }
 	void set_handler(const device_config &devconfig, const char *tag, read16_device_func rfunc, const char *rstring, write16_device_func wfunc, const char *wstring) { internal_set_handler(devconfig, tag, rfunc, rstring, wfunc, wstring, 0); }
+	void set_handler(const device_config &devconfig, const char *tag, read16_proto_delegate func) { internal_set_handler(devconfig, tag, func, 0); }
+	void set_handler(const device_config &devconfig, const char *tag, write16_proto_delegate func) { internal_set_handler(devconfig, tag, func, 0); }
+	void set_handler(const device_config &devconfig, const char *tag, read16_proto_delegate rfunc, write16_proto_delegate wfunc) { internal_set_handler(devconfig, tag, rfunc, wfunc, 0); }
 
 	// 8-bit handlers
 	void set_handler(read8_space_func func, const char *string, UINT16 mask) { internal_set_handler(func, string, mask); }
@@ -285,6 +294,9 @@ public:
 	void set_handler(const device_config &devconfig, const char *tag, read8_device_func func, const char *string, UINT16 mask) { internal_set_handler(devconfig, tag, func, string, mask); }
 	void set_handler(const device_config &devconfig, const char *tag, write8_device_func func, const char *string, UINT16 mask) { internal_set_handler(devconfig, tag, func, string, mask); }
 	void set_handler(const device_config &devconfig, const char *tag, read8_device_func rfunc, const char *rstring, write8_device_func wfunc, const char *wstring, UINT16 mask) { internal_set_handler(devconfig, tag, rfunc, rstring, wfunc, wstring, mask); }
+	void set_handler(const device_config &devconfig, const char *tag, read8_proto_delegate func, UINT16 mask) { internal_set_handler(devconfig, tag, func, mask); }
+	void set_handler(const device_config &devconfig, const char *tag, write8_proto_delegate func, UINT16 mask) { internal_set_handler(devconfig, tag, func, mask); }
+	void set_handler(const device_config &devconfig, const char *tag, read8_proto_delegate rfunc, write8_proto_delegate wfunc, UINT16 mask) { internal_set_handler(devconfig, tag, rfunc, wfunc, mask); }
 };
 
 
@@ -305,6 +317,9 @@ public:
 	void set_handler(const device_config &devconfig, const char *tag, read32_device_func func, const char *string) { internal_set_handler(devconfig, tag, func, string, 0); }
 	void set_handler(const device_config &devconfig, const char *tag, write32_device_func func, const char *string) { internal_set_handler(devconfig, tag, func, string, 0); }
 	void set_handler(const device_config &devconfig, const char *tag, read32_device_func rfunc, const char *rstring, write32_device_func wfunc, const char *wstring) { internal_set_handler(devconfig, tag, rfunc, rstring, wfunc, wstring, 0); }
+	void set_handler(const device_config &devconfig, const char *tag, read32_proto_delegate func) { internal_set_handler(devconfig, tag, func, 0); }
+	void set_handler(const device_config &devconfig, const char *tag, write32_proto_delegate func) { internal_set_handler(devconfig, tag, func, 0); }
+	void set_handler(const device_config &devconfig, const char *tag, read32_proto_delegate rfunc, write32_proto_delegate wfunc) { internal_set_handler(devconfig, tag, rfunc, wfunc, 0); }
 
 	// 16-bit handlers
 	void set_handler(read16_space_func func, const char *string, UINT32 mask) { internal_set_handler(func, string, mask); }
@@ -313,6 +328,9 @@ public:
 	void set_handler(const device_config &devconfig, const char *tag, read16_device_func func, const char *string, UINT32 mask) { internal_set_handler(devconfig, tag, func, string, mask); }
 	void set_handler(const device_config &devconfig, const char *tag, write16_device_func func, const char *string, UINT32 mask) { internal_set_handler(devconfig, tag, func, string, mask); }
 	void set_handler(const device_config &devconfig, const char *tag, read16_device_func rfunc, const char *rstring, write16_device_func wfunc, const char *wstring, UINT32 mask) { internal_set_handler(devconfig, tag, rfunc, rstring, wfunc, wstring, mask); }
+	void set_handler(const device_config &devconfig, const char *tag, read16_proto_delegate func, UINT32 mask) { internal_set_handler(devconfig, tag, func, mask); }
+	void set_handler(const device_config &devconfig, const char *tag, write16_proto_delegate func, UINT32 mask) { internal_set_handler(devconfig, tag, func, mask); }
+	void set_handler(const device_config &devconfig, const char *tag, read16_proto_delegate rfunc, write16_proto_delegate wfunc, UINT32 mask) { internal_set_handler(devconfig, tag, rfunc, wfunc, mask); }
 
 	// 8-bit handlers
 	void set_handler(read8_space_func func, const char *string, UINT32 mask) { internal_set_handler(func, string, mask); }
@@ -321,6 +339,9 @@ public:
 	void set_handler(const device_config &devconfig, const char *tag, read8_device_func func, const char *string, UINT32 mask) { internal_set_handler(devconfig, tag, func, string, mask); }
 	void set_handler(const device_config &devconfig, const char *tag, write8_device_func func, const char *string, UINT32 mask) { internal_set_handler(devconfig, tag, func, string, mask); }
 	void set_handler(const device_config &devconfig, const char *tag, read8_device_func rfunc, const char *rstring, write8_device_func wfunc, const char *wstring, UINT32 mask) { internal_set_handler(devconfig, tag, rfunc, rstring, wfunc, wstring, mask); }
+	void set_handler(const device_config &devconfig, const char *tag, read8_proto_delegate func, UINT32 mask) { internal_set_handler(devconfig, tag, func, mask); }
+	void set_handler(const device_config &devconfig, const char *tag, write8_proto_delegate func, UINT32 mask) { internal_set_handler(devconfig, tag, func, mask); }
+	void set_handler(const device_config &devconfig, const char *tag, read8_proto_delegate rfunc, write8_proto_delegate wfunc, UINT32 mask) { internal_set_handler(devconfig, tag, rfunc, wfunc, mask); }
 };
 
 
@@ -341,6 +362,9 @@ public:
 	void set_handler(const device_config &devconfig, const char *tag, read64_device_func func, const char *string) { internal_set_handler(devconfig, tag, func, string, 0); }
 	void set_handler(const device_config &devconfig, const char *tag, write64_device_func func, const char *string) { internal_set_handler(devconfig, tag, func, string, 0); }
 	void set_handler(const device_config &devconfig, const char *tag, read64_device_func rfunc, const char *rstring, write64_device_func wfunc, const char *wstring) { internal_set_handler(devconfig, tag, rfunc, rstring, wfunc, wstring, 0); }
+	void set_handler(const device_config &devconfig, const char *tag, read64_proto_delegate func) { internal_set_handler(devconfig, tag, func, 0); }
+	void set_handler(const device_config &devconfig, const char *tag, write64_proto_delegate func) { internal_set_handler(devconfig, tag, func, 0); }
+	void set_handler(const device_config &devconfig, const char *tag, read64_proto_delegate rfunc, write64_proto_delegate wfunc) { internal_set_handler(devconfig, tag, rfunc, wfunc, 0); }
 
 	// 32-bit handlers
 	void set_handler(read32_space_func func, const char *string, UINT64 mask) { internal_set_handler(func, string, mask); }
@@ -349,6 +373,9 @@ public:
 	void set_handler(const device_config &devconfig, const char *tag, read32_device_func func, const char *string, UINT64 mask) { internal_set_handler(devconfig, tag, func, string, mask); }
 	void set_handler(const device_config &devconfig, const char *tag, write32_device_func func, const char *string, UINT64 mask) { internal_set_handler(devconfig, tag, func, string, mask); }
 	void set_handler(const device_config &devconfig, const char *tag, read32_device_func rfunc, const char *rstring, write32_device_func wfunc, const char *wstring, UINT64 mask) { internal_set_handler(devconfig, tag, rfunc, rstring, wfunc, wstring, mask); }
+	void set_handler(const device_config &devconfig, const char *tag, read32_proto_delegate func, UINT64 mask) { internal_set_handler(devconfig, tag, func, mask); }
+	void set_handler(const device_config &devconfig, const char *tag, write32_proto_delegate func, UINT64 mask) { internal_set_handler(devconfig, tag, func, mask); }
+	void set_handler(const device_config &devconfig, const char *tag, read32_proto_delegate rfunc, write32_proto_delegate wfunc, UINT64 mask) { internal_set_handler(devconfig, tag, rfunc, wfunc, mask); }
 
 	// 16-bit handlers
 	void set_handler(read16_space_func func, const char *string, UINT64 mask) { internal_set_handler(func, string, mask); }
@@ -357,6 +384,9 @@ public:
 	void set_handler(const device_config &devconfig, const char *tag, read16_device_func func, const char *string, UINT64 mask) { internal_set_handler(devconfig, tag, func, string, mask); }
 	void set_handler(const device_config &devconfig, const char *tag, write16_device_func func, const char *string, UINT64 mask) { internal_set_handler(devconfig, tag, func, string, mask); }
 	void set_handler(const device_config &devconfig, const char *tag, read16_device_func rfunc, const char *rstring, write16_device_func wfunc, const char *wstring, UINT64 mask) { internal_set_handler(devconfig, tag, rfunc, rstring, wfunc, wstring, mask); }
+	void set_handler(const device_config &devconfig, const char *tag, read16_proto_delegate func, UINT64 mask) { internal_set_handler(devconfig, tag, func, mask); }
+	void set_handler(const device_config &devconfig, const char *tag, write16_proto_delegate func, UINT64 mask) { internal_set_handler(devconfig, tag, func, mask); }
+	void set_handler(const device_config &devconfig, const char *tag, read16_proto_delegate rfunc, write16_proto_delegate wfunc, UINT64 mask) { internal_set_handler(devconfig, tag, rfunc, wfunc, mask); }
 
 	// 8-bit handlers
 	void set_handler(read8_space_func func, const char *string, UINT64 mask) { internal_set_handler(func, string, mask); }
@@ -365,6 +395,9 @@ public:
 	void set_handler(const device_config &devconfig, const char *tag, read8_device_func func, const char *string, UINT64 mask) { internal_set_handler(devconfig, tag, func, string, mask); }
 	void set_handler(const device_config &devconfig, const char *tag, write8_device_func func, const char *string, UINT64 mask) { internal_set_handler(devconfig, tag, func, string, mask); }
 	void set_handler(const device_config &devconfig, const char *tag, read8_device_func rfunc, const char *rstring, write8_device_func wfunc, const char *wstring, UINT64 mask) { internal_set_handler(devconfig, tag, rfunc, rstring, wfunc, wstring, mask); }
+	void set_handler(const device_config &devconfig, const char *tag, read8_proto_delegate func, UINT64 mask) { internal_set_handler(devconfig, tag, func, mask); }
+	void set_handler(const device_config &devconfig, const char *tag, write8_proto_delegate func, UINT64 mask) { internal_set_handler(devconfig, tag, func, mask); }
+	void set_handler(const device_config &devconfig, const char *tag, read8_proto_delegate rfunc, write8_proto_delegate wfunc, UINT64 mask) { internal_set_handler(devconfig, tag, rfunc, wfunc, mask); }
 };
 
 
@@ -396,11 +429,7 @@ public:
 	UINT8					m_databits;			// data bits represented by the map
 	UINT8					m_unmapval;			// unmapped memory value
 	offs_t					m_globalmask;		// global mask
-	address_map_entry *		m_entrylist;		// list of entries
+	simple_list<address_map_entry> m_entrylist;	// list of entries
-
-private:
-	// internal data
-	address_map_entry **	m_tailptr;
 };
 
 
@@ -419,6 +448,8 @@ private:
 #define ADDRESS_MAP_START(_name, _space, _bits) \
 void ADDRESS_MAP_NAME(_name)(address_map &map, const device_config &devconfig) \
 { \
+	typedef read##_bits##_proto_delegate read_proto_delegate; \
+	typedef write##_bits##_proto_delegate write_proto_delegate; \
 	address_map_entry##_bits *curentry = NULL; \
 	(void)curentry; \
 	map.configure(_space, _bits); \
@@ -458,7 +489,7 @@ void ADDRESS_MAP_NAME(_name)(address_map &map, const device_config &devconfig) \
 	curentry->set_mirror(_mirror); \
 
 
-// space reads
+// legacy space reads
 #define AM_READ(_handler) \
 	curentry->set_handler(_handler, #_handler); \
 
@@ -472,7 +503,7 @@ void ADDRESS_MAP_NAME(_name)(address_map &map, const device_config &devconfig) \
 	curentry->set_handler(_handler, #_handler, _unitmask); \
 
 
-// space writes
+// legacy space writes
 #define AM_WRITE(_handler) \
 	curentry->set_handler(_handler, #_handler); \
 
@@ -486,7 +517,7 @@ void ADDRESS_MAP_NAME(_name)(address_map &map, const device_config &devconfig) \
 	curentry->set_handler(_handler, #_handler, _unitmask); \
 
 
-// space reads/writes
+// legacy space reads/writes
 #define AM_READWRITE(_rhandler, _whandler) \
 	curentry->set_handler(_rhandler, #_rhandler, _whandler, #_whandler); \
 
@@ -500,7 +531,7 @@ void ADDRESS_MAP_NAME(_name)(address_map &map, const device_config &devconfig) \
 	curentry->set_handler(_rhandler, #_rhandler, _whandler, #_whandler, _unitmask); \
 
 
-// device reads
+// legacy device reads
 #define AM_DEVREAD(_tag, _handler) \
 	curentry->set_handler(devconfig, _tag, _handler, #_handler); \
 
@@ -514,7 +545,7 @@ void ADDRESS_MAP_NAME(_name)(address_map &map, const device_config &devconfig) \
 	curentry->set_handler(devconfig, _tag, _handler, #_handler, _unitmask); \
 
 
-// device writes
+// legacy device writes
 #define AM_DEVWRITE(_tag, _handler) \
 	curentry->set_handler(devconfig, _tag, _handler, #_handler); \
 
@@ -528,7 +559,7 @@ void ADDRESS_MAP_NAME(_name)(address_map &map, const device_config &devconfig) \
 	curentry->set_handler(devconfig, _tag, _handler, #_handler, _unitmask); \
 
 
-// device reads/writes
+// legacy device reads/writes
 #define AM_DEVREADWRITE(_tag, _rhandler, _whandler) \
 	curentry->set_handler(devconfig, _tag, _rhandler, #_rhandler, _whandler, #_whandler); \
 
@@ -542,6 +573,90 @@ void ADDRESS_MAP_NAME(_name)(address_map &map, const device_config &devconfig) \
 	curentry->set_handler(devconfig, _tag, _rhandler, #_rhandler, _whandler, #_whandler, _unitmask); \
 
 
+// driver data reads
+#define AM_READ_MEMBER(_class, _handler) \
+	curentry->set_handler(devconfig, NULL, read_proto_delegate::_create_member<_class, &_class::_handler>(#_class "::" #_handler)); \
+
+#define AM_READ8_MEMBER(_class, _handler, _unitmask) \
+	curentry->set_handler(devconfig, NULL, read8_proto_delegate::_create_member<_class, &_class::_handler>(#_class "::" #_handler), _unitmask); \
+
+#define AM_READ16_MEMBER(_class, _handler, _unitmask) \
+	curentry->set_handler(devconfig, NULL, read16_proto_delegate::_create_member<_class, &_class::_handler>(#_class "::" #_handler), _unitmask); \
+
+#define AM_READ32_MEMBER(_class, _handler, _unitmask) \
+	curentry->set_handler(devconfig, NULL, read32_proto_delegate::_create_member<_class, &_class::_handler>(#_class "::" #_handler), _unitmask); \
+
+
+// driver data writes
+#define AM_WRITE_MEMBER(_class, _handler) \
+	curentry->set_handler(devconfig, NULL, write_proto_delegate::_create_member<_class, &_class::_handler>(#_class "::" #_handler)); \
+
+#define AM_WRITE8_MEMBER(_class, _handler, _unitmask) \
+	curentry->set_handler(devconfig, NULL, write8_proto_delegate::_create_member<_class, &_class::_handler>(#_class "::" #_handler), _unitmask); \
+
+#define AM_WRITE16_MEMBER(_class, _handler, _unitmask) \
+	curentry->set_handler(devconfig, NULL, write16_proto_delegate::_create_member<_class, &_class::_handler>(#_class "::" #_handler), _unitmask); \
+
+#define AM_WRITE32_MEMBER(_class, _handler, _unitmask) \
+	curentry->set_handler(devconfig, NULL, write32_proto_delegate::_create_member<_class, &_class::_handler>(#_class "::" #_handler), _unitmask); \
+
+
+// driver data reads/writes
+#define AM_READWRITE_MEMBER(_class, _rhandler, _whandler) \
+	curentry->set_handler(devconfig, NULL, read_proto_delegate::_create_member<_class, &_class::_rhandler>(#_class "::" #_rhandler), write_proto_delegate::_create_member<_class, &_class::_whandler>(#_class "::" #_whandler)); \
+
+#define AM_READWRITE8_MEMBER(_class, _rhandler, _whandler, _unitmask) \
+	curentry->set_handler(devconfig, NULL, read8_proto_delegate::_create_member<_class, &_class::_rhandler>(#_class "::" #_rhandler), write8_proto_delegate::_create_member<_class, &_class::_whandler>(#_class "::" #_whandler), _unitmask); \
+
+#define AM_READWRITE16_MEMBER(_class, _rhandler, _whandler, _unitmask) \
+	curentry->set_handler(devconfig, NULL, read16_proto_delegate::_create_member<_class, &_class::_rhandler>(#_class "::" #_rhandler), write16_proto_delegate::_create_member<_class, &_class::_whandler>(#_class "::" #_whandler), _unitmask); \
+
+#define AM_READWRITE32_MEMBER(_class, _rhandler, _whandler, _unitmask) \
+	curentry->set_handler(devconfig, NULL, read32_proto_delegate::_create_member<_class, &_class::_rhandler>(#_class "::" #_rhandler), write32_proto_delegate::_create_member<_class, &_class::_whandler>(#_class "::" #_whandler), _unitmask); \
+
+
+// device reads
+#define AM_DEVREAD_MEMBER(_tag, _class, _handler) \
+	curentry->set_handler(devconfig, _tag, read_proto_delegate::_create_member<_class, &_class::_handler>(#_class "::" #_handler)); \
+
+#define AM_DEVREAD8_MEMBER(_tag, _class, _handler, _unitmask) \
+	curentry->set_handler(devconfig, _tag, read8_proto_delegate::_create_member<_class, &_class::_handler>(#_class "::" #_handler), _unitmask); \
+
+#define AM_DEVREAD16_MEMBER(_tag, _class, _handler, _unitmask) \
+	curentry->set_handler(devconfig, _tag, read16_proto_delegate::_create_member<_class, &_class::_handler>(#_class "::" #_handler), _unitmask); \
+
+#define AM_DEVREAD32_MEMBER(_tag, _class, _handler, _unitmask) \
+	curentry->set_handler(devconfig, _tag, read32_proto_delegate::_create_member<_class, &_class::_handler>(#_class "::" #_handler), _unitmask); \
+
+
+// device writes
+#define AM_DEVWRITE_MEMBER(_tag, _class, _handler) \
+	curentry->set_handler(devconfig, _tag, write_proto_delegate::_create_member<_class, &_class::_handler>(#_class "::" #_handler)); \
+
+#define AM_DEVWRITE8_MEMBER(_tag, _class, _handler, _unitmask) \
+	curentry->set_handler(devconfig, _tag, write8_proto_delegate::_create_member<_class, &_class::_handler>(#_class "::" #_handler), _unitmask); \
+
+#define AM_DEVWRITE16_MEMBER(_tag, _class, _handler, _unitmask) \
+	curentry->set_handler(devconfig, _tag, write16_proto_delegate::_create_member<_class, &_class::_handler>(#_class "::" #_handler), _unitmask); \
+
+#define AM_DEVWRITE32_MEMBER(_tag, _class, _handler, _unitmask) \
+	curentry->set_handler(devconfig, _tag, write32_proto_delegate::_create_member<_class, &_class::_handler>(#_class "::" #_handler), _unitmask); \
+
+
+// device reads/writes
+#define AM_DEVREADWRITE_MEMBER(_tag, _class, _rhandler, _whandler) \
+	curentry->set_handler(devconfig, _tag, read_proto_delegate::_create_member<_class, &_class::_rhandler>(#_class "::" #_rhandler), write_proto_delegate::_create_member<_class, &_class::_whandler>(#_class "::" #_whandler)); \
+
+#define AM_DEVREADWRITE8_MEMBER(_tag, _class, _rhandler, _whandler, _unitmask) \
+	curentry->set_handler(devconfig, _tag, read8_proto_delegate::_create_member<_class, &_class::_rhandler>(#_class "::" #_rhandler), write8_proto_delegate::_create_member<_class, &_class::_whandler>(#_class "::" #_whandler), _unitmask); \
+
+#define AM_DEVREADWRITE16_MEMBER(_tag, _class, _rhandler, _whandler, _unitmask) \
+	curentry->set_handler(devconfig, _tag, read16_proto_delegate::_create_member<_class, &_class::_rhandler>(#_class "::" #_rhandler), write16_proto_delegate::_create_member<_class, &_class::_whandler>(#_class "::" #_whandler), _unitmask); \
+
+#define AM_DEVREADWRITE32_MEMBER(_tag, _class, _rhandler, _whandler, _unitmask) \
+	curentry->set_handler(devconfig, _tag, read32_proto_delegate::_create_member<_class, &_class::_rhandler>(#_class "::" #_rhandler), write32_proto_delegate::_create_member<_class, &_class::_whandler>(#_class "::" #_whandler), _unitmask); \
+
+
 // special-case accesses
 #define AM_ROM \
 	curentry->set_read_type(AMH_ROM); \
@@ -624,12 +739,25 @@ void ADDRESS_MAP_NAME(_name)(address_map &map, const device_config &devconfig) \
 #define AM_ROMBANK(_bank)					AM_READ_BANK(_bank)
 #define AM_RAMBANK(_bank)					AM_READWRITE_BANK(_bank)
 #define AM_RAM_READ(_read)					AM_READ(_read) AM_WRITEONLY
+#define AM_RAM_READ_MEMBER(_class, _read)	AM_READ_MEMBER(_class, _read) AM_WRITEONLY
 #define AM_RAM_WRITE(_write)				AM_READONLY AM_WRITE(_write)
-#define AM_RAM_DEVREAD(_tag, _read)			AM_DEVREAD(_tag, _read) AM_WRITEONLY
+#define AM_RAM_WRITE_MEMBER(_class, _write)	AM_READONLY AM_WRITE_MEMBER(_class, _write)
-#define AM_RAM_DEVWRITE(_tag, _write)		AM_READONLY AM_DEVWRITE(_tag, _write)
+#define AM_RAM_DEVREAD(_tag, _read) 		AM_DEVREAD(_tag, _read) AM_WRITEONLY
+#define AM_RAM_DEVREAD_MEMBER(_tag, _class, _read) AM_DEVREAD_MEMBER(_tag, _class, _read) AM_WRITEONLY
+#define AM_RAM_DEVWRITE(_tag, _write) 		AM_READONLY AM_DEVWRITE(_tag, _write)
+#define AM_RAM_DEVWRITE_MEMBER(_tag, _class, _write) AM_READONLY AM_DEVWRITE_MEMBER(_tag, _class, _write)
 
 #define AM_BASE_SIZE_MEMBER(_struct, _base, _size)	AM_BASE_MEMBER(_struct, _base) AM_SIZE_MEMBER(_struct, _size)
 #define AM_BASE_SIZE_GENERIC(_member)		AM_BASE_GENERIC(_member) AM_SIZE_GENERIC(_member)
 
 
+
+//**************************************************************************
+//  GLOBAL VARIABLES
+//**************************************************************************
+
+// use this to refer to the owning device when providing a device tag
+static const char DEVICE_SELF[] = "";
+
+
 #endif	/* __ADDRMAP_H__ */

src/emu/cpu/drcbex64.c

@@ -277,7 +277,7 @@ struct _drcbe_state
 	x86code *				debug_cpu_instruction_hook;/* debugger callback */
 	x86code *				debug_log_hashjmp;		/* hashjmp debugging */
 	x86code *				drcmap_get_value;		/* map lookup helper */
-	data_accessors			accessors[ADDRESS_SPACES];/* memory accessors */
+	data_accessors			accessors[ADDRESS_SPACES];	/* memory accessors */
 	const address_space *	space[ADDRESS_SPACES];	/* address spaces */
 
 	UINT8					sse41;					/* do we have SSE4.1 support? */
@@ -388,7 +388,6 @@ static const UINT8 fprnd_map[4] =
 };
 
 
-
 /***************************************************************************
     TABLES
 ***************************************************************************/
@@ -716,7 +715,7 @@ static drcbe_state *drcbex64_alloc(drcuml_state *drcuml, drccache *cache, runnin
 	{
 		drcbe->space[spacenum] = downcast<cpu_device *>(device)->space(spacenum);
 		if (drcbe->space[spacenum] != NULL)
-			drcbe->accessors[spacenum] = drcbe->space[spacenum]->accessors;
+			drcbe->space[spacenum]->accessors(drcbe->accessors[spacenum]);
 	}
 
 	/* build up necessary arrays */

src/emu/cpu/drcbex86.c

@@ -178,6 +178,7 @@ struct _drcbe_state
 	UINT32 *				last_upper_addr;		/* address where we last stored an upper register */
 	double					fptemp;					/* temporary storage for floating point */
 
+	data_accessors			accessors[ADDRESS_SPACES];	/* memory accessors */
 	const address_space *	space[ADDRESS_SPACES];	/* address spaces */
 
 	UINT8					sse3;					/* do we have SSE3 support? */
@@ -629,9 +630,13 @@ static drcbe_state *drcbex86_alloc(drcuml_state *drcuml, drccache *cache, runnin
 	drcbe->drcuml = drcuml;
 	drcbe->cache = cache;
 
-	/* get address spaces */
+	/* get address spaces and accessors */
 	for (spacenum = 0; spacenum < ADDRESS_SPACES; spacenum++)
+	{
 		drcbe->space[spacenum] = downcast<cpu_device *>(device)->space(spacenum);
+		if (drcbe->space[spacenum] != NULL)
+			drcbe->space[spacenum]->accessors(drcbe->accessors[spacenum]);
+	}
 
 	/* allocate hash tables */
 	drcbe->hash = drchash_alloc(cache, modes, addrbits, ignorebits);
@@ -4262,25 +4267,25 @@ static x86code *op_read(drcbe_state *drcbe, x86code *dst, const drcuml_instructi
 	emit_mov_m32_imm(&dst, MBD(REG_ESP, 0), (UINT32)drcbe->space[spacesizep.value / 16]);// mov    [esp],space
 	if ((spacesizep.value & 3) == DRCUML_SIZE_BYTE)
 	{
-		emit_call(&dst, (x86code *)drcbe->space[spacesizep.value / 16]->accessors.read_byte);
+		emit_call(&dst, (x86code *)drcbe->accessors[spacesizep.value / 16].read_byte);
 																						// call   read_byte
 		emit_movzx_r32_r8(&dst, dstreg, REG_AL);										// movzx  dstreg,al
 	}
 	else if ((spacesizep.value & 3) == DRCUML_SIZE_WORD)
 	{
-		emit_call(&dst, (x86code *)drcbe->space[spacesizep.value / 16]->accessors.read_word);
+		emit_call(&dst, (x86code *)drcbe->accessors[spacesizep.value / 16].read_word);
 																						// call   read_word
 		emit_movzx_r32_r16(&dst, dstreg, REG_AX);										// movzx  dstreg,ax
 	}
 	else if ((spacesizep.value & 3) == DRCUML_SIZE_DWORD)
 	{
-		emit_call(&dst, (x86code *)drcbe->space[spacesizep.value / 16]->accessors.read_dword);
+		emit_call(&dst, (x86code *)drcbe->accessors[spacesizep.value / 16].read_dword);
 																						// call   read_dword
 		emit_mov_r32_r32(&dst, dstreg, REG_EAX);										// mov    dstreg,eax
 	}
 	else if ((spacesizep.value & 3) == DRCUML_SIZE_QWORD)
 	{
-		emit_call(&dst, (x86code *)drcbe->space[spacesizep.value / 16]->accessors.read_qword);
+		emit_call(&dst, (x86code *)drcbe->accessors[spacesizep.value / 16].read_qword);
 																						// call   read_qword
 		emit_mov_r32_r32(&dst, dstreg, REG_EAX);										// mov    dstreg,eax
 	}
@@ -4342,19 +4347,19 @@ static x86code *op_readm(drcbe_state *drcbe, x86code *dst, const drcuml_instruct
 	emit_mov_m32_imm(&dst, MBD(REG_ESP, 0), (UINT32)drcbe->space[spacesizep.value / 16]);// mov    [esp],space
 	if ((spacesizep.value & 3) == DRCUML_SIZE_WORD)
 	{
-		emit_call(&dst, (x86code *)drcbe->space[spacesizep.value / 16]->accessors.read_word_masked);
+		emit_call(&dst, (x86code *)drcbe->accessors[spacesizep.value / 16].read_word_masked);
 																						// call   read_word_masked
 		emit_movzx_r32_r16(&dst, dstreg, REG_AX);										// movzx  dstreg,ax
 	}
 	else if ((spacesizep.value & 3) == DRCUML_SIZE_DWORD)
 	{
-		emit_call(&dst, (x86code *)drcbe->space[spacesizep.value / 16]->accessors.read_dword_masked);
+		emit_call(&dst, (x86code *)drcbe->accessors[spacesizep.value / 16].read_dword_masked);
 																						// call   read_dword_masked
 		emit_mov_r32_r32(&dst, dstreg, REG_EAX);										// mov    dstreg,eax
 	}
 	else if ((spacesizep.value & 3) == DRCUML_SIZE_QWORD)
 	{
-		emit_call(&dst, (x86code *)drcbe->space[spacesizep.value / 16]->accessors.read_qword_masked);
+		emit_call(&dst, (x86code *)drcbe->accessors[spacesizep.value / 16].read_qword_masked);
 																						// call   read_qword_masked
 		emit_mov_r32_r32(&dst, dstreg, REG_EAX);										// mov    dstreg,eax
 	}
@@ -4411,16 +4416,16 @@ static x86code *op_write(drcbe_state *drcbe, x86code *dst, const drcuml_instruct
 	emit_mov_m32_p32(drcbe, &dst, MBD(REG_ESP, 4), &addrp);								// mov    [esp+4],addrp
 	emit_mov_m32_imm(&dst, MBD(REG_ESP, 0), (UINT32)drcbe->space[spacesizep.value / 16]);// mov    [esp],space
 	if ((spacesizep.value & 3) == DRCUML_SIZE_BYTE)
-		emit_call(&dst, (x86code *)drcbe->space[spacesizep.value / 16]->accessors.write_byte);
+		emit_call(&dst, (x86code *)drcbe->accessors[spacesizep.value / 16].write_byte);
 																						// call   write_byte
 	else if ((spacesizep.value & 3) == DRCUML_SIZE_WORD)
-		emit_call(&dst, (x86code *)drcbe->space[spacesizep.value / 16]->accessors.write_word);
+		emit_call(&dst, (x86code *)drcbe->accessors[spacesizep.value / 16].write_word);
 																						// call   write_word
 	else if ((spacesizep.value & 3) == DRCUML_SIZE_DWORD)
-		emit_call(&dst, (x86code *)drcbe->space[spacesizep.value / 16]->accessors.write_dword);
+		emit_call(&dst, (x86code *)drcbe->accessors[spacesizep.value / 16].write_dword);
 																						// call   write_dword
 	else if ((spacesizep.value & 3) == DRCUML_SIZE_QWORD)
-		emit_call(&dst, (x86code *)drcbe->space[spacesizep.value / 16]->accessors.write_qword);
+		emit_call(&dst, (x86code *)drcbe->accessors[spacesizep.value / 16].write_qword);
 																						// call   write_qword
 	return dst;
 }
@@ -4456,13 +4461,13 @@ static x86code *op_writem(drcbe_state *drcbe, x86code *dst, const drcuml_instruc
 	emit_mov_m32_p32(drcbe, &dst, MBD(REG_ESP, 4), &addrp);								// mov    [esp+4],addrp
 	emit_mov_m32_imm(&dst, MBD(REG_ESP, 0), (UINT32)drcbe->space[spacesizep.value / 16]);// mov    [esp],space
 	if ((spacesizep.value & 3) == DRCUML_SIZE_WORD)
-		emit_call(&dst, (x86code *)drcbe->space[spacesizep.value / 16]->accessors.write_word_masked);
+		emit_call(&dst, (x86code *)drcbe->accessors[spacesizep.value / 16].write_word_masked);
 																						// call   write_word_masked
 	else if ((spacesizep.value & 3) == DRCUML_SIZE_DWORD)
-		emit_call(&dst, (x86code *)drcbe->space[spacesizep.value / 16]->accessors.write_dword_masked);
+		emit_call(&dst, (x86code *)drcbe->accessors[spacesizep.value / 16].write_dword_masked);
 																						// call   write_dword_masked
 	else if ((spacesizep.value & 3) == DRCUML_SIZE_QWORD)
-		emit_call(&dst, (x86code *)drcbe->space[spacesizep.value / 16]->accessors.write_qword_masked);
+		emit_call(&dst, (x86code *)drcbe->accessors[spacesizep.value / 16].write_qword_masked);
 																						// call   write_qword_masked
 	return dst;
 }
@@ -6411,9 +6416,9 @@ static x86code *op_fread(drcbe_state *drcbe, x86code *dst, const drcuml_instruct
 	emit_mov_m32_p32(drcbe, &dst, MBD(REG_ESP, 4), &addrp);								// mov    [esp+4],addrp
 	emit_mov_m32_imm(&dst, MBD(REG_ESP, 0), (UINT32)drcbe->space[spacep.value]);		// mov    [esp],space
 	if (inst->size == 4)
-		emit_call(&dst, (x86code *)drcbe->space[spacep.value]->accessors.read_dword);	// call   read_dword
+		emit_call(&dst, (x86code *)drcbe->accessors[spacep.value].read_dword);	// call   read_dword
 	else if (inst->size == 8)
-		emit_call(&dst, (x86code *)drcbe->space[spacep.value]->accessors.read_qword);	// call   read_qword
+		emit_call(&dst, (x86code *)drcbe->accessors[spacep.value].read_qword);	// call   read_qword
 
 	/* store result */
 	if (inst->size == 4)
@@ -6449,9 +6454,9 @@ static x86code *op_fwrite(drcbe_state *drcbe, x86code *dst, const drcuml_instruc
 	emit_mov_m32_p32(drcbe, &dst, MBD(REG_ESP, 4), &addrp);								// mov    [esp+4],addrp
 	emit_mov_m32_imm(&dst, MBD(REG_ESP, 0), (UINT32)drcbe->space[spacep.value]);		// mov    [esp],space
 	if (inst->size == 4)
-		emit_call(&dst, (x86code *)drcbe->space[spacep.value]->accessors.write_dword);	// call   write_dword
+		emit_call(&dst, (x86code *)drcbe->accessors[spacep.value].write_dword);	// call   write_dword
 	else if (inst->size == 8)
-		emit_call(&dst, (x86code *)drcbe->space[spacep.value]->accessors.write_qword);	// call   write_qword
+		emit_call(&dst, (x86code *)drcbe->accessors[spacep.value].write_qword);	// call   write_qword
 
 	return dst;
 }

src/emu/cpu/dsp56k/dsp56k.c

@@ -67,12 +67,12 @@ static CPU_RESET( dsp56k );
 /***************************************************************************
     Direct Update Handler
 ***************************************************************************/
-static DIRECT_UPDATE_HANDLER( dsp56k_direct_handler )
+DIRECT_UPDATE_HANDLER( dsp56k_direct_handler )
 {
 	if (address >= (0x0000<<1) && address <= (0x07ff<<1))
 	{
-		dsp56k_core* cpustate = get_safe_token(space->cpu);
+		dsp56k_core* cpustate = get_safe_token(direct.space().cpu);
-		direct->raw = direct->decrypted = (UINT8 *)(cpustate->program_ram - (0x0000<<1));
+		direct.explicit_configure(0x0000<<1, 0x07ff<<1, 0x07ff<<1, cpustate->program_ram);
 		return ~0;
 	}
 
@@ -237,7 +237,7 @@ static CPU_INIT( dsp56k )
 
 	/* Setup the direct memory handler for this CPU */
 	/* NOTE: Be sure to grab this guy and call him if you ever install another direct_update_hander in a driver! */
-	memory_set_direct_update_handler(cpustate->program, dsp56k_direct_handler);
+	const_cast<address_space *>(cpustate->program)->set_direct_update_handler(direct_update_delegate_create_static(dsp56k_direct_handler, *device->machine));
 }
 
 

src/emu/cpu/mips/mips3com.c

@@ -98,7 +98,7 @@ void mips3com_init(mips3_state *mips, mips3_flavor flavor, int bigendian, legacy
 	}
 
 	/* set up the endianness */
-	mips->memory = mips->program->accessors;
+	mips->program->accessors(mips->memory);
 
 	/* allocate the virtual TLB */
 	mips->vtlb = vtlb_alloc(device, ADDRESS_SPACE_PROGRAM, 2 * mips->tlbentries + 2, 0);

src/emu/cpu/mips/r3000.c

@@ -150,7 +150,7 @@ struct _r3000_state
 	/* memory accesses */
 	UINT8		bigendian;
 	data_accessors cur;
-	const data_accessors *memory_hand;
+	data_accessors memory_hand;
 	const data_accessors *cache_hand;
 
 	/* cache memory */
@@ -319,9 +319,9 @@ static void r3000_reset(r3000_state *r3000, int bigendian)
 {
 	/* set up the endianness */
 	r3000->bigendian = bigendian;
+	r3000->program->accessors(r3000->memory_hand);
 	if (r3000->bigendian)
 	{
-		r3000->memory_hand = &r3000->program->accessors;
 		r3000->cache_hand = &be_cache;
 		r3000->lwl = lwl_be;
 		r3000->lwr = lwr_be;
@@ -330,7 +330,6 @@ static void r3000_reset(r3000_state *r3000, int bigendian)
 	}
 	else
 	{
-		r3000->memory_hand = &r3000->program->accessors;
 		r3000->cache_hand = &le_cache;
 		r3000->lwl = lwl_le;
 		r3000->lwr = lwr_le;
@@ -339,7 +338,7 @@ static void r3000_reset(r3000_state *r3000, int bigendian)
 	}
 
 	/* initialize the rest of the config */
-	r3000->cur = *r3000->memory_hand;
+	r3000->cur = r3000->memory_hand;
 	r3000->cache = r3000->dcache;
 	r3000->cache_size = r3000->dcache_size;
 
@@ -396,7 +395,7 @@ INLINE void set_cop0_reg(r3000_state *r3000, int idx, UINT32 val)
 			if (val & SR_IsC)
 				r3000->cur = *r3000->cache_hand;
 			else
-				r3000->cur = *r3000->memory_hand;
+				r3000->cur = r3000->memory_hand;
 		}
 
 		/* handle cache switching */

src/emu/debug/debugcmd.c

@@ -1438,14 +1438,14 @@ static void execute_wplist(running_machine *machine, int ref, int params, const
 			{
 				static const char *const types[] = { "unkn ", "read ", "write", "r/w  " };
 
-				debug_console_printf(machine, "Device '%s' %s space watchpoints:\n", device->tag(), device->debug()->watchpoint_first(spacenum)->space().name);
+				debug_console_printf(machine, "Device '%s' %s space watchpoints:\n", device->tag(), device->debug()->watchpoint_first(spacenum)->space().name());
 
 				/* loop over the watchpoints */
 				for (device_debug::watchpoint *wp = device->debug()->watchpoint_first(spacenum); wp != NULL; wp = wp->next())
 				{
 					buffer.printf("%c%4X @ %s-%s %s", wp->enabled() ? ' ' : 'D', wp->index(),
-							core_i64_hex_format(memory_byte_to_address(&wp->space(), wp->address()), wp->space().addrchars),
+							core_i64_hex_format(wp->space().byte_to_address(wp->address()), wp->space().addrchars()),
-							core_i64_hex_format(memory_byte_to_address_end(&wp->space(), wp->address() + wp->length()) - 1, wp->space().addrchars),
+							core_i64_hex_format(wp->space().byte_to_address_end(wp->address() + wp->length()) - 1, wp->space().addrchars()),
 							types[wp->type() & 3]);
 					if (wp->condition() != NULL)
 						buffer.catprintf(" if %s", wp->condition());
@@ -1524,8 +1524,8 @@ static void execute_save(running_machine *machine, int ref, int params, const ch
 		return;
 
 	/* determine the addresses to write */
-	endoffset = memory_address_to_byte(space, offset + length - 1) & space->bytemask;
+	endoffset = space->address_to_byte(offset + length - 1) & space->bytemask();
-	offset = memory_address_to_byte(space, offset) & space->bytemask;
+	offset = space->address_to_byte(offset) & space->bytemask();
 
 	/* open the file */
 	f = fopen(param[0], "wb");
@@ -1573,16 +1573,16 @@ static void execute_dump(running_machine *machine, int ref, int params, const ch
 
 	/* further validation */
 	if (width == 0)
-		width = space->dbits / 8;
+		width = space->data_width() / 8;
-	if (width < memory_address_to_byte(space, 1))
+	if (width < space->address_to_byte(1))
-		width = memory_address_to_byte(space, 1);
+		width = space->address_to_byte(1);
 	if (width != 1 && width != 2 && width != 4 && width != 8)
 	{
 		debug_console_printf(machine, "Invalid width! (must be 1,2,4 or 8)\n");
 		return;
 	}
-	endoffset = memory_address_to_byte(space, offset + length - 1) & space->bytemask;
+	endoffset = space->address_to_byte(offset + length - 1) & space->bytemask();
-	offset = memory_address_to_byte(space, offset) & space->bytemask;
+	offset = space->address_to_byte(offset) & space->bytemask();
 
 	/* open the file */
 	f = fopen(param[0], "w");
@@ -1599,7 +1599,7 @@ static void execute_dump(running_machine *machine, int ref, int params, const ch
 		int outdex = 0;
 
 		/* print the address */
-		outdex += sprintf(&output[outdex], "%s: ", core_i64_hex_format((UINT32)memory_byte_to_address(space, i), space->logaddrchars));
+		outdex += sprintf(&output[outdex], "%s: ", core_i64_hex_format((UINT32)space->byte_to_address(i), space->logaddrchars()));
 
 		/* print the bytes */
 		for (j = 0; j < 16; j += width)
@@ -1711,19 +1711,19 @@ static void execute_cheatinit(running_machine *machine, int ref, int params, con
 	if (params <= 1)
 	{
 		offset = 0;
-		length = space->bytemask + 1;
+		length = space->bytemask() + 1;
-		for (entry = space->map->m_entrylist; entry != NULL; entry = entry->m_next)
+		for (entry = space->map()->m_entrylist.first(); entry != NULL; entry = entry->next())
 		{
-			cheat_region[region_count].offset = memory_address_to_byte(space, entry->m_addrstart) & space->bytemask;
+			cheat_region[region_count].offset = space->address_to_byte(entry->m_addrstart) & space->bytemask();
-			cheat_region[region_count].endoffset = memory_address_to_byte(space, entry->m_addrend) & space->bytemask;
+			cheat_region[region_count].endoffset = space->address_to_byte(entry->m_addrend) & space->bytemask();
 			cheat_region[region_count].share = entry->m_share;
-			cheat_region[region_count].disabled = (entry->m_write.type == AMH_RAM) ? FALSE : TRUE;
+			cheat_region[region_count].disabled = (entry->m_write.m_type == AMH_RAM) ? FALSE : TRUE;
 
 			/* disable double share regions */
 			if (entry->m_share != NULL)
 				for (i = 0; i < region_count; i++)
 					if (cheat_region[i].share != NULL)
-						if (strcmp(cheat_region[i].share, entry->m_share)==0)
+						if (strcmp(cheat_region[i].share, entry->m_share) == 0)
 							cheat_region[region_count].disabled = TRUE;
 
 			region_count++;
@@ -1738,8 +1738,8 @@ static void execute_cheatinit(running_machine *machine, int ref, int params, con
 			return;
 
 		/* force region to the specified range */
-		cheat_region[region_count].offset = memory_address_to_byte(space, offset) & space->bytemask;;
+		cheat_region[region_count].offset = space->address_to_byte(offset) & space->bytemask();
-		cheat_region[region_count].endoffset = memory_address_to_byte(space, offset + length - 1) & space->bytemask;;
+		cheat_region[region_count].endoffset = space->address_to_byte(offset + length - 1) & space->bytemask();
 		cheat_region[region_count].share = NULL;
 		cheat_region[region_count].disabled = FALSE;
 		region_count++;
@@ -2000,7 +2000,7 @@ static void execute_cheatlist(running_machine *machine, int ref, int params, con
 	if (params > 0)
 		f = fopen(param[0], "w");
 
-	switch (space->spacenum)
+	switch (space->spacenum())
 	{
 		default:
 		case ADDRESS_SPACE_PROGRAM:	spaceletter = 'p';	break;
@@ -2023,19 +2023,19 @@ static void execute_cheatlist(running_machine *machine, int ref, int params, con
 		if (cheat.cheatmap[cheatindex].state == 1)
 		{
 			UINT64 value = cheat_byte_swap(&cheat, cheat_read_extended(&cheat, space, cheat.cheatmap[cheatindex].offset)) & sizemask;
-			offs_t address = memory_byte_to_address(space, cheat.cheatmap[cheatindex].offset);
+			offs_t address = space->byte_to_address(cheat.cheatmap[cheatindex].offset);
 
 			if (params > 0)
 			{
 				active_cheat++;
-				fprintf(f, "  <cheat desc=\"Possibility %d : %s (%s)\">\n", active_cheat, core_i64_hex_format(address, space->logaddrchars), core_i64_hex_format(value, cheat.width * 2));
+				fprintf(f, "  <cheat desc=\"Possibility %d : %s (%s)\">\n", active_cheat, core_i64_hex_format(address, space->logaddrchars()), core_i64_hex_format(value, cheat.width * 2));
 				fprintf(f, "    <script state=\"run\">\n");
-				fprintf(f, "      <action>%s.p%c%c@%s=%s</action>\n", cpu->tag(), spaceletter, sizeletter, core_i64_hex_format(address, space->logaddrchars), core_i64_hex_format(cheat_byte_swap(&cheat, cheat.cheatmap[cheatindex].first_value) & sizemask, cheat.width * 2));
+				fprintf(f, "      <action>%s.p%c%c@%s=%s</action>\n", cpu->tag(), spaceletter, sizeletter, core_i64_hex_format(address, space->logaddrchars()), core_i64_hex_format(cheat_byte_swap(&cheat, cheat.cheatmap[cheatindex].first_value) & sizemask, cheat.width * 2));
 				fprintf(f, "    </script>\n");
 				fprintf(f, "  </cheat>\n\n");
 			}
 			else
-				debug_console_printf(machine, "Address=%s Start=%s Current=%s\n", core_i64_hex_format(address, space->logaddrchars), core_i64_hex_format(cheat_byte_swap(&cheat, cheat.cheatmap[cheatindex].first_value) & sizemask, cheat.width * 2), core_i64_hex_format(value, cheat.width * 2));
+				debug_console_printf(machine, "Address=%s Start=%s Current=%s\n", core_i64_hex_format(address, space->logaddrchars()), core_i64_hex_format(cheat_byte_swap(&cheat, cheat.cheatmap[cheatindex].first_value) & sizemask, cheat.width * 2), core_i64_hex_format(value, cheat.width * 2));
 		}
 	}
 	if (params > 0)
@@ -2096,9 +2096,9 @@ static void execute_find(running_machine *machine, int ref, int params, const ch
 		return;
 
 	/* further validation */
-	endoffset = memory_address_to_byte(space, offset + length - 1) & space->bytemask;
+	endoffset = space->address_to_byte(offset + length - 1) & space->bytemask();
-	offset = memory_address_to_byte(space, offset) & space->bytemask;
+	offset = space->address_to_byte(offset) & space->bytemask();
-	cur_data_size = memory_address_to_byte(space, 1);
+	cur_data_size = space->address_to_byte(1);
 	if (cur_data_size == 0)
 		cur_data_size = 1;
 
@@ -2161,7 +2161,7 @@ static void execute_find(running_machine *machine, int ref, int params, const ch
 		if (match)
 		{
 			found++;
-			debug_console_printf(machine, "Found at %s\n", core_i64_hex_format((UINT32)memory_byte_to_address(space, i), space->addrchars));
+			debug_console_printf(machine, "Found at %s\n", core_i64_hex_format((UINT32)space->byte_to_address(i), space->addrchars()));
 		}
 	}
 
@@ -2215,7 +2215,7 @@ static void execute_dasm(running_machine *machine, int ref, int params, const ch
 	/* now write the data out */
 	for (i = 0; i < length; )
 	{
-		int pcbyte = memory_address_to_byte(space, offset + i) & space->bytemask;
+		int pcbyte = space->address_to_byte(offset + i) & space->bytemask();
 		char output[200+DEBUG_COMMENT_MAX_LINE_LENGTH], disasm[200];
 		const char *comment;
 		offs_t tempaddr;
@@ -2223,7 +2223,7 @@ static void execute_dasm(running_machine *machine, int ref, int params, const ch
 		int numbytes = 0;
 
 		/* print the address */
-		outdex += sprintf(&output[outdex], "%s: ", core_i64_hex_format((UINT32)memory_byte_to_address(space, pcbyte), space->logaddrchars));
+		outdex += sprintf(&output[outdex], "%s: ", core_i64_hex_format((UINT32)space->byte_to_address(pcbyte), space->logaddrchars()));
 
 		/* make sure we can translate the address */
 		tempaddr = pcbyte;
@@ -2246,7 +2246,7 @@ static void execute_dasm(running_machine *machine, int ref, int params, const ch
 		if (bytes)
 		{
 			int startdex = outdex;
-			numbytes = memory_address_to_byte(space, numbytes);
+			numbytes = space->address_to_byte(numbytes);
 			for (j = 0; j < numbytes; j += minbytes)
 				outdex += sprintf(&output[outdex], "%s ", core_i64_hex_format(debug_read_opcode(space, pcbyte + j, minbytes, FALSE), minbytes * 2));
 			if (outdex - startdex < byteswidth)
@@ -2394,7 +2394,7 @@ static void execute_history(running_machine *machine, int ref, int params, const
 		offs_t pc = debug->history_pc(-index);
 
 		/* fetch the bytes up to the maximum */
-		offs_t pcbyte = memory_address_to_byte(space, pc) & space->bytemask;
+		offs_t pcbyte = space->address_to_byte(pc) & space->bytemask();
 		UINT8 opbuf[64], argbuf[64];
 		for (int numbytes = 0; numbytes < maxbytes; numbytes++)
 		{
@@ -2405,7 +2405,7 @@ static void execute_history(running_machine *machine, int ref, int params, const
 		char buffer[200];
 		debug->disassemble(buffer, pc, opbuf, argbuf);
 
-		debug_console_printf(machine, "%s: %s\n", core_i64_hex_format(pc, space->logaddrchars), buffer);
+		debug_console_printf(machine, "%s: %s\n", core_i64_hex_format(pc, space->logaddrchars()), buffer);
 	}
 }
 
@@ -2490,14 +2490,14 @@ static void execute_map(running_machine *machine, int ref, int params, const cha
 	for (intention = TRANSLATE_READ_DEBUG; intention <= TRANSLATE_FETCH_DEBUG; intention++)
 	{
 		static const char *const intnames[] = { "Read", "Write", "Fetch" };
-		taddress = memory_address_to_byte(space, address) & space->bytemask;
+		taddress = space->address_to_byte(address) & space->bytemask();
 		if (debug_cpu_translate(space, intention, &taddress))
 		{
-			const char *mapname = memory_get_handler_string(space, intention == TRANSLATE_WRITE_DEBUG, taddress);
+			const char *mapname = const_cast<address_space *>(space)->get_handler_string((intention == TRANSLATE_WRITE_DEBUG) ? ROW_WRITE : ROW_READ, taddress);
-			debug_console_printf(machine, "%7s: %s logical == %s physical -> %s\n", intnames[intention & 3], core_i64_hex_format(address, space->logaddrchars), core_i64_hex_format(memory_byte_to_address(space, taddress), space->addrchars), mapname);
+			debug_console_printf(machine, "%7s: %s logical == %s physical -> %s\n", intnames[intention & 3], core_i64_hex_format(address, space->logaddrchars()), core_i64_hex_format(space->byte_to_address(taddress), space->addrchars()), mapname);
 		}
 		else
-			debug_console_printf(machine, "%7s: %s logical is unmapped\n", intnames[intention & 3], core_i64_hex_format(address, space->logaddrchars));
+			debug_console_printf(machine, "%7s: %s logical is unmapped\n", intnames[intention & 3], core_i64_hex_format(address, space->logaddrchars()));
 	}
 }
 

src/emu/debug/debugcmt.c

@@ -289,7 +289,7 @@ UINT32 debug_comment_get_opcode_crc32(device_t *device, offs_t address)
 	offs_t numbytes;
 	cpu_device *cpudevice = downcast<cpu_device *>(device);
 	int maxbytes = cpudevice->max_opcode_bytes();
-	UINT32 addrmask = space->logaddrmask;
+	UINT32 addrmask = space->logaddrmask();
 
 	memset(opbuf, 0x00, sizeof(opbuf));
 	memset(argbuf, 0x00, sizeof(argbuf));
@@ -302,7 +302,7 @@ UINT32 debug_comment_get_opcode_crc32(device_t *device, offs_t address)
 	}
 
 	numbytes = device->debug()->disassemble(buff, address & addrmask, opbuf, argbuf) & DASMFLAG_LENGTHMASK;
-	numbytes = memory_address_to_byte(space, numbytes);
+	numbytes = space->address_to_byte(numbytes);
 
 	crc = crc32(0, argbuf, numbytes);
 

src/emu/debug/debugcpu.c

@@ -81,10 +81,10 @@ struct _debugcpu_private
 
 	symbol_table *	symtable;					/* global symbol table */
 
-	UINT8			within_instruction_hook;
+	bool			within_instruction_hook;
-	UINT8			vblank_occurred;
+	bool			vblank_occurred;
-	UINT8			memory_modified;
+	bool			memory_modified;
-	UINT8			debugger_access;
+	bool			debugger_access;
 
 	int				execution_state;
 
@@ -243,14 +243,14 @@ int debug_cpu_within_instruction_hook(running_machine *machine)
 
 
 /*-------------------------------------------------
-    debug_cpu_is_stopped - return TRUE if the
+    debug_cpu_is_stopped - return true if the
     current execution state is stopped
 -------------------------------------------------*/
 
 int debug_cpu_is_stopped(running_machine *machine)
 {
 	debugcpu_private *global = machine->debugcpu_data;
-	return (global != NULL) ? (global->execution_state == EXECUTION_STATE_STOPPED) : FALSE;
+	return (global != NULL) ? (global->execution_state == EXECUTION_STATE_STOPPED) : false;
 }
 
 
@@ -327,8 +327,8 @@ int debug_cpu_translate(const address_space *space, int intention, offs_t *addre
 {
 	device_memory_interface *memory;
 	if (space->cpu->interface(memory))
-		return memory->translate(space->spacenum, intention, *address);
+		return memory->translate(space->spacenum(), intention, *address);
-	return TRUE;
+	return true;
 }
 
 
@@ -341,32 +341,33 @@ int debug_cpu_translate(const address_space *space, int intention, offs_t *addre
     the specified memory space
 -------------------------------------------------*/
 
-UINT8 debug_read_byte(const address_space *space, offs_t address, int apply_translation)
+UINT8 debug_read_byte(const address_space *_space, offs_t address, int apply_translation)
 {
+	address_space *space = const_cast<address_space *>(_space);
 	debugcpu_private *global = space->machine->debugcpu_data;
 	UINT64 custom;
 	UINT8 result;
 
 	/* mask against the logical byte mask */
-	address &= space->logbytemask;
+	address &= space->logbytemask();
 
 	/* all accesses from this point on are for the debugger */
-	memory_set_debugger_access(space, global->debugger_access = TRUE);
+	space->set_debugger_access(global->debugger_access = true);
 
 	/* translate if necessary; if not mapped, return 0xff */
 	if (apply_translation && !debug_cpu_translate(space, TRANSLATE_READ_DEBUG, &address))
 		result = 0xff;
 
-	/* if there is a custom read handler, and it returns TRUE, use that value */
+	/* if there is a custom read handler, and it returns true, use that value */
-	else if (device_memory(space->cpu)->read(space->spacenum, address, 1, custom))
+	else if (device_memory(space->cpu)->read(space->spacenum(), address, 1, custom))
 		result = custom;
 
 	/* otherwise, call the byte reading function for the translated address */
 	else
-		result = memory_read_byte(space, address);
+		result = space->read_byte(address);
 
 	/* no longer accessing via the debugger */
-	memory_set_debugger_access(space, global->debugger_access = FALSE);
+	space->set_debugger_access(global->debugger_access = false);
 	return result;
 }
 
@@ -376,13 +377,14 @@ UINT8 debug_read_byte(const address_space *space, offs_t address, int apply_tran
     specified memory space
 -------------------------------------------------*/
 
-UINT16 debug_read_word(const address_space *space, offs_t address, int apply_translation)
+UINT16 debug_read_word(const address_space *_space, offs_t address, int apply_translation)
 {
+	address_space *space = const_cast<address_space *>(_space);
 	debugcpu_private *global = space->machine->debugcpu_data;
 	UINT16 result;
 
 	/* mask against the logical byte mask */
-	address &= space->logbytemask;
+	address &= space->logbytemask();
 
 	/* if this is misaligned read, or if there are no word readers, just read two bytes */
 	if ((address & 1) != 0)
@@ -391,7 +393,7 @@ UINT16 debug_read_word(const address_space *space, offs_t address, int apply_tra
 		UINT8 byte1 = debug_read_byte(space, address + 1, apply_translation);
 
 		/* based on the endianness, the result is assembled differently */
-		if (space->endianness == ENDIANNESS_LITTLE)
+		if (space->endianness() == ENDIANNESS_LITTLE)
 			result = byte0 | (byte1 << 8);
 		else
 			result = byte1 | (byte0 << 8);
@@ -403,22 +405,22 @@ UINT16 debug_read_word(const address_space *space, offs_t address, int apply_tra
 		UINT64 custom;
 
 		/* all accesses from this point on are for the debugger */
-		memory_set_debugger_access(space, global->debugger_access = TRUE);
+		space->set_debugger_access(global->debugger_access = true);
 
 		/* translate if necessary; if not mapped, return 0xffff */
 		if (apply_translation && !debug_cpu_translate(space, TRANSLATE_READ_DEBUG, &address))
 			result = 0xffff;
 
-		/* if there is a custom read handler, and it returns TRUE, use that value */
+		/* if there is a custom read handler, and it returns true, use that value */
-		else if (device_memory(space->cpu)->read(space->spacenum, address, 2, custom))
+		else if (device_memory(space->cpu)->read(space->spacenum(), address, 2, custom))
 			result = custom;
 
 		/* otherwise, call the byte reading function for the translated address */
 		else
-			result = memory_read_word(space, address);
+			result = space->read_word(address);
 
 		/* no longer accessing via the debugger */
-		memory_set_debugger_access(space, global->debugger_access = FALSE);
+		space->set_debugger_access(global->debugger_access = false);
 	}
 
 	return result;
@@ -430,13 +432,14 @@ UINT16 debug_read_word(const address_space *space, offs_t address, int apply_tra
     specified memory space
 -------------------------------------------------*/
 
-UINT32 debug_read_dword(const address_space *space, offs_t address, int apply_translation)
+UINT32 debug_read_dword(const address_space *_space, offs_t address, int apply_translation)
 {
+	address_space *space = const_cast<address_space *>(_space);
 	debugcpu_private *global = space->machine->debugcpu_data;
 	UINT32 result;
 
 	/* mask against the logical byte mask */
-	address &= space->logbytemask;
+	address &= space->logbytemask();
 
 	/* if this is misaligned read, or if there are no dword readers, just read two words */
 	if ((address & 3) != 0)
@@ -445,7 +448,7 @@ UINT32 debug_read_dword(const address_space *space, offs_t address, int apply_tr
 		UINT16 word1 = debug_read_word(space, address + 2, apply_translation);
 
 		/* based on the endianness, the result is assembled differently */
-		if (space->endianness == ENDIANNESS_LITTLE)
+		if (space->endianness() == ENDIANNESS_LITTLE)
 			result = word0 | (word1 << 16);
 		else
 			result = word1 | (word0 << 16);
@@ -457,22 +460,22 @@ UINT32 debug_read_dword(const address_space *space, offs_t address, int apply_tr
 		UINT64 custom;
 
 		/* all accesses from this point on are for the debugger */
-		memory_set_debugger_access(space, global->debugger_access = TRUE);
+		space->set_debugger_access(global->debugger_access = true);
 
 		/* translate if necessary; if not mapped, return 0xffffffff */
 		if (apply_translation && !debug_cpu_translate(space, TRANSLATE_READ_DEBUG, &address))
 			result = 0xffffffff;
 
-		/* if there is a custom read handler, and it returns TRUE, use that value */
+		/* if there is a custom read handler, and it returns true, use that value */
-		else if (device_memory(space->cpu)->read(space->spacenum, address, 4, custom))
+		else if (device_memory(space->cpu)->read(space->spacenum(), address, 4, custom))
 			result = custom;
 
 		/* otherwise, call the byte reading function for the translated address */
 		else
-			result = memory_read_dword(space, address);
+			result = space->read_dword(address);
 
 		/* no longer accessing via the debugger */
-		memory_set_debugger_access(space, global->debugger_access = FALSE);
+		space->set_debugger_access(global->debugger_access = false);
 	}
 
 	return result;
@@ -484,13 +487,14 @@ UINT32 debug_read_dword(const address_space *space, offs_t address, int apply_tr
     specified memory space
 -------------------------------------------------*/
 
-UINT64 debug_read_qword(const address_space *space, offs_t address, int apply_translation)
+UINT64 debug_read_qword(const address_space *_space, offs_t address, int apply_translation)
 {
+	address_space *space = const_cast<address_space *>(_space);
 	debugcpu_private *global = space->machine->debugcpu_data;
 	UINT64 result;
 
 	/* mask against the logical byte mask */
-	address &= space->logbytemask;
+	address &= space->logbytemask();
 
 	/* if this is misaligned read, or if there are no qword readers, just read two dwords */
 	if ((address & 7) != 0)
@@ -499,7 +503,7 @@ UINT64 debug_read_qword(const address_space *space, offs_t address, int apply_tr
 		UINT32 dword1 = debug_read_dword(space, address + 4, apply_translation);
 
 		/* based on the endianness, the result is assembled differently */
-		if (space->endianness == ENDIANNESS_LITTLE)
+		if (space->endianness() == ENDIANNESS_LITTLE)
 			result = dword0 | ((UINT64)dword1 << 32);
 		else
 			result = dword1 | ((UINT64)dword0 << 32);
@@ -511,22 +515,22 @@ UINT64 debug_read_qword(const address_space *space, offs_t address, int apply_tr
 		UINT64 custom;
 
 		/* all accesses from this point on are for the debugger */
-		memory_set_debugger_access(space, global->debugger_access = TRUE);
+		space->set_debugger_access(global->debugger_access = true);
 
 		/* translate if necessary; if not mapped, return 0xffffffffffffffff */
 		if (apply_translation && !debug_cpu_translate(space, TRANSLATE_READ_DEBUG, &address))
 			result = ~(UINT64)0;
 
-		/* if there is a custom read handler, and it returns TRUE, use that value */
+		/* if there is a custom read handler, and it returns true, use that value */
-		else if (device_memory(space->cpu)->read(space->spacenum, address, 8, custom))
+		else if (device_memory(space->cpu)->read(space->spacenum(), address, 8, custom))
 			result = custom;
 
 		/* otherwise, call the byte reading function for the translated address */
 		else
-			result = memory_read_qword(space, address);
+			result = space->read_qword(address);
 
 		/* no longer accessing via the debugger */
-		memory_set_debugger_access(space, global->debugger_access = FALSE);
+		space->set_debugger_access(global->debugger_access = false);
 	}
 
 	return result;
@@ -557,31 +561,32 @@ UINT64 debug_read_memory(const address_space *space, offs_t address, int size, i
     specified memory space
 -------------------------------------------------*/
 
-void debug_write_byte(const address_space *space, offs_t address, UINT8 data, int apply_translation)
+void debug_write_byte(const address_space *_space, offs_t address, UINT8 data, int apply_translation)
 {
+	address_space *space = const_cast<address_space *>(_space);
 	debugcpu_private *global = space->machine->debugcpu_data;
 
 	/* mask against the logical byte mask */
-	address &= space->logbytemask;
+	address &= space->logbytemask();
 
 	/* all accesses from this point on are for the debugger */
-	memory_set_debugger_access(space, global->debugger_access = TRUE);
+	space->set_debugger_access(global->debugger_access = true);
 
 	/* translate if necessary; if not mapped, we're done */
 	if (apply_translation && !debug_cpu_translate(space, TRANSLATE_WRITE_DEBUG, &address))
 		;
 
-	/* if there is a custom write handler, and it returns TRUE, use that */
+	/* if there is a custom write handler, and it returns true, use that */
-	else if (device_memory(space->cpu)->write(space->spacenum, address, 1, data))
+	else if (device_memory(space->cpu)->write(space->spacenum(), address, 1, data))
 		;
 
 	/* otherwise, call the byte reading function for the translated address */
 	else
-		memory_write_byte(space, address, data);
+		space->write_byte(address, data);
 
 	/* no longer accessing via the debugger */
-	memory_set_debugger_access(space, global->debugger_access = FALSE);
+	space->set_debugger_access(global->debugger_access = false);
-	global->memory_modified = TRUE;
+	global->memory_modified = true;
 }
 
 
@@ -590,17 +595,18 @@ void debug_write_byte(const address_space *space, offs_t address, UINT8 data, in
     specified memory space
 -------------------------------------------------*/
 
-void debug_write_word(const address_space *space, offs_t address, UINT16 data, int apply_translation)
+void debug_write_word(const address_space *_space, offs_t address, UINT16 data, int apply_translation)
 {
+	address_space *space = const_cast<address_space *>(_space);
 	debugcpu_private *global = space->machine->debugcpu_data;
 
 	/* mask against the logical byte mask */
-	address &= space->logbytemask;
+	address &= space->logbytemask();
 
 	/* if this is a misaligned write, or if there are no word writers, just read two bytes */
 	if ((address & 1) != 0)
 	{
-		if (space->endianness == ENDIANNESS_LITTLE)
+		if (space->endianness() == ENDIANNESS_LITTLE)
 		{
 			debug_write_byte(space, address + 0, data >> 0, apply_translation);
 			debug_write_byte(space, address + 1, data >> 8, apply_translation);
@@ -616,23 +622,23 @@ void debug_write_word(const address_space *space, offs_t address, UINT16 data, i
 	else
 	{
 		/* all accesses from this point on are for the debugger */
-		memory_set_debugger_access(space, global->debugger_access = TRUE);
+		space->set_debugger_access(global->debugger_access = true);
 
 		/* translate if necessary; if not mapped, we're done */
 		if (apply_translation && !debug_cpu_translate(space, TRANSLATE_WRITE_DEBUG, &address))
 			;
 
-		/* if there is a custom write handler, and it returns TRUE, use that */
+		/* if there is a custom write handler, and it returns true, use that */
-		else if (device_memory(space->cpu)->write(space->spacenum, address, 2, data))
+		else if (device_memory(space->cpu)->write(space->spacenum(), address, 2, data))
 			;
 
 		/* otherwise, call the byte reading function for the translated address */
 		else
-			memory_write_word(space, address, data);
+			space->write_word(address, data);
 
 		/* no longer accessing via the debugger */
-		memory_set_debugger_access(space, global->debugger_access = FALSE);
+		space->set_debugger_access(global->debugger_access = false);
-		global->memory_modified = TRUE;
+		global->memory_modified = true;
 	}
 }
 
@@ -642,17 +648,18 @@ void debug_write_word(const address_space *space, offs_t address, UINT16 data, i
     specified memory space
 -------------------------------------------------*/
 
-void debug_write_dword(const address_space *space, offs_t address, UINT32 data, int apply_translation)
+void debug_write_dword(const address_space *_space, offs_t address, UINT32 data, int apply_translation)
 {
+	address_space *space = const_cast<address_space *>(_space);
 	debugcpu_private *global = space->machine->debugcpu_data;
 
 	/* mask against the logical byte mask */
-	address &= space->logbytemask;
+	address &= space->logbytemask();
 
 	/* if this is a misaligned write, or if there are no dword writers, just read two words */
 	if ((address & 3) != 0)
 	{
-		if (space->endianness == ENDIANNESS_LITTLE)
+		if (space->endianness() == ENDIANNESS_LITTLE)
 		{
 			debug_write_word(space, address + 0, data >> 0, apply_translation);
 			debug_write_word(space, address + 2, data >> 16, apply_translation);
@@ -668,23 +675,23 @@ void debug_write_dword(const address_space *space, offs_t address, UINT32 data,
 	else
 	{
 		/* all accesses from this point on are for the debugger */
-		memory_set_debugger_access(space, global->debugger_access = TRUE);
+		space->set_debugger_access(global->debugger_access = true);
 
 		/* translate if necessary; if not mapped, we're done */
 		if (apply_translation && !debug_cpu_translate(space, TRANSLATE_WRITE_DEBUG, &address))
 			;
 
-		/* if there is a custom write handler, and it returns TRUE, use that */
+		/* if there is a custom write handler, and it returns true, use that */
-		else if (device_memory(space->cpu)->write(space->spacenum, address, 4, data))
+		else if (device_memory(space->cpu)->write(space->spacenum(), address, 4, data))
 			;
 
 		/* otherwise, call the byte reading function for the translated address */
 		else
-			memory_write_dword(space, address, data);
+			space->write_dword(address, data);
 
 		/* no longer accessing via the debugger */
-		memory_set_debugger_access(space, global->debugger_access = FALSE);
+		space->set_debugger_access(global->debugger_access = false);
-		global->memory_modified = TRUE;
+		global->memory_modified = true;
 	}
 }
 
@@ -694,17 +701,18 @@ void debug_write_dword(const address_space *space, offs_t address, UINT32 data,
     specified memory space
 -------------------------------------------------*/
 
-void debug_write_qword(const address_space *space, offs_t address, UINT64 data, int apply_translation)
+void debug_write_qword(const address_space *_space, offs_t address, UINT64 data, int apply_translation)
 {
+	address_space *space = const_cast<address_space *>(_space);
 	debugcpu_private *global = space->machine->debugcpu_data;
 
 	/* mask against the logical byte mask */
-	address &= space->logbytemask;
+	address &= space->logbytemask();
 
 	/* if this is a misaligned write, or if there are no qword writers, just read two dwords */
 	if ((address & 7) != 0)
 	{
-		if (space->endianness == ENDIANNESS_LITTLE)
+		if (space->endianness() == ENDIANNESS_LITTLE)
 		{
 			debug_write_dword(space, address + 0, data >> 0, apply_translation);
 			debug_write_dword(space, address + 4, data >> 32, apply_translation);
@@ -720,23 +728,23 @@ void debug_write_qword(const address_space *space, offs_t address, UINT64 data,
 	else
 	{
 		/* all accesses from this point on are for the debugger */
-		memory_set_debugger_access(space, global->debugger_access = TRUE);
+		space->set_debugger_access(global->debugger_access = true);
 
 		/* translate if necessary; if not mapped, we're done */
 		if (apply_translation && !debug_cpu_translate(space, TRANSLATE_WRITE_DEBUG, &address))
 			;
 
-		/* if there is a custom write handler, and it returns TRUE, use that */
+		/* if there is a custom write handler, and it returns true, use that */
-		else if (device_memory(space->cpu)->write(space->spacenum, address, 8, data))
+		else if (device_memory(space->cpu)->write(space->spacenum(), address, 8, data))
 			;
 
 		/* otherwise, call the byte reading function for the translated address */
 		else
-			memory_write_qword(space, address, data);
+			space->write_qword(address, data);
 
 		/* no longer accessing via the debugger */
-		memory_set_debugger_access(space, global->debugger_access = FALSE);
+		space->set_debugger_access(global->debugger_access = false);
-		global->memory_modified = TRUE;
+		global->memory_modified = true;
 	}
 }
 
@@ -763,31 +771,32 @@ void debug_write_memory(const address_space *space, offs_t address, UINT64 data,
     the given offset from opcode space
 -------------------------------------------------*/
 
-UINT64 debug_read_opcode(const address_space *space, offs_t address, int size, int arg)
+UINT64 debug_read_opcode(const address_space *_space, offs_t address, int size, int arg)
 {
+	address_space *space = const_cast<address_space *>(_space);
 	UINT64 result = ~(UINT64)0 & (~(UINT64)0 >> (64 - 8*size)), result2;
 	debugcpu_private *global = space->machine->debugcpu_data;
 
 	/* keep in logical range */
-	address &= space->logbytemask;
+	address &= space->logbytemask();
 
 	/* return early if we got the result directly */
-	memory_set_debugger_access(space, global->debugger_access = TRUE);
+	space->set_debugger_access(global->debugger_access = true);
 	device_memory_interface *memory;
 	if (space->cpu->interface(memory) && memory->readop(address, size, result2))
 	{
-		memory_set_debugger_access(space, global->debugger_access = FALSE);
+		space->set_debugger_access(global->debugger_access = false);
 		return result2;
 	}
 
 	/* if we're bigger than the address bus, break into smaller pieces */
-	if (size > space->dbits / 8)
+	if (size > space->data_width() / 8)
 	{
 		int halfsize = size / 2;
 		UINT64 r0 = debug_read_opcode(space, address + 0, halfsize, arg);
 		UINT64 r1 = debug_read_opcode(space, address + halfsize, halfsize, arg);
 
-		if (space->endianness == ENDIANNESS_LITTLE)
+		if (space->endianness() == ENDIANNESS_LITTLE)
 			return r0 | (r1 << (8 * halfsize));
 		else
 			return r1 | (r0 << (8 * halfsize));
@@ -798,8 +807,8 @@ UINT64 debug_read_opcode(const address_space *space, offs_t address, int size, i
 		return result;
 
 	/* keep in physical range */
-	address &= space->bytemask;
+	address &= space->bytemask();
-	switch (space->dbits / 8 * 10 + size)
+	switch (space->data_width() / 8 * 10 + size)
 	{
 		/* dump opcodes in bytes from a byte-sized bus */
 		case 11:
@@ -807,7 +816,7 @@ UINT64 debug_read_opcode(const address_space *space, offs_t address, int size, i
 
 		/* dump opcodes in bytes from a word-sized bus */
 		case 21:
-			address ^= (space->endianness == ENDIANNESS_LITTLE) ? BYTE_XOR_LE(0) : BYTE_XOR_BE(0);
+			address ^= (space->endianness() == ENDIANNESS_LITTLE) ? BYTE_XOR_LE(0) : BYTE_XOR_BE(0);
 			break;
 
 		/* dump opcodes in words from a word-sized bus */
@@ -816,12 +825,12 @@ UINT64 debug_read_opcode(const address_space *space, offs_t address, int size, i
 
 		/* dump opcodes in bytes from a dword-sized bus */
 		case 41:
-			address ^= (space->endianness == ENDIANNESS_LITTLE) ? BYTE4_XOR_LE(0) : BYTE4_XOR_BE(0);
+			address ^= (space->endianness() == ENDIANNESS_LITTLE) ? BYTE4_XOR_LE(0) : BYTE4_XOR_BE(0);
 			break;
 
 		/* dump opcodes in words from a dword-sized bus */
 		case 42:
-			address ^= (space->endianness == ENDIANNESS_LITTLE) ? WORD_XOR_LE(0) : WORD_XOR_BE(0);
+			address ^= (space->endianness() == ENDIANNESS_LITTLE) ? WORD_XOR_LE(0) : WORD_XOR_BE(0);
 			break;
 
 		/* dump opcodes in dwords from a dword-sized bus */
@@ -830,17 +839,17 @@ UINT64 debug_read_opcode(const address_space *space, offs_t address, int size, i
 
 		/* dump opcodes in bytes from a qword-sized bus */
 		case 81:
-			address ^= (space->endianness == ENDIANNESS_LITTLE) ? BYTE8_XOR_LE(0) : BYTE8_XOR_BE(0);
+			address ^= (space->endianness() == ENDIANNESS_LITTLE) ? BYTE8_XOR_LE(0) : BYTE8_XOR_BE(0);
 			break;
 
 		/* dump opcodes in words from a qword-sized bus */
 		case 82:
-			address ^= (space->endianness == ENDIANNESS_LITTLE) ? WORD2_XOR_LE(0) : WORD2_XOR_BE(0);
+			address ^= (space->endianness() == ENDIANNESS_LITTLE) ? WORD2_XOR_LE(0) : WORD2_XOR_BE(0);
 			break;
 
 		/* dump opcodes in dwords from a qword-sized bus */
 		case 84:
-			address ^= (space->endianness == ENDIANNESS_LITTLE) ? DWORD_XOR_LE(0) : DWORD_XOR_BE(0);
+			address ^= (space->endianness() == ENDIANNESS_LITTLE) ? DWORD_XOR_LE(0) : DWORD_XOR_BE(0);
 			break;
 
 		/* dump opcodes in qwords from a qword-sized bus */
@@ -848,13 +857,13 @@ UINT64 debug_read_opcode(const address_space *space, offs_t address, int size, i
 			break;
 
 		default:
-			fatalerror("debug_read_opcode: unknown type = %d", space->dbits / 8 * 10 + size);
+			fatalerror("debug_read_opcode: unknown type = %d", space->data_width() / 8 * 10 + size);
 			break;
 	}
 
 	/* turn on debugger access */
 	if (!global->debugger_access)
-		memory_set_debugger_access(space, global->debugger_access = TRUE);
+		space->set_debugger_access(global->debugger_access = true);
 
 	/* switch off the size and handle unaligned accesses */
 	switch (size)
@@ -868,7 +877,7 @@ UINT64 debug_read_opcode(const address_space *space, offs_t address, int size, i
 			if ((address & 1) != 0)
 			{
 				result2 = (arg) ? memory_raw_read_word(space, (address & ~1) + 2) : memory_decrypted_read_word(space, (address & ~1) + 2);
-				if (space->endianness == ENDIANNESS_LITTLE)
+				if (space->endianness() == ENDIANNESS_LITTLE)
 					result = (result >> (8 * (address & 1))) | (result2 << (16 - 8 * (address & 1)));
 				else
 					result = (result << (8 * (address & 1))) | (result2 >> (16 - 8 * (address & 1)));
@@ -881,7 +890,7 @@ UINT64 debug_read_opcode(const address_space *space, offs_t address, int size, i
 			if ((address & 3) != 0)
 			{
 				result2 = (arg) ? memory_raw_read_dword(space, (address & ~3) + 4) : memory_decrypted_read_dword(space, (address & ~3) + 4);
-				if (space->endianness == ENDIANNESS_LITTLE)
+				if (space->endianness() == ENDIANNESS_LITTLE)
 					result = (result >> (8 * (address & 3))) | (result2 << (32 - 8 * (address & 3)));
 				else
 					result = (result << (8 * (address & 3))) | (result2 >> (32 - 8 * (address & 3)));
@@ -894,7 +903,7 @@ UINT64 debug_read_opcode(const address_space *space, offs_t address, int size, i
 			if ((address & 7) != 0)
 			{
 				result2 = (arg) ? memory_raw_read_qword(space, (address & ~7) + 8) : memory_decrypted_read_qword(space, (address & ~7) + 8);
-				if (space->endianness == ENDIANNESS_LITTLE)
+				if (space->endianness() == ENDIANNESS_LITTLE)
 					result = (result >> (8 * (address & 7))) | (result2 << (64 - 8 * (address & 7)));
 				else
 					result = (result << (8 * (address & 7))) | (result2 >> (64 - 8 * (address & 7)));
@@ -903,7 +912,7 @@ UINT64 debug_read_opcode(const address_space *space, offs_t address, int size, i
 	}
 
 	/* no longer accessing via the debugger */
-	memory_set_debugger_access(space, global->debugger_access = FALSE);
+	space->set_debugger_access(global->debugger_access = false);
 	return result;
 }
 
@@ -935,7 +944,7 @@ static void on_vblank(screen_device &device, void *param, bool vblank_state)
 {
 	/* just set a global flag to be consumed later */
 	if (vblank_state)
-		device.machine->debugcpu_data->vblank_occurred = TRUE;
+		device.machine->debugcpu_data->vblank_occurred = true;
 }
 
 
@@ -1044,7 +1053,7 @@ static UINT64 expression_read_memory(void *param, const char *name, int spacenum
 				device = debug_cpu_get_visible_cpu(machine);
 			space = cpu_get_address_space(device, ADDRESS_SPACE_PROGRAM + (spacenum - EXPSPACE_PROGRAM_LOGICAL));
 			if (space != NULL)
-				result = debug_read_memory(space, memory_address_to_byte(space, address), size, TRUE);
+				result = debug_read_memory(space, space->address_to_byte(address), size, true);
 			break;
 
 		case EXPSPACE_PROGRAM_PHYSICAL:
@@ -1057,7 +1066,7 @@ static UINT64 expression_read_memory(void *param, const char *name, int spacenum
 				device = debug_cpu_get_visible_cpu(machine);
 			space = cpu_get_address_space(device, ADDRESS_SPACE_PROGRAM + (spacenum - EXPSPACE_PROGRAM_PHYSICAL));
 			if (space != NULL)
-				result = debug_read_memory(space, memory_address_to_byte(space, address), size, FALSE);
+				result = debug_read_memory(space, space->address_to_byte(address), size, false);
 			break;
 
 		case EXPSPACE_OPCODE:
@@ -1084,8 +1093,9 @@ static UINT64 expression_read_memory(void *param, const char *name, int spacenum
     directly from an opcode or RAM pointer
 -------------------------------------------------*/
 
-static UINT64 expression_read_program_direct(const address_space *space, int opcode, offs_t address, int size)
+static UINT64 expression_read_program_direct(const address_space *_space, int opcode, offs_t address, int size)
 {
+	address_space *space = const_cast<address_space *>(_space);
 	UINT64 result = ~(UINT64)0 >> (64 - 8*size);
 
 	if (space != NULL)
@@ -1094,7 +1104,7 @@ static UINT64 expression_read_program_direct(const address_space *space, int opc
 
 		/* adjust the address into a byte address, but not if being called recursively */
 		if ((opcode & 2) == 0)
-			address = memory_address_to_byte(space, address);
+			address = space->address_to_byte(address);
 
 		/* call ourself recursively until we are byte-sized */
 		if (size > 1)
@@ -1107,7 +1117,7 @@ static UINT64 expression_read_program_direct(const address_space *space, int opc
 			r1 = expression_read_program_direct(space, opcode | 2, address + halfsize, halfsize);
 
 			/* assemble based on the target endianness */
-			if (space->endianness == ENDIANNESS_LITTLE)
+			if (space->endianness() == ENDIANNESS_LITTLE)
 				result = r0 | (r1 << (8 * halfsize));
 			else
 				result = r1 | (r0 << (8 * halfsize));
@@ -1117,7 +1127,7 @@ static UINT64 expression_read_program_direct(const address_space *space, int opc
 		else
 		{
 			/* lowmask specified which address bits are within the databus width */
-			offs_t lowmask = space->dbits / 8 - 1;
+			offs_t lowmask = space->data_width() / 8 - 1;
 
 			/* get the base of memory, aligned to the address minus the lowbits */
 			if (opcode & 1)
@@ -1128,7 +1138,7 @@ static UINT64 expression_read_program_direct(const address_space *space, int opc
 			/* if we have a valid base, return the appropriate byte */
 			if (base != NULL)
 			{
-				if (space->endianness == ENDIANNESS_LITTLE)
+				if (space->endianness() == ENDIANNESS_LITTLE)
 					result = base[BYTE8_XOR_LE(address) & lowmask];
 				else
 					result = base[BYTE8_XOR_BE(address) & lowmask];
@@ -1211,7 +1221,7 @@ static void expression_write_memory(void *param, const char *name, int spacenum,
 				device = debug_cpu_get_visible_cpu(machine);
 			space = cpu_get_address_space(device, ADDRESS_SPACE_PROGRAM + (spacenum - EXPSPACE_PROGRAM_LOGICAL));
 			if (space != NULL)
-				debug_write_memory(space, memory_address_to_byte(space, address), data, size, TRUE);
+				debug_write_memory(space, space->address_to_byte(address), data, size, true);
 			break;
 
 		case EXPSPACE_PROGRAM_PHYSICAL:
@@ -1224,7 +1234,7 @@ static void expression_write_memory(void *param, const char *name, int spacenum,
 				device = debug_cpu_get_visible_cpu(machine);
 			space = cpu_get_address_space(device, ADDRESS_SPACE_PROGRAM + (spacenum - EXPSPACE_PROGRAM_PHYSICAL));
 			if (space != NULL)
-				debug_write_memory(space, memory_address_to_byte(space, address), data, size, FALSE);
+				debug_write_memory(space, space->address_to_byte(address), data, size, false);
 			break;
 
 		case EXPSPACE_OPCODE:
@@ -1250,8 +1260,9 @@ static void expression_write_memory(void *param, const char *name, int spacenum,
     directly to an opcode or RAM pointer
 -------------------------------------------------*/
 
-static void expression_write_program_direct(const address_space *space, int opcode, offs_t address, int size, UINT64 data)
+static void expression_write_program_direct(const address_space *_space, int opcode, offs_t address, int size, UINT64 data)
 {
+	address_space *space = const_cast<address_space *>(_space);
 	if (space != NULL)
 	{
 		debugcpu_private *global = space->machine->debugcpu_data;
@@ -1259,7 +1270,7 @@ static void expression_write_program_direct(const address_space *space, int opco
 
 		/* adjust the address into a byte address, but not if being called recursively */
 		if ((opcode & 2) == 0)
-			address = memory_address_to_byte(space, address);
+			address = space->address_to_byte(address);
 
 		/* call ourself recursively until we are byte-sized */
 		if (size > 1)
@@ -1269,7 +1280,7 @@ static void expression_write_program_direct(const address_space *space, int opco
 
 			/* break apart based on the target endianness */
 			halfmask = ~(UINT64)0 >> (64 - 8 * halfsize);
-			if (space->endianness == ENDIANNESS_LITTLE)
+			if (space->endianness() == ENDIANNESS_LITTLE)
 			{
 				r0 = data & halfmask;
 				r1 = (data >> (8 * halfsize)) & halfmask;
@@ -1289,7 +1300,7 @@ static void expression_write_program_direct(const address_space *space, int opco
 		else
 		{
 			/* lowmask specified which address bits are within the databus width */
-			offs_t lowmask = space->dbits / 8 - 1;
+			offs_t lowmask = space->data_width() / 8 - 1;
 
 			/* get the base of memory, aligned to the address minus the lowbits */
 			if (opcode & 1)
@@ -1300,11 +1311,11 @@ static void expression_write_program_direct(const address_space *space, int opco
 			/* if we have a valid base, write the appropriate byte */
 			if (base != NULL)
 			{
-				if (space->endianness == ENDIANNESS_LITTLE)
+				if (space->endianness() == ENDIANNESS_LITTLE)
 					base[BYTE8_XOR_LE(address) & lowmask] = data;
 				else
 					base[BYTE8_XOR_BE(address) & lowmask] = data;
-				global->memory_modified = TRUE;
+				global->memory_modified = true;
 			}
 		}
 	}
@@ -1360,7 +1371,7 @@ static void expression_write_memory_region(running_machine *machine, const char
 				base[BYTE8_XOR_LE(address) & lowmask] = data;
 			else
 				base[BYTE8_XOR_BE(address) & lowmask] = data;
-			global->memory_modified = TRUE;
+			global->memory_modified = true;
 		}
 	}
 }
@@ -1678,7 +1689,7 @@ void device_debug::start_hook(attotime endtime)
 		// if a VBLANK occurred, check on things
 		if (global->vblank_occurred)
 		{
-			global->vblank_occurred = FALSE;
+			global->vblank_occurred = false;
 
 			// if we were waiting for a VBLANK, signal it now
 			if ((m_flags & DEBUG_FLAG_STOP_VBLANK) != 0)
@@ -1769,7 +1780,7 @@ void device_debug::instruction_hook(offs_t curpc)
 	debugcpu_private *global = m_device.machine->debugcpu_data;
 
 	// note that we are in the debugger code
-	global->within_instruction_hook = TRUE;
+	global->within_instruction_hook = true;
 
 	// update the history
 	m_pc_history[m_pc_history_index++ % HISTORY_SIZE] = curpc;
@@ -1831,7 +1842,7 @@ void device_debug::instruction_hook(offs_t curpc)
 	// if we are supposed to halt, do it now
 	if (global->execution_state == EXECUTION_STATE_STOPPED)
 	{
-		int firststop = TRUE;
+		int firststop = true;
 
 		// reset any transient state
 		reset_transient_flags(*m_device.machine);
@@ -1845,19 +1856,19 @@ void device_debug::instruction_hook(offs_t curpc)
 		debugger_refresh_display(m_device.machine);
 
 		// wait for the debugger; during this time, disable sound output
-		sound_mute(m_device.machine, TRUE);
+		sound_mute(m_device.machine, true);
 		while (global->execution_state == EXECUTION_STATE_STOPPED)
 		{
 			// flush any pending updates before waiting again
 			m_device.machine->m_debug_view->flush_osd_updates();
 
 			// clear the memory modified flag and wait
-			global->memory_modified = FALSE;
+			global->memory_modified = false;
 			if (m_device.machine->debug_flags & DEBUG_FLAG_OSD_ENABLED)
 				osd_wait_for_debugger(&m_device, firststop);
 			else if (m_device.machine->debug_flags & DEBUG_FLAG_ENABLED)
 				debugint_wait_for_debugger(&m_device, firststop);
-			firststop = FALSE;
+			firststop = false;
 
 			// if something modified memory, update the screen
 			if (global->memory_modified)
@@ -1873,7 +1884,7 @@ void device_debug::instruction_hook(offs_t curpc)
 			if (m_device.machine->scheduled_event_pending())
 				global->execution_state = EXECUTION_STATE_RUNNING;
 		}
-		sound_mute(m_device.machine, FALSE);
+		sound_mute(m_device.machine, false);
 
 		// remember the last visible CPU in the debugger
 		global->visiblecpu = &m_device;
@@ -1884,7 +1895,7 @@ void device_debug::instruction_hook(offs_t curpc)
 		prepare_for_step_overout(pc());
 
 	// no longer in debugger code
-	global->within_instruction_hook = FALSE;
+	global->within_instruction_hook = false;
 }
 
 
@@ -1956,7 +1967,7 @@ offs_t device_debug::disassemble(char *buffer, offs_t pc, const UINT8 *oprom, co
 if (m_memory != NULL && m_disasm != NULL)
 {
 	const address_space *space = m_memory->space(AS_PROGRAM);
-	int bytes = memory_address_to_byte(space, result & DASMFLAG_LENGTHMASK);
+	int bytes = space->address_to_byte(result & DASMFLAG_LENGTHMASK);
 	assert(bytes >= m_disasm->min_opcode_bytes());
 	assert(bytes <= m_disasm->max_opcode_bytes());
 	(void) bytes; // appease compiler
@@ -2068,7 +2079,7 @@ void device_debug::go_vblank()
 
 	assert(m_exec != NULL);
 
-	global->vblank_occurred = FALSE;
+	global->vblank_occurred = false;
 	m_flags |= DEBUG_FLAG_STOP_VBLANK;
 	global->execution_state = EXECUTION_STATE_RUNNING;
 }
@@ -2270,14 +2281,14 @@ void device_debug::breakpoint_enable_all(bool enable)
 
 int device_debug::watchpoint_set(const address_space &space, int type, offs_t address, offs_t length, parsed_expression *condition, const char *action)
 {
-	assert(space.spacenum < ARRAY_LENGTH(m_wplist));
+	assert(space.spacenum() < ARRAY_LENGTH(m_wplist));
 
 	// allocate a new one
 	watchpoint *wp = auto_alloc(m_device.machine, watchpoint(m_device.machine->debugcpu_data->bpindex++, space, type, address, length, condition, action));
 
 	// hook it into our list
-	wp->m_next = m_wplist[space.spacenum];
+	wp->m_next = m_wplist[space.spacenum()];
-	m_wplist[space.spacenum] = wp;
+	m_wplist[space.spacenum()] = wp;
 
 	// update the flags and return the index
 	watchpoint_update_flags(wp->m_space);
@@ -2571,7 +2582,7 @@ void device_debug::watchpoint_update_flags(const address_space &space)
 
 	// see if there are any enabled breakpoints
 	bool enablewrite = false;
-	for (watchpoint *wp = m_wplist[space.spacenum]; wp != NULL; wp = wp->m_next)
+	for (watchpoint *wp = m_wplist[space.spacenum()]; wp != NULL; wp = wp->m_next)
 		if (wp->m_enabled)
 		{
 			if (wp->m_type & WATCHPOINT_READ)
@@ -2598,13 +2609,13 @@ void device_debug::watchpoint_check(const address_space &space, int type, offs_t
 	// if we're within debugger code, don't stop
 	if (global->within_instruction_hook || global->debugger_access)
 		return;
-	global->within_instruction_hook = TRUE;
+	global->within_instruction_hook = true;
 
 	// adjust address, size & value_to_write based on mem_mask.
 	offs_t size = 0;
 	if (mem_mask != 0)
 	{
-		int bus_size = space.dbits / 8;
+		int bus_size = space.data_width() / 8;
 		int address_offset = 0;
 
 		while (address_offset < bus_size && (mem_mask & 0xff) == 0)
@@ -2620,7 +2631,7 @@ void device_debug::watchpoint_check(const address_space &space, int type, offs_t
 			mem_mask >>= 8;
 		}
 
-		if (space.endianness == ENDIANNESS_LITTLE)
+		if (space.endianness() == ENDIANNESS_LITTLE)
 			address += address_offset;
 		else
 			address += bus_size - size - address_offset;
@@ -2632,7 +2643,7 @@ void device_debug::watchpoint_check(const address_space &space, int type, offs_t
 		global->wpdata = value_to_write;
 
 	// see if we match
-	for (watchpoint *wp = m_wplist[space.spacenum]; wp != NULL; wp = wp->m_next)
+	for (watchpoint *wp = m_wplist[space.spacenum()]; wp != NULL; wp = wp->m_next)
 		if (wp->hit(type, address, size))
 		{
 			// halt in the debugger by default
@@ -2654,21 +2665,21 @@ void device_debug::watchpoint_check(const address_space &space, int type, offs_t
 
 				if (type & WATCHPOINT_WRITE)
 				{
-					buffer.printf("Stopped at watchpoint %X writing %s to %08X (PC=%X)", wp->m_index, sizes[size], memory_byte_to_address(&space, address), pc);
+					buffer.printf("Stopped at watchpoint %X writing %s to %08X (PC=%X)", wp->m_index, sizes[size], space.byte_to_address(address), pc);
 					if (value_to_write >> 32)
 						buffer.catprintf(" (data=%X%08X)", (UINT32)(value_to_write >> 32), (UINT32)value_to_write);
 					else
 						buffer.catprintf(" (data=%X)", (UINT32)value_to_write);
 				}
 				else
-					buffer.printf("Stopped at watchpoint %X reading %s from %08X (PC=%X)", wp->m_index, sizes[size], memory_byte_to_address(&space, address), pc);
+					buffer.printf("Stopped at watchpoint %X reading %s from %08X (PC=%X)", wp->m_index, sizes[size], space.byte_to_address(address), pc);
 				debug_console_printf(space.machine, "%s\n", buffer.cstr());
 				space.cpu->debug()->compute_debug_flags();
 			}
 			break;
 		}
 
-	global->within_instruction_hook = FALSE;
+	global->within_instruction_hook = false;
 }
 
 
@@ -2693,7 +2704,7 @@ void device_debug::hotspot_check(const address_space &space, offs_t address)
 		// if the bottom of the list is over the threshhold, print it
 		hotspot_entry &spot = m_hotspots[m_hotspot_count - 1];
 		if (spot.m_count > m_hotspot_threshhold)
-			debug_console_printf(space.machine, "Hotspot @ %s %08X (PC=%08X) hit %d times (fell off bottom)\n", space.name, spot.m_access, spot.m_pc, spot.m_count);
+			debug_console_printf(space.machine, "Hotspot @ %s %08X (PC=%08X) hit %d times (fell off bottom)\n", space.name(), spot.m_access, spot.m_pc, spot.m_count);
 
 		// move everything else down and insert this one at the top
 		memmove(&m_hotspots[1], &m_hotspots[0], sizeof(m_hotspots[0]) * (m_hotspot_count - 1));
@@ -2729,15 +2740,15 @@ UINT32 device_debug::dasm_wrapped(astring &buffer, offs_t pc)
 
 	// determine the adjusted PC
 	const address_space *space = m_memory->space(AS_PROGRAM);
-	offs_t pcbyte = memory_address_to_byte(space, pc) & space->bytemask;
+	offs_t pcbyte = space->address_to_byte(pc) & space->bytemask();
 
 	// fetch the bytes up to the maximum
 	UINT8 opbuf[64], argbuf[64];
 	int maxbytes = max_opcode_bytes();
 	for (int numbytes = 0; numbytes < maxbytes; numbytes++)
 	{
-		opbuf[numbytes] = debug_read_opcode(space, pcbyte + numbytes, 1, FALSE);
+		opbuf[numbytes] = debug_read_opcode(space, pcbyte + numbytes, 1, false);
-		argbuf[numbytes] = debug_read_opcode(space, pcbyte + numbytes, 1, TRUE);
+		argbuf[numbytes] = debug_read_opcode(space, pcbyte + numbytes, 1, true);
 	}
 
 	// disassemble to our buffer
@@ -2789,8 +2800,8 @@ UINT64 device_debug::get_logunmap(void *globalref, void *ref)
 
 void device_debug::set_logunmap(void *globalref, void *ref, UINT64 value)
 {
-	const address_space *space = reinterpret_cast<const address_space *>(ref);
+	address_space *space = reinterpret_cast<address_space *>(ref);
-	memory_set_log_unmap(space, value ? 1 : 0);
+	space->set_log_unmap(value ? true : false);
 }
 
 
@@ -2887,8 +2898,8 @@ device_debug::watchpoint::watchpoint(int index, const address_space &space, int
 	  m_index(index),
 	  m_enabled(true),
 	  m_type(type),
-	  m_address(memory_address_to_byte(&space, address) & space.bytemask),
+	  m_address(space.address_to_byte(address) & space.bytemask()),
-	  m_length(memory_address_to_byte(&space, length)),
+	  m_length(space.address_to_byte(length)),
 	  m_condition(condition),
 	  m_action((action != NULL) ? action : "")
 {

src/emu/debug/debugcpu.h

@@ -146,7 +146,7 @@ public:
 
 	// commonly-used pass-throughs
 	offs_t pc() const { return (m_state != NULL) ? m_state->pc() : 0; }
-	int logaddrchars(int spacenum = AS_PROGRAM) const { return (m_memory != NULL && m_memory->space(spacenum) != NULL) ? m_memory->space(spacenum)->logaddrchars : 8; }
+	int logaddrchars(int spacenum = AS_PROGRAM) const { return (m_memory != NULL && m_memory->space(spacenum) != NULL) ? m_memory->space(spacenum)->logaddrchars() : 8; }
 	int min_opcode_bytes() const { return (m_disasm != NULL) ? m_disasm->max_opcode_bytes() : 1; }
 	int max_opcode_bytes() const { return (m_disasm != NULL) ? m_disasm->max_opcode_bytes() : 1; }
 

src/emu/debug/dvdisasm.c

@@ -203,7 +203,7 @@ void debug_view_disasm::view_char(int chval)
 		case DCH_HOME:				// set the active column to the PC
 		{
 			const debug_view_disasm_source &source = downcast<const debug_view_disasm_source &>(*m_source);
-			offs_t pc = memory_address_to_byte(source.m_space, cpu_get_pc(&source.m_device)) & source.m_space->logbytemask;
+			offs_t pc = source.m_space->address_to_byte(cpu_get_pc(&source.m_device)) & source.m_space->logbytemask();
 
 			// figure out which row the pc is on
 			for (int curline = 0; curline < m_allocated.y; curline++)
@@ -242,9 +242,9 @@ offs_t debug_view_disasm::find_pc_backwards(offs_t targetpc, int numinstrs)
 	const debug_view_disasm_source &source = downcast<const debug_view_disasm_source &>(*m_source);
 
 	// compute the increment
-	int minlen = memory_byte_to_address(source.m_space, source.m_disasmintf->min_opcode_bytes());
+	int minlen = source.m_space->byte_to_address(source.m_disasmintf->min_opcode_bytes());
 	if (minlen == 0) minlen = 1;
-	int maxlen = memory_byte_to_address(source.m_space, source.m_disasmintf->max_opcode_bytes());
+	int maxlen = source.m_space->byte_to_address(source.m_disasmintf->max_opcode_bytes());
 	if (maxlen == 0) maxlen = 1;
 
 	// start off numinstrs back
@@ -253,13 +253,13 @@ offs_t debug_view_disasm::find_pc_backwards(offs_t targetpc, int numinstrs)
 		curpc = 0;
 
 	/* loop until we find what we are looking for */
-	offs_t targetpcbyte = memory_address_to_byte(source.m_space, targetpc) & source.m_space->logbytemask;
+	offs_t targetpcbyte = source.m_space->address_to_byte(targetpc) & source.m_space->logbytemask();
 	offs_t fillpcbyte = targetpcbyte;
 	offs_t lastgoodpc = targetpc;
 	while (1)
 	{
 		// fill the buffer up to the target
-		offs_t curpcbyte = memory_address_to_byte(source.m_space, curpc) & source.m_space->logbytemask;
+		offs_t curpcbyte = source.m_space->address_to_byte(curpc) & source.m_space->logbytemask();
 		UINT8 opbuf[1024], argbuf[1024];
 		while (curpcbyte < fillpcbyte)
 		{
@@ -274,7 +274,7 @@ offs_t debug_view_disasm::find_pc_backwards(offs_t targetpc, int numinstrs)
 		offs_t scanpc;
 		for (scanpc = curpc; scanpc < targetpc; scanpc += instlen)
 		{
-			offs_t scanpcbyte = memory_address_to_byte(source.m_space, scanpc) & source.m_space->logbytemask;
+			offs_t scanpcbyte = source.m_space->address_to_byte(scanpc) & source.m_space->logbytemask();
 			offs_t physpcbyte = scanpcbyte;
 
 			// get the disassembly, but only if mapped
@@ -348,7 +348,7 @@ bool debug_view_disasm::recompute(offs_t pc, int startline, int lines)
 	const debug_view_disasm_source &source = downcast<const debug_view_disasm_source &>(*m_source);
 
 	// determine how many characters we need for an address and set the divider
-	m_divider1 = 1 + source.m_space->logaddrchars + 1;
+	m_divider1 = 1 + source.m_space->logaddrchars() + 1;
 
 	// assume a fixed number of characters for the disassembly
 	m_divider2 = m_divider1 + 1 + m_dasm_width + 1;
@@ -358,7 +358,7 @@ bool debug_view_disasm::recompute(offs_t pc, int startline, int lines)
 	int maxbytes = source.m_disasmintf->max_opcode_bytes();
 
 	// ensure that the PC is aligned to the minimum opcode size
-	pc &= ~memory_byte_to_address_end(source.m_space, minbytes - 1);
+	pc &= ~source.m_space->byte_to_address_end(minbytes - 1);
 
 	// set the width of the third column according to display mode
 	if (m_right_column == DASM_RIGHTCOL_RAW || m_right_column == DASM_RIGHTCOL_ENCRYPTED)
@@ -390,7 +390,7 @@ bool debug_view_disasm::recompute(offs_t pc, int startline, int lines)
 	for (int line = 0; line < lines; line++)
 	{
 		// convert PC to a byte offset
-		offs_t pcbyte = memory_address_to_byte(source.m_space, pc) & source.m_space->logbytemask;
+		offs_t pcbyte = source.m_space->address_to_byte(pc) & source.m_space->logbytemask();
 
 		// save a copy of the previous line as a backup if we're only doing one line
 		int instr = startline + line;
@@ -401,7 +401,7 @@ bool debug_view_disasm::recompute(offs_t pc, int startline, int lines)
 
 		// convert back and set the address of this instruction
 		m_byteaddress[instr] = pcbyte;
-		sprintf(&destbuf[0], " %s  ", core_i64_hex_format(memory_byte_to_address(source.m_space, pcbyte), source.m_space->logaddrchars));
+		sprintf(&destbuf[0], " %s  ", core_i64_hex_format(source.m_space->byte_to_address(pcbyte), source.m_space->logaddrchars()));
 
 		// make sure we can translate the address, and then disassemble the result
 		char buffer[100];
@@ -419,7 +419,7 @@ bool debug_view_disasm::recompute(offs_t pc, int startline, int lines)
 			}
 
 			// disassemble the result
-			pc += numbytes = source.m_disasmintf->disassemble(buffer, pc & source.m_space->logaddrmask, opbuf, argbuf) & DASMFLAG_LENGTHMASK;
+			pc += numbytes = source.m_disasmintf->disassemble(buffer, pc & source.m_space->logaddrmask(), opbuf, argbuf) & DASMFLAG_LENGTHMASK;
 		}
 		else
 			strcpy(buffer, "<unmapped>");
@@ -431,13 +431,13 @@ bool debug_view_disasm::recompute(offs_t pc, int startline, int lines)
 		if (m_right_column == DASM_RIGHTCOL_RAW || m_right_column == DASM_RIGHTCOL_ENCRYPTED)
 		{
 			// get the bytes
-			numbytes = memory_address_to_byte(source.m_space, numbytes) & source.m_space->logbytemask;
+			numbytes = source.m_space->address_to_byte(numbytes) & source.m_space->logbytemask();
 			generate_bytes(pcbyte, numbytes, minbytes, &destbuf[m_divider2], m_allocated.x - m_divider2, m_right_column == DASM_RIGHTCOL_ENCRYPTED);
 		}
 		else if (m_right_column == DASM_RIGHTCOL_COMMENTS)
 		{
 			// get and add the comment, if present
-			offs_t comment_address = memory_byte_to_address(source.m_space, m_byteaddress[instr]);
+			offs_t comment_address = source.m_space->byte_to_address(m_byteaddress[instr]);
 			const char *text = debug_comment_get_text(&source.m_device, comment_address, debug_comment_get_opcode_crc32(&source.m_device, comment_address));
 			if (text != NULL)
 				sprintf(&destbuf[m_divider2], "// %.*s", m_allocated.x - m_divider2 - 1, text);
@@ -449,8 +449,8 @@ bool debug_view_disasm::recompute(offs_t pc, int startline, int lines)
 	}
 
 	// update opcode base information
-	m_last_direct_decrypted = source.m_space->direct.decrypted;
+	m_last_direct_decrypted = source.m_space->direct().decrypted();
-	m_last_direct_raw = source.m_space->direct.raw;
+	m_last_direct_raw = source.m_space->direct().raw();
 	m_last_change_count = debug_comment_all_change_count(&m_machine);
 
 	// now longer need to recompute
@@ -469,7 +469,7 @@ void debug_view_disasm::view_update()
 	const debug_view_disasm_source &source = downcast<const debug_view_disasm_source &>(*m_source);
 
 	offs_t pc = cpu_get_pc(&source.m_device);
-	offs_t pcbyte = memory_address_to_byte(source.m_space, pc) & source.m_space->logbytemask;
+	offs_t pcbyte = source.m_space->address_to_byte(pc) & source.m_space->logbytemask();
 
 	// update our context; if the expression is dirty, recompute
 	if (m_expression.dirty())
@@ -480,7 +480,7 @@ void debug_view_disasm::view_update()
 	UINT64 result = m_expression.value();
 	if (result != previous)
 	{
-		offs_t resultbyte = memory_address_to_byte(source.m_space, result) & source.m_space->logbytemask;
+		offs_t resultbyte = source.m_space->address_to_byte(result) & source.m_space->logbytemask();
 
 		// see if the new result is an address we already have
 		UINT32 row;
@@ -498,7 +498,7 @@ void debug_view_disasm::view_update()
 	}
 
 	// if the opcode base has changed, rework things
-	if (source.m_space->direct.decrypted != m_last_direct_decrypted || source.m_space->direct.raw != m_last_direct_raw)
+	if (source.m_space->direct().decrypted() != m_last_direct_decrypted || source.m_space->direct().raw() != m_last_direct_raw)
 		m_recompute = true;
 
 	// if the comments have changed, redo it
@@ -517,7 +517,7 @@ recompute:
 			m_topleft.x = 0;
 
 			// recompute from where we last recomputed!
-			recompute(memory_byte_to_address(source.m_space, m_byteaddress[0]), 0, m_total.y);
+			recompute(source.m_space->byte_to_address(m_byteaddress[0]), 0, m_total.y);
 		}
 		else
 		{
@@ -579,7 +579,7 @@ recompute:
 			else
 			{
 				for (device_debug::breakpoint *bp = source.m_device.debug()->breakpoint_first(); bp != NULL; bp = bp->next())
-					if (m_byteaddress[effrow] == (memory_address_to_byte(source.m_space, bp->address()) & source.m_space->logbytemask))
+					if (m_byteaddress[effrow] == (source.m_space->address_to_byte(bp->address()) & source.m_space->logbytemask()))
 						attrib = DCA_CHANGED;
 			}
 
@@ -627,7 +627,7 @@ recompute:
 offs_t debug_view_disasm::selected_address()
 {
 	flush_updates();
-	return memory_byte_to_address(downcast<const debug_view_disasm_source &>(*m_source).m_space, m_byteaddress[m_cursor.y]);
+	return downcast<const debug_view_disasm_source &>(*m_source).m_space->byte_to_address(m_byteaddress[m_cursor.y]);
 }
 
 
@@ -695,7 +695,7 @@ void debug_view_disasm::set_disasm_width(UINT32 width)
 void debug_view_disasm::set_selected_address(offs_t address)
 {
 	const debug_view_disasm_source &source = downcast<const debug_view_disasm_source &>(*m_source);
-	offs_t byteaddress = memory_address_to_byte(source.m_space, address) & source.m_space->logbytemask;
+	offs_t byteaddress = source.m_space->address_to_byte(address) & source.m_space->logbytemask();
 	for (int line = 0; line < m_total.y; line++)
 		if (m_byteaddress[line] == byteaddress)
 		{

src/emu/debug/dvmemory.c

@@ -79,8 +79,8 @@ debug_view_memory_source::debug_view_memory_source(const char *name, const addre
 	  m_base(NULL),
 	  m_length(0),
 	  m_offsetxor(0),
-	  m_endianness(space.endianness),
+	  m_endianness(space.endianness()),
-	  m_prefsize(space.dbits / 8)
+	  m_prefsize(space.data_width() / 8)
 {
 }
 
@@ -159,7 +159,7 @@ void debug_view_memory::enumerate_sources()
 			const address_space *space = memintf->space(spacenum);
 			if (space != NULL)
 			{
-				name.printf("%s '%s' %s space memory", memintf->device().name(), memintf->device().tag(), space->name);
+				name.printf("%s '%s' %s space memory", memintf->device().name(), memintf->device().tag(), space->name());
 				m_source_list.append(*auto_alloc(&m_machine, debug_view_memory_source(name, *space)));
 			}
 		}
@@ -263,7 +263,7 @@ void debug_view_memory::view_update()
 		if (effrow < m_total.y)
 		{
 			offs_t addrbyte = m_byte_offset + effrow * m_bytes_per_row;
-			offs_t address = (source.m_space != NULL) ? memory_byte_to_address(source.m_space, addrbyte) : addrbyte;
+			offs_t address = (source.m_space != NULL) ? source.m_space->byte_to_address(addrbyte) : addrbyte;
 			char addrtext[20];
 
 			// generate the address
@@ -441,8 +441,8 @@ void debug_view_memory::recompute()
 	int addrchars;
 	if (source.m_space != NULL)
 	{
-		m_maxaddr = m_no_translation ? source.m_space->bytemask : source.m_space->logbytemask;
+		m_maxaddr = m_no_translation ? source.m_space->bytemask() : source.m_space->logbytemask();
-		addrchars = m_no_translation ? source.m_space->addrchars : source.m_space->logaddrchars;
+		addrchars = m_no_translation ? source.m_space->addrchars() : source.m_space->logaddrchars();
 	}
 	else
 	{
@@ -457,9 +457,9 @@ void debug_view_memory::recompute()
 		m_addrformat.printf("%%0%dX%*s", addrchars, 8 - addrchars, "");
 
 	// if we are viewing a space with a minimum chunk size, clamp the bytes per chunk
-	if (source.m_space != NULL && source.m_space->ashift < 0)
+	if (source.m_space != NULL && source.m_space->byte_to_address(1) > 1)
 	{
-		UINT32 min_bytes_per_chunk = 1 << -source.m_space->ashift;
+		UINT32 min_bytes_per_chunk = source.m_space->byte_to_address(1);
 		while (m_bytes_per_chunk < min_bytes_per_chunk)
 		{
 			m_bytes_per_chunk *= 2;
@@ -521,7 +521,7 @@ bool debug_view_memory::needs_recompute()
 		const debug_view_memory_source &source = downcast<const debug_view_memory_source &>(*m_source);
 		offs_t resultbyte;
 		if (source.m_space != NULL)
-			resultbyte  = memory_address_to_byte(source.m_space, m_expression.value()) & source.m_space->logbytemask;
+			resultbyte  = source.m_space->address_to_byte(m_expression.value()) & source.m_space->logbytemask();
 		else
 			resultbyte = m_expression.value();
 
@@ -621,7 +621,7 @@ bool debug_view_memory::read(UINT8 size, offs_t offs, UINT64 &data)
 	{
 		offs_t dummyaddr = offs;
 
-		bool ismapped = m_no_translation ? true : source.m_memintf->translate(source.m_space->spacenum, TRANSLATE_READ_DEBUG, dummyaddr);
+		bool ismapped = m_no_translation ? true : source.m_memintf->translate(source.m_space->spacenum(), TRANSLATE_READ_DEBUG, dummyaddr);
 		data = ~(UINT64)0;
 		if (ismapped)
 		{

src/emu/delegate.c

@@ -0,0 +1,97 @@
+/***************************************************************************
+
+    delegate.c
+
+    Templates and classes to enable delegates for callbacks.
+
+****************************************************************************
+
+    Copyright Aaron Giles
+    All rights reserved.
+
+    Redistribution and use in source and binary forms, with or without
+    modification, are permitted provided that the following conditions are
+    met:
+
+        * Redistributions of source code must retain the above copyright
+          notice, this list of conditions and the following disclaimer.
+        * Redistributions in binary form must reproduce the above copyright
+          notice, this list of conditions and the following disclaimer in
+          the documentation and/or other materials provided with the
+          distribution.
+        * Neither the name 'MAME' nor the names of its contributors may be
+          used to endorse or promote products derived from this software
+          without specific prior written permission.
+
+    THIS SOFTWARE IS PROVIDED BY AARON GILES ''AS IS'' AND ANY EXPRESS OR
+    IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED
+    WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE
+    DISCLAIMED. IN NO EVENT SHALL AARON GILES BE LIABLE FOR ANY DIRECT,
+    INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES
+    (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR
+    SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION)
+    HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT,
+    STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING
+    IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE
+    POSSIBILITY OF SUCH DAMAGE.
+
+***************************************************************************/
+
+#include "emucore.h"
+#include "delegate.h"
+
+
+//**************************************************************************
+//  BINDABLE OBJECT
+//**************************************************************************
+
+//-------------------------------------------------
+//  bindable_object - constructor
+//-------------------------------------------------
+
+bindable_object::bindable_object()
+{
+}
+
+
+//-------------------------------------------------
+//  ~bindable_object - destructor
+//-------------------------------------------------
+
+bindable_object::~bindable_object()
+{
+}
+
+
+
+//**************************************************************************
+//  INTERNAL DELEGATE HELPERS
+//**************************************************************************
+
+#if (USE_DELEGATE_TYPE == DELEGATE_TYPE_INTERNAL)
+
+// NULL structure used in dummy constructor
+delegate_gcc_mfp_internal delegate_gcc_mfp_null;
+
+
+//-------------------------------------------------
+//  delegate_convert_raw - given an object and
+//  an raw function, adjust the object base and
+//  return the actual final code pointer
+//-------------------------------------------------
+
+delegate_generic_function delegate_convert_raw(delegate_generic_class *&object, delegate_gcc_mfp_internal &mfp)
+{
+	// apply the "this" delta to the object first
+	object = reinterpret_cast<delegate_generic_class *>(reinterpret_cast<UINT8 *>(object) + mfp.this_delta);
+
+	// if the low bit of the vtable index is clear, then it is just a raw function pointer
+	if (!(mfp.u.vtable_index & 1))
+		return mfp.u.funcptr;
+
+	// otherwise, it is the byte index into the vtable where the actual function lives
+	UINT8 *vtable_base = *reinterpret_cast<UINT8 **>(object);
+	return *reinterpret_cast<delegate_generic_function *>(vtable_base + mfp.u.vtable_index - 1);
+} 
+
+#endif

src/emu/devcpu.c

@@ -78,6 +78,8 @@ legacy_cpu_device_config::legacy_cpu_device_config(const machine_config &mconfig
 		m_space_config[spacenum].m_addrbus_width = get_legacy_config_int(DEVINFO_INT_ADDRBUS_WIDTH + spacenum);
 		m_space_config[spacenum].m_addrbus_shift = get_legacy_config_int(DEVINFO_INT_ADDRBUS_SHIFT + spacenum);
 		m_space_config[spacenum].m_logaddr_width = get_legacy_config_int(CPUINFO_INT_LOGADDR_WIDTH + spacenum);
+		if (m_space_config[spacenum].m_logaddr_width == 0)
+			m_space_config[spacenum].m_logaddr_width = m_space_config[spacenum].m_addrbus_width;
 		m_space_config[spacenum].m_page_shift = get_legacy_config_int(CPUINFO_INT_PAGE_SHIFT + spacenum);
 		m_space_config[spacenum].m_internal_map = reinterpret_cast<address_map_constructor>(get_legacy_config_fct(DEVINFO_PTR_INTERNAL_MEMORY_MAP + spacenum));
 		m_space_config[spacenum].m_default_map = reinterpret_cast<address_map_constructor>(get_legacy_config_fct(DEVINFO_PTR_DEFAULT_MEMORY_MAP + spacenum));

src/emu/devintrf.h

@@ -347,7 +347,7 @@ protected:
 // ======================> device_t
 
 // device_t represents a device that is live and attached to a running_machine
-class device_t
+class device_t : public bindable_object
 {
 	DISABLE_COPYING(device_t);
 

src/emu/dimemory.c

@@ -191,7 +191,7 @@ bool device_config_memory_interface::interface_validity_check(const game_driver
 			::address_map *map = global_alloc(::address_map(*devconfig, spacenum));
 
 			// if this is an empty map, just skip it
-			if (map->m_entrylist == NULL)
+			if (map->m_entrylist.first() == NULL)
 			{
 				global_free(map);
 				continue;
@@ -210,7 +210,7 @@ bool device_config_memory_interface::interface_validity_check(const game_driver
 			}
 
 			// loop over entries and look for errors
-			for (address_map_entry *entry = map->m_entrylist; entry != NULL; entry = entry->m_next)
+			for (address_map_entry *entry = map->m_entrylist.first(); entry != NULL; entry = entry->next())
 			{
 				UINT32 bytestart = spaceconfig->addr2byte(entry->m_addrstart);
 				UINT32 byteend = spaceconfig->addr2byte_end(entry->m_addrend);
@@ -219,12 +219,12 @@ bool device_config_memory_interface::interface_validity_check(const game_driver
 				if (!detected_overlap)
 				{
 					address_map_entry *scan;
-					for (scan = map->m_entrylist; scan != entry; scan = scan->m_next)
+					for (scan = map->m_entrylist.first(); scan != entry; scan = scan->next())
 						if (entry->m_addrstart <= scan->m_addrend && entry->m_addrend >= scan->m_addrstart &&
-							((entry->m_read.type != AMH_NONE && scan->m_read.type != AMH_NONE) ||
+							((entry->m_read.m_type != AMH_NONE && scan->m_read.m_type != AMH_NONE) ||
-							 (entry->m_write.type != AMH_NONE && scan->m_write.type != AMH_NONE)))
+							 (entry->m_write.m_type != AMH_NONE && scan->m_write.m_type != AMH_NONE)))
 						{
-							mame_printf_warning("%s: %s '%s' %s space has overlapping memory (%X-%X,%d,%d) vs (%X-%X,%d,%d)\n", driver.source_file, driver.name, devconfig->tag(), spaceconfig->m_name, entry->m_addrstart, entry->m_addrend, entry->m_read.type, entry->m_write.type, scan->m_addrstart, scan->m_addrend, scan->m_read.type, scan->m_write.type);
+							mame_printf_warning("%s: %s '%s' %s space has overlapping memory (%X-%X,%d,%d) vs (%X-%X,%d,%d)\n", driver.source_file, driver.name, devconfig->tag(), spaceconfig->m_name, entry->m_addrstart, entry->m_addrend, entry->m_read.m_type, entry->m_write.m_type, scan->m_addrstart, scan->m_addrend, scan->m_read.m_type, scan->m_write.m_type);
 							detected_overlap = true;
 							break;
 						}
@@ -245,7 +245,7 @@ bool device_config_memory_interface::interface_validity_check(const game_driver
 				}
 
 				// if this is a program space, auto-assign implicit ROM entries
-				if (entry->m_read.type == AMH_ROM && entry->m_region == NULL)
+				if (entry->m_read.m_type == AMH_ROM && entry->m_region == NULL)
 				{
 					entry->m_region = devconfig->tag();
 					entry->m_rgnoffs = entry->m_addrstart;
@@ -287,25 +287,25 @@ bool device_config_memory_interface::interface_validity_check(const game_driver
 				}
 
 				// make sure all devices exist
-				if ((entry->m_read.type == AMH_DEVICE_HANDLER && entry->m_read.tag != NULL && m_machine_config.m_devicelist.find(entry->m_read.tag) == NULL) ||
+				if ((entry->m_read.m_type == AMH_LEGACY_DEVICE_HANDLER && entry->m_read.m_tag != NULL && m_machine_config.m_devicelist.find(entry->m_read.m_tag) == NULL) ||
-					(entry->m_write.type == AMH_DEVICE_HANDLER && entry->m_write.tag != NULL && m_machine_config.m_devicelist.find(entry->m_write.tag) == NULL))
+					(entry->m_write.m_type == AMH_LEGACY_DEVICE_HANDLER && entry->m_write.m_tag != NULL && m_machine_config.m_devicelist.find(entry->m_write.m_tag) == NULL))
 				{
-					mame_printf_error("%s: %s device '%s' %s space memory map entry references nonexistant device '%s'\n", driver.source_file, driver.name, devconfig->tag(), spaceconfig->m_name, entry->m_write.tag);
+					mame_printf_error("%s: %s device '%s' %s space memory map entry references nonexistant device '%s'\n", driver.source_file, driver.name, devconfig->tag(), spaceconfig->m_name, entry->m_write.m_tag);
 					error = true;
 				}
 
 				// make sure ports exist
-//              if ((entry->m_read.type == AMH_PORT && entry->m_read.tag != NULL && portlist.find(entry->m_read.tag) == NULL) ||
+//              if ((entry->m_read.m_type == AMH_PORT && entry->m_read.m_tag != NULL && portlist.find(entry->m_read.m_tag) == NULL) ||
-//                  (entry->m_write.type == AMH_PORT && entry->m_write.tag != NULL && portlist.find(entry->m_write.tag) == NULL))
+//                  (entry->m_write.m_type == AMH_PORT && entry->m_write.m_tag != NULL && portlist.find(entry->m_write.m_tag) == NULL))
 //              {
 //                  mame_printf_error("%s: %s device '%s' %s space memory map entry references nonexistant port tag '%s'\n", driver.source_file, driver.name, devconfig->tag(), spaceconfig->m_name, entry->m_read.tag);
 //                  error = true;
 //              }
 
 				// validate bank and share tags
-				if (entry->m_read.type == AMH_BANK && !validate_tag(&driver, "bank", entry->m_read.tag))
+				if (entry->m_read.m_type == AMH_BANK && !validate_tag(&driver, "bank", entry->m_read.m_tag))
 					error = true ;
-				if (entry->m_write.type == AMH_BANK && !validate_tag(&driver, "bank", entry->m_write.tag))
+				if (entry->m_write.m_type == AMH_BANK && !validate_tag(&driver, "bank", entry->m_write.m_tag))
 					error = true;
 				if (entry->m_share != NULL && !validate_tag(&driver, "share", entry->m_share))
 					error = true;
@@ -350,10 +350,10 @@ device_memory_interface::~device_memory_interface()
 //  to a device
 //-------------------------------------------------
 
-void device_memory_interface::set_address_space(int spacenum, const address_space *space)
+void device_memory_interface::set_address_space(int spacenum, address_space &space)
 {
 	assert(spacenum < ARRAY_LENGTH(m_addrspace));
-	m_addrspace[spacenum] = space;
+	m_addrspace[spacenum] = &space;
 }
 
 

src/emu/dimemory.h

@@ -100,48 +100,6 @@ const int TRANSLATE_FETCH_DEBUG		= (TRANSLATE_FETCH | TRANSLATE_DEBUG_MASK);
 //  TYPE DEFINITIONS
 //**************************************************************************
 
-// ======================> address_space_config
-
-class address_space_config
-{
-public:
-	address_space_config();
-	address_space_config(const char *name, endianness_t endian, UINT8 datawidth, UINT8 addrwidth, INT8 addrshift = 0, address_map_constructor internal = NULL, address_map_constructor defmap = NULL);
-	address_space_config(const char *name, endianness_t endian, UINT8 datawidth, UINT8 addrwidth, INT8 addrshift, UINT8 logwidth, UINT8 pageshift, address_map_constructor internal = NULL, address_map_constructor defmap = NULL);
-
-	inline offs_t addr2byte(offs_t address) const
-	{
-		return (m_addrbus_shift < 0) ? (address << -m_addrbus_shift) : (address >> m_addrbus_shift);
-	}
-
-	inline offs_t addr2byte_end(offs_t address) const
-	{
-		return (m_addrbus_shift < 0) ? ((address << -m_addrbus_shift) | ((1 << -m_addrbus_shift) - 1)) : (address >> m_addrbus_shift);
-	}
-
-	inline offs_t byte2addr(offs_t address) const
-	{
-		return (m_addrbus_shift > 0) ? (address << m_addrbus_shift) : (address >> -m_addrbus_shift);
-	}
-
-	inline offs_t byte2addr_end(offs_t address) const
-	{
-		return (m_addrbus_shift > 0) ? ((address << m_addrbus_shift) | ((1 << -m_addrbus_shift) - 1)) : (address >> -m_addrbus_shift);
-	}
-
-	const char *		m_name;
-	endianness_t		m_endianness;
-	UINT8				m_databus_width;
-	UINT8				m_addrbus_width;
-	INT8				m_addrbus_shift;
-	UINT8				m_logaddr_width;
-	UINT8				m_page_shift;
-	address_map_constructor m_internal_map;
-	address_map_constructor m_default_map;
-};
-
-
-
 // ======================> device_config_memory_interface
 
 // class representing interface-specific configuration state
@@ -187,11 +145,11 @@ public:
 
 	// basic information getters
 	const address_space_config *space_config(int spacenum = 0) const { return m_memory_config.space_config(spacenum); }
-	const address_space *space(int index = 0) const { return m_addrspace[index]; }
+	address_space *space(int index = 0) const { return m_addrspace[index]; }
-	const address_space *space(device_space index) const { return m_addrspace[static_cast<int>(index)]; }
+	address_space *space(device_space index) const { return m_addrspace[static_cast<int>(index)]; }
 
 	// address space accessors
-	void set_address_space(int spacenum, const address_space *space);
+	void set_address_space(int spacenum, address_space &space);
 
 	// address translation
 	bool translate(int spacenum, int intention, offs_t &address) { return memory_translate(spacenum, intention, address); }
@@ -212,7 +170,7 @@ protected:
 
 	// configuration
 	const device_config_memory_interface &m_memory_config;	// reference to our device_config_execute_interface
-	const address_space *	m_addrspace[ADDRESS_SPACES]; // reported address spaces
+	address_space *		m_addrspace[ADDRESS_SPACES]; // reported address spaces
 };
 
 

src/emu/emu.h

@@ -62,6 +62,7 @@
 #include "attotime.h"
 #include "fileio.h" // remove me once NVRAM is implemented as device
 #include "tokenize.h"
+#include "delegate.h"
 
 // memory and address spaces
 #include "memory.h"

src/emu/emu.mak

@@ -45,6 +45,7 @@ EMUOBJS = \
 	$(EMUOBJ)/config.o \
 	$(EMUOBJ)/crsshair.o \
 	$(EMUOBJ)/debugger.o \
+	$(EMUOBJ)/delegate.o \
 	$(EMUOBJ)/devcb.o \
 	$(EMUOBJ)/devcpu.o \
 	$(EMUOBJ)/devimage.o \

src/emu/emucore.h

@@ -355,6 +355,100 @@ inline _Dest crosscast(_Source *src)
 //  COMMON TEMPLATES
 //**************************************************************************
 
+// ======================> simple_list
+
+template<class T>
+class simple_list
+{
+	DISABLE_COPYING(simple_list);
+
+	T *m_head;
+	T *m_tail;
+	resource_pool &m_pool;
+	int m_count;
+
+public:
+	simple_list(resource_pool &pool = global_resource_pool) :
+		m_head(NULL),
+		m_tail(NULL),
+		m_pool(pool),
+		m_count(0) { }
+
+	virtual ~simple_list() { reset(); }
+
+	T *first() const { return m_head; }
+	T *last() const { return m_tail; }
+	int count() const { return m_count; }
+
+	void reset() { while (m_head != NULL) remove(*m_head); }
+
+	int index(T *object) const
+	{
+		int num = 0;
+		for (T *cur = m_head; cur != NULL; cur = cur->m_next)
+			if (cur == object)
+				return num;
+			else
+				num++;
+		return -1;
+	}
+	
+	T &prepend(T &object)
+	{
+		object.m_next = m_head;
+		m_head = &object;
+		if (m_tail == NULL)
+			m_tail = m_head;
+		m_count++;
+		return object;
+	}
+
+	T &append(T &object)
+	{
+		object.m_next = NULL;
+		if (m_tail != NULL)
+			m_tail = m_tail->m_next = &object;
+		else
+			m_tail = m_head = &object;
+		m_count++;
+		return object;
+	}
+
+	void detach(T &object)
+	{
+		T *prev = NULL;
+		for (T *cur = m_head; cur != NULL; prev = cur, cur = cur->m_next)
+			if (cur == &object)
+			{
+				if (prev != NULL)
+					prev->m_next = object.m_next;
+				else
+					m_head = object.m_next;
+				if (m_tail == &object)
+					m_tail = prev;
+				m_count--;
+				return;
+			}
+	}
+
+	void remove(T &object)
+	{
+		detach(object);
+		pool_free(m_pool, &object);
+	}
+
+	T *find(int index) const
+	{
+		for (T *cur = m_head; cur != NULL; cur = cur->m_next)
+			if (index-- == 0)
+				return cur;
+		return NULL;
+	}
+};
+
+
+// ======================> tagged_list
+
 template<class T>
 class tagged_list
 {

src/emu/machine.c

@@ -243,7 +243,7 @@ const char *running_machine::describe_context()
 	{
 		cpu_device *cpu = downcast<cpu_device *>(&executing->device());
 		if (cpu != NULL)
-			m_context.printf("'%s' (%s)", cpu->tag(), core_i64_hex_format(cpu->pc(), cpu->space(AS_PROGRAM)->logaddrchars));
+			m_context.printf("'%s' (%s)", cpu->tag(), core_i64_hex_format(cpu->pc(), cpu->space(AS_PROGRAM)->logaddrchars()));
 		else
 			m_context.printf("'%s'", cpu->tag());
 	}

src/emu/machine.h

@@ -158,7 +158,7 @@ typedef tagged_list<region_info> region_list;
 
 
 // base class for all driver data structures
-class driver_data_t
+class driver_data_t : public bindable_object
 {
 public:
 	driver_data_t(running_machine &machine);
@@ -271,7 +271,7 @@ public:
 
 
 // description of the currently-running machine
-class running_machine
+class running_machine : public bindable_object
 {
 	DISABLE_COPYING(running_machine);
 
@@ -346,6 +346,7 @@ public:
 
 	// CPU information
 	cpu_device *			firstcpu;			// first CPU (allows for quick iteration via typenext)
+	address_space *			m_nonspecific_space;// a dummy address_space used for legacy compatibility
 
 	// game-related information
 	const game_driver *		gamedrv;			// points to the definition of the game machine

src/emu/machine/generic.c

@@ -816,7 +816,7 @@ INTERRUPT_GEN( irq7_line_assert )	{ if (interrupt_enabled(device)) cpu_set_input
 -------------------------------------------------*/
 
 WRITE8_HANDLER( watchdog_reset_w ) { watchdog_reset(space->machine); }
-READ8_HANDLER( watchdog_reset_r ) { watchdog_reset(space->machine); return space->unmap; }
+READ8_HANDLER( watchdog_reset_r ) { watchdog_reset(space->machine); return space->unmap(); }
 
 
 /*-------------------------------------------------
@@ -824,7 +824,7 @@ READ8_HANDLER( watchdog_reset_r ) { watchdog_reset(space->machine); return space
 -------------------------------------------------*/
 
 WRITE16_HANDLER( watchdog_reset16_w ) {	watchdog_reset(space->machine); }
-READ16_HANDLER( watchdog_reset16_r ) { watchdog_reset(space->machine); return space->unmap; }
+READ16_HANDLER( watchdog_reset16_r ) { watchdog_reset(space->machine); return space->unmap(); }
 
 
 /*-------------------------------------------------
@@ -832,7 +832,7 @@ READ16_HANDLER( watchdog_reset16_r ) { watchdog_reset(space->machine); return sp
 -------------------------------------------------*/
 
 WRITE32_HANDLER( watchdog_reset32_w ) {	watchdog_reset(space->machine); }
-READ32_HANDLER( watchdog_reset32_r ) { watchdog_reset(space->machine); return space->unmap; }
+READ32_HANDLER( watchdog_reset32_r ) { watchdog_reset(space->machine); return space->unmap(); }
 
 
 

src/emu/machine/idectrl.c

@@ -1819,7 +1819,7 @@ static DEVICE_START( ide_controller )
 		ide->dma_space = memory->space(config->bmspace);
 		if (ide->dma_space == NULL)
 			throw emu_fatalerror("IDE controller '%s' bus master target '%s' does not have specified space %d!", device->tag(), config->bmcpu, config->bmspace);
-		ide->dma_address_xor = (ide->dma_space->endianness == ENDIANNESS_LITTLE) ? 0 : 3;
+		ide->dma_address_xor = (ide->dma_space->endianness() == ENDIANNESS_LITTLE) ? 0 : 3;
 	}
 
 	/* get and copy the geometry */

src/emu/sound/okim6295.c

@@ -159,7 +159,8 @@ okim6295_device::okim6295_device(running_machine &_machine, const okim6295_devic
 	  m_bank_installed(false),
 	  m_bank_offs(0),
 	  m_stream(NULL),
-	  m_pin7_state(m_config.m_pin7)
+	  m_pin7_state(m_config.m_pin7),
+	  m_direct(NULL)
 {
 }
 
@@ -170,6 +171,9 @@ okim6295_device::okim6295_device(running_machine &_machine, const okim6295_devic
 
 void okim6295_device::device_start()
 {
+	// find our direct access
+	m_direct = &space()->direct();
+
 	// create the stream
 	int divisor = m_config.m_pin7 ? 132 : 165;
 	m_stream = stream_create(this, 0, 1, clock() / divisor, this, static_stream_generate);
@@ -240,7 +244,7 @@ void okim6295_device::stream_generate(stream_sample_t **inputs, stream_sample_t
 
 	// iterate over voices and accumulate sample data
 	for (int voicenum = 0; voicenum < OKIM6295_VOICES; voicenum++)
-		m_voice[voicenum].generate_adpcm(space(), outputs[0], samples);
+		m_voice[voicenum].generate_adpcm(*m_direct, outputs[0], samples);
 }
 
 
@@ -289,10 +293,10 @@ void okim6295_device::set_pin7(int pin7)
 
 READ8_DEVICE_HANDLER( okim6295_r )
 {
-	return downcast<okim6295_device *>(device)->status_read();
+	return downcast<okim6295_device *>(device)->read(*device->machine->m_nonspecific_space, offset);
 }
 
-UINT8 okim6295_device::status_read()
+READ8_MEMBER( okim6295_device::read )
 {
 	UINT8 result = 0xf0;	// naname expects bits 4-7 to be 1
 
@@ -312,10 +316,10 @@ UINT8 okim6295_device::status_read()
 
 WRITE8_DEVICE_HANDLER( okim6295_w )
 {
-	downcast<okim6295_device *>(device)->data_write(data);
+	downcast<okim6295_device *>(device)->write(*device->machine->m_nonspecific_space, offset, data);
 }
 
-void okim6295_device::data_write(UINT8 data)
+WRITE8_MEMBER( okim6295_device::write )
 {
 	// if a command is pending, process the second half
 	if (m_command != -1)
@@ -337,14 +341,14 @@ void okim6295_device::data_write(UINT8 data)
 				// determine the start/stop positions
 				offs_t base = m_command * 8;
 
-				offs_t start = memory_raw_read_byte(space(), base + 0) << 16;
+				offs_t start = m_direct->read_raw_byte(base + 0) << 16;
-				start |= memory_raw_read_byte(space(), base + 1) << 8;
+				start |= m_direct->read_raw_byte(base + 1) << 8;
-				start |= memory_raw_read_byte(space(), base + 2) << 0;
+				start |= m_direct->read_raw_byte(base + 2) << 0;
 				start &= 0x3ffff;
 
-				offs_t stop = memory_raw_read_byte(space(), base + 3) << 16;
+				offs_t stop = m_direct->read_raw_byte(base + 3) << 16;
-				stop |= memory_raw_read_byte(space(), base + 4) << 8;
+				stop |= m_direct->read_raw_byte(base + 4) << 8;
-				stop |= memory_raw_read_byte(space(), base + 5) << 0;
+				stop |= m_direct->read_raw_byte(base + 5) << 0;
 				stop &= 0x3ffff;
 
 				// set up the voice to play this sample
@@ -420,7 +424,7 @@ okim6295_device::okim_voice::okim_voice()
 //  add them to an output stream
 //-------------------------------------------------
 
-void okim6295_device::okim_voice::generate_adpcm(const address_space *space, stream_sample_t *buffer, int samples)
+void okim6295_device::okim_voice::generate_adpcm(direct_read_data &direct, stream_sample_t *buffer, int samples)
 {
 	// skip if not active
 	if (!m_playing)
@@ -430,7 +434,7 @@ void okim6295_device::okim_voice::generate_adpcm(const address_space *space, str
 	while (samples-- != 0)
 	{
 		// fetch the next sample byte
-		int nibble = memory_raw_read_byte(space, m_base_offset + m_sample / 2) >> (((m_sample & 1) << 2) ^ 4);
+		int nibble = direct.read_raw_byte(m_base_offset + m_sample / 2) >> (((m_sample & 1) << 2) ^ 4);
 
 		// output to the buffer, scaling by the volume
 		// signal in range -2048..2047, volume in range 2..32 => signal * volume / 2 in range -32768..32767

src/emu/sound/okim6295.h

@@ -122,8 +122,8 @@ public:
 	void set_bank_base(offs_t base);
 	void set_pin7(int pin7);
 
-	UINT8 status_read();
+	DECLARE_READ8_MEMBER( read );
-	void data_write(UINT8 data);
+	DECLARE_WRITE8_MEMBER( write );
 
 protected:
 	// device-level overrides
@@ -141,7 +141,7 @@ protected:
 	{
 	public:
 		okim_voice();
-		void generate_adpcm(const address_space *space, stream_sample_t *buffer, int samples);
+		void generate_adpcm(direct_read_data &direct, stream_sample_t *buffer, int samples);
 
 		adpcm_state m_adpcm;			// current ADPCM state
 		bool		m_playing;
@@ -156,12 +156,13 @@ protected:
 
 	const okim6295_device_config &m_config;
 
-	okim_voice		m_voice[OKIM6295_VOICES];
+	okim_voice			m_voice[OKIM6295_VOICES];
-	INT32			m_command;
+	INT32				m_command;
-	bool			m_bank_installed;
+	bool				m_bank_installed;
-	offs_t			m_bank_offs;
+	offs_t				m_bank_offs;
-	sound_stream *	m_stream;
+	sound_stream *		m_stream;
-	UINT8			m_pin7_state;
+	UINT8				m_pin7_state;
+	direct_read_data *	m_direct;
 
 	static const UINT8 s_volume_table[16];
 };

src/mame/audio/williams.c

@@ -141,7 +141,7 @@ static ADDRESS_MAP_START( williams_adpcm_map, ADDRESS_SPACE_PROGRAM, 8 )
 	AM_RANGE(0x2000, 0x2000) AM_MIRROR(0x03ff) AM_WRITE(adpcm_bank_select_w)
 	AM_RANGE(0x2400, 0x2401) AM_MIRROR(0x03fe) AM_DEVREADWRITE("ymsnd", ym2151_r, ym2151_w)
 	AM_RANGE(0x2800, 0x2800) AM_MIRROR(0x03ff) AM_DEVWRITE("dac", dac_w)
-	AM_RANGE(0x2c00, 0x2c00) AM_MIRROR(0x03ff) AM_DEVREADWRITE("oki", okim6295_r, okim6295_w)
+	AM_RANGE(0x2c00, 0x2c00) AM_MIRROR(0x03ff) AM_DEVREADWRITE_MEMBER("oki", okim6295_device, read, write)
 	AM_RANGE(0x3000, 0x3000) AM_MIRROR(0x03ff) AM_READ(adpcm_command_r)
 	AM_RANGE(0x3400, 0x3400) AM_MIRROR(0x03ff) AM_DEVWRITE("oki", adpcm_6295_bank_select_w)
 	AM_RANGE(0x3c00, 0x3c00) AM_MIRROR(0x03ff) AM_WRITE(adpcm_talkback_w)

src/mame/drivers/atarig42.c

@@ -138,12 +138,12 @@ static WRITE16_HANDLER( mo_command_w )
  *
  *************************************/
 
-static DIRECT_UPDATE_HANDLER( sloop_direct_handler )
+DIRECT_UPDATE_HANDLER( atarig42_sloop_direct_handler )
 {
-	atarig42_state *state = space->machine->driver_data<atarig42_state>();
 	if (address < 0x80000)
 	{
-		direct->raw = direct->decrypted = (UINT8 *)state->sloop_base;
+		atarig42_state *state = machine->driver_data<atarig42_state>();
+		direct.explicit_configure(0x00000, 0x7ffff, 0x7ffff, state->sloop_base);
 		return (offs_t)-1;
 	}
 	return address;
@@ -696,8 +696,9 @@ static DRIVER_INIT( roadriot )
 	state->motion_object_base = 0x200;
 	state->motion_object_mask = 0x1ff;
 
-	state->sloop_base = memory_install_readwrite16_handler(cputag_get_address_space(machine, "maincpu", ADDRESS_SPACE_PROGRAM), 0x000000, 0x07ffff, 0, 0, roadriot_sloop_data_r, roadriot_sloop_data_w);
+	address_space *main = machine->device<m68000_device>("maincpu")->space(AS_PROGRAM);
-	memory_set_direct_update_handler(cputag_get_address_space(machine, "maincpu", ADDRESS_SPACE_PROGRAM), sloop_direct_handler);
+	state->sloop_base = memory_install_readwrite16_handler(main, 0x000000, 0x07ffff, 0, 0, roadriot_sloop_data_r, roadriot_sloop_data_w);
+	main->set_direct_update_handler(direct_update_delegate_create_static(atarig42_sloop_direct_handler, *machine));
 
 	asic65_config(machine, ASIC65_ROMBASED);
 /*
@@ -750,8 +751,9 @@ static DRIVER_INIT( guardian )
 	/* put an RTS there so we don't die */
 	*(UINT16 *)&memory_region(machine, "maincpu")[0x80000] = 0x4E75;
 
-	state->sloop_base = memory_install_readwrite16_handler(cputag_get_address_space(machine, "maincpu", ADDRESS_SPACE_PROGRAM), 0x000000, 0x07ffff, 0, 0, guardians_sloop_data_r, guardians_sloop_data_w);
+	address_space *main = machine->device<m68000_device>("maincpu")->space(AS_PROGRAM);
-	memory_set_direct_update_handler(cputag_get_address_space(machine, "maincpu", ADDRESS_SPACE_PROGRAM), sloop_direct_handler);
+	state->sloop_base = memory_install_readwrite16_handler(main, 0x000000, 0x07ffff, 0, 0, guardians_sloop_data_r, guardians_sloop_data_w);
+	main->set_direct_update_handler(direct_update_delegate_create_static(atarig42_sloop_direct_handler, *machine));
 
 	asic65_config(machine, ASIC65_GUARDIANS);
 /*

src/mame/drivers/atarisy2.c

@@ -208,14 +208,13 @@ static void scanline_update(screen_device &screen, int scanline)
  *
  *************************************/
 
-static DIRECT_UPDATE_HANDLER( atarisy2_direct_handler )
+DIRECT_UPDATE_HANDLER( atarisy2_direct_handler )
 {
-	atarisy2_state *state = space->machine->driver_data<atarisy2_state>();
-
 	/* make sure slapstic area looks like ROM */
 	if (address >= 0x8000 && address < 0x8200)
 	{
-		direct->raw = direct->decrypted = (UINT8 *)state->slapstic_base - 0x8000;
+		atarisy2_state *state = machine->driver_data<atarisy2_state>();
+		direct.explicit_configure(0x8000, 0x81ff, 0x1ff, (UINT8 *)state->slapstic_base);
 		return ~0;
 	}
 	return address;
@@ -245,7 +244,9 @@ static MACHINE_RESET( atarisy2 )
 	atarigen_interrupt_reset(state, update_interrupts);
 	atarigen_sound_io_reset(machine->device("soundcpu"));
 	atarigen_scanline_timer_reset(*machine->primary_screen, scanline_update, 64);
-	memory_set_direct_update_handler(cputag_get_address_space(machine, "maincpu", ADDRESS_SPACE_PROGRAM), atarisy2_direct_handler);
+
+	address_space *main = machine->device<t11_device>("maincpu")->space(AS_PROGRAM);
+	main->set_direct_update_handler(direct_update_delegate_create_static(atarisy2_direct_handler, *machine));
 
 	state->p2portwr_state = 0;
 	state->p2portrd_state = 0;

src/mame/drivers/beathead.c

@@ -98,9 +98,6 @@
 
 
 #include "emu.h"
-#include "cpu/asap/asap.h"
-#include "machine/atarigen.h"
-#include "audio/atarijsa.h"
 #include "includes/beathead.h"
 
 
@@ -115,8 +112,6 @@
  *
  *************************************/
 
-static void update_interrupts(running_machine *machine);
-
 static TIMER_DEVICE_CALLBACK( scanline_callback )
 {
 	beathead_state *state = timer.machine->driver_data<beathead_state>();
@@ -135,11 +130,11 @@ static TIMER_DEVICE_CALLBACK( scanline_callback )
 		scanline = 0;
 
 	/* set the scanline IRQ */
-	state->irq_state[2] = 1;
+	state->m_irq_state[2] = 1;
-	update_interrupts(timer.machine);
+	state->update_interrupts();
 
 	/* set the timer for the next one */
-	timer.adjust(double_to_attotime(attotime_to_double(timer.machine->primary_screen->time_until_pos(scanline)) - state->hblank_offset), scanline);
+	timer.adjust(double_to_attotime(attotime_to_double(timer.machine->primary_screen->time_until_pos(scanline)) - state->m_hblank_offset), scanline);
 }
 
 
@@ -149,6 +144,7 @@ static MACHINE_START( beathead )
 }
 
 
+static void update_interrupts(running_machine *machine) { machine->driver_data<beathead_state>()->update_interrupts(); }
 static MACHINE_RESET( beathead )
 {
 	beathead_state *state = machine->driver_data<beathead_state>();
@@ -160,17 +156,17 @@ static MACHINE_RESET( beathead )
 
 	/* the code is temporarily mapped at 0 at startup */
 	/* just copying the first 0x40 bytes is sufficient */
-	memcpy(state->ram_base, state->rom_base, 0x40);
+	memcpy(state->m_ram_base, state->m_rom_base, 0x40);
 
 	/* compute the timing of the HBLANK interrupt and set the first timer */
-	state->hblank_offset = attotime_to_double(machine->primary_screen->scan_period()) * ((455. - 336. - 25.) / 455.);
+	state->m_hblank_offset = attotime_to_double(machine->primary_screen->scan_period()) * ((455. - 336. - 25.) / 455.);
 	timer_device *scanline_timer = machine->device<timer_device>("scan_timer");
-	scanline_timer->adjust(double_to_attotime(attotime_to_double(machine->primary_screen->time_until_pos(0)) - state->hblank_offset));
+	scanline_timer->adjust(double_to_attotime(attotime_to_double(machine->primary_screen->time_until_pos(0)) - state->m_hblank_offset));
 
 	/* reset IRQs */
-	state->irq_line_state = CLEAR_LINE;
+	state->m_irq_line_state = CLEAR_LINE;
-	state->irq_state[0] = state->irq_state[1] = state->irq_state[2] = 0;
+	state->m_irq_state[0] = state->m_irq_state[1] = state->m_irq_state[2] = 0;
-	state->irq_enable[0] = state->irq_enable[1] = state->irq_enable[2] = 0;
+	state->m_irq_enable[0] = state->m_irq_enable[1] = state->m_irq_enable[2] = 0;
 }
 
 
@@ -181,54 +177,50 @@ static MACHINE_RESET( beathead )
  *
  *************************************/
 
-static void update_interrupts(running_machine *machine)
+void beathead_state::update_interrupts()
 {
-	beathead_state *state = machine->driver_data<beathead_state>();
 	int gen_int;
 
 	/* compute the combined interrupt signal */
-	gen_int  = state->irq_state[0] & state->irq_enable[0];
+	gen_int  = m_irq_state[0] & m_irq_enable[0];
-	gen_int |= state->irq_state[1] & state->irq_enable[1];
+	gen_int |= m_irq_state[1] & m_irq_enable[1];
-	gen_int |= state->irq_state[2] & state->irq_enable[2];
+	gen_int |= m_irq_state[2] & m_irq_enable[2];
 	gen_int  = gen_int ? ASSERT_LINE : CLEAR_LINE;
 
 	/* if it's changed since the last time, call through */
-	if (state->irq_line_state != gen_int)
+	if (m_irq_line_state != gen_int)
 	{
-		state->irq_line_state = gen_int;
+		m_irq_line_state = gen_int;
-		//if (state->irq_line_state != CLEAR_LINE)
+		//if (m_irq_line_state != CLEAR_LINE)
-			cputag_set_input_line(machine, "maincpu", ASAP_IRQ0, state->irq_line_state);
+			cputag_set_input_line(&m_machine, "maincpu", ASAP_IRQ0, m_irq_line_state);
 		//else
-			//asap_set_irq_line(ASAP_IRQ0, state->irq_line_state);
+			//asap_set_irq_line(ASAP_IRQ0, m_irq_line_state);
 	}
 }
 
 
-static WRITE32_HANDLER( interrupt_control_w )
+WRITE32_MEMBER( beathead_state::interrupt_control_w )
 {
-	beathead_state *state = space->machine->driver_data<beathead_state>();
 	int irq = offset & 3;
 	int control = (offset >> 2) & 1;
 
 	/* offsets 1-3 seem to be the enable latches for the IRQs */
 	if (irq != 0)
-		state->irq_enable[irq - 1] = control;
+		m_irq_enable[irq - 1] = control;
 
 	/* offset 0 seems to be the interrupt ack */
 	else
-		state->irq_state[0] = state->irq_state[1] = state->irq_state[2] = 0;
+		m_irq_state[0] = m_irq_state[1] = m_irq_state[2] = 0;
 
 	/* update the current state */
-	update_interrupts(space->machine);
+	update_interrupts();
 }
 
 
-static READ32_HANDLER( interrupt_control_r )
+READ32_MEMBER( beathead_state::interrupt_control_r )
 {
-	beathead_state *state = space->machine->driver_data<beathead_state>();
-
 	/* return the enables as a bitfield */
-	return (state->irq_enable[0]) | (state->irq_enable[1] << 1) | (state->irq_enable[2] << 2);
+	return (m_irq_enable[0]) | (m_irq_enable[1] << 1) | (m_irq_enable[2] << 2);
 }
 
 
@@ -239,24 +231,20 @@ static READ32_HANDLER( interrupt_control_r )
  *
  *************************************/
 
-static WRITE32_HANDLER( eeprom_data_w )
+WRITE32_MEMBER( beathead_state::eeprom_data_w )
 {
-	beathead_state *state = space->machine->driver_data<beathead_state>();
+	if (m_eeprom_enabled)
-
-	if (state->eeprom_enabled)
 	{
 		mem_mask &= 0x000000ff;
-		COMBINE_DATA(space->machine->generic.nvram.u32 + offset);
+		COMBINE_DATA(m_machine.generic.nvram.u32 + offset);
-		state->eeprom_enabled = 0;
+		m_eeprom_enabled = 0;
 	}
 }
 
 
-static WRITE32_HANDLER( eeprom_enable_w )
+WRITE32_MEMBER( beathead_state::eeprom_enable_w )
 {
-	beathead_state *state = space->machine->driver_data<beathead_state>();
+	m_eeprom_enabled = 1;
-
-	state->eeprom_enabled = 1;
 }
 
 
@@ -267,12 +255,11 @@ static WRITE32_HANDLER( eeprom_enable_w )
  *
  *************************************/
 
-static READ32_HANDLER( input_2_r )
+READ32_MEMBER( beathead_state::input_2_r )
 {
-	beathead_state *state = space->machine->driver_data<beathead_state>();
+	int result = input_port_read(&m_machine, "IN2");
-	int result = input_port_read(space->machine, "IN2");
+	if (sound_to_cpu_ready) result ^= 0x10;
-	if (state->sound_to_cpu_ready) result ^= 0x10;
+	if (cpu_to_sound_ready) result ^= 0x20;
-	if (state->cpu_to_sound_ready) result ^= 0x20;
 	return result;
 }
 
@@ -284,23 +271,23 @@ static READ32_HANDLER( input_2_r )
  *
  *************************************/
 
-static READ32_HANDLER( sound_data_r )
+READ32_MEMBER( beathead_state::sound_data_r )
 {
-	return atarigen_sound_r(space,offset,0xffff);
+	return atarigen_sound_r(&space, offset, 0xffff);
 }
 
 
-static WRITE32_HANDLER( sound_data_w )
+WRITE32_MEMBER( beathead_state::sound_data_w )
 {
 	if (ACCESSING_BITS_0_7)
-		atarigen_sound_w(space,offset, data, mem_mask);
+		atarigen_sound_w(&space, offset, data, mem_mask);
 }
 
 
-static WRITE32_HANDLER( sound_reset_w )
+WRITE32_MEMBER( beathead_state::sound_reset_w )
 {
 	logerror("Sound reset = %d\n", !offset);
-	cputag_set_input_line(space->machine, "jsa", INPUT_LINE_RESET, offset ? CLEAR_LINE : ASSERT_LINE);
+	cputag_set_input_line(&m_machine, "jsa", INPUT_LINE_RESET, offset ? CLEAR_LINE : ASSERT_LINE);
 }
 
 
@@ -311,9 +298,9 @@ static WRITE32_HANDLER( sound_reset_w )
  *
  *************************************/
 
-static WRITE32_HANDLER( coin_count_w )
+WRITE32_MEMBER( beathead_state::coin_count_w )
 {
-	coin_counter_w(space->machine, 0, !offset);
+	coin_counter_w(&m_machine, 0, !offset);
 }
 
 
@@ -325,31 +312,31 @@ static WRITE32_HANDLER( coin_count_w )
  *************************************/
 
 static ADDRESS_MAP_START( main_map, ADDRESS_SPACE_PROGRAM, 32 )
-	AM_RANGE(0x00000000, 0x0001ffff) AM_RAM AM_BASE_MEMBER(beathead_state, ram_base)
+	AM_RANGE(0x00000000, 0x0001ffff) AM_RAM AM_BASE_MEMBER(beathead_state, m_ram_base)
-	AM_RANGE(0x01800000, 0x01bfffff) AM_ROM AM_REGION("user1", 0) AM_BASE_MEMBER(beathead_state, rom_base)
+	AM_RANGE(0x01800000, 0x01bfffff) AM_ROM AM_REGION("user1", 0) AM_BASE_MEMBER(beathead_state, m_rom_base)
-	AM_RANGE(0x40000000, 0x400007ff) AM_RAM_WRITE(eeprom_data_w) AM_BASE_SIZE_GENERIC(nvram)
+	AM_RANGE(0x40000000, 0x400007ff) AM_RAM_WRITE_MEMBER(beathead_state, eeprom_data_w) AM_BASE_SIZE_GENERIC(nvram)
-	AM_RANGE(0x41000000, 0x41000003) AM_READWRITE(sound_data_r, sound_data_w)
+	AM_RANGE(0x41000000, 0x41000003) AM_READWRITE_MEMBER(beathead_state, sound_data_r, sound_data_w)
-	AM_RANGE(0x41000100, 0x41000103) AM_READ(interrupt_control_r)
+	AM_RANGE(0x41000100, 0x41000103) AM_READ_MEMBER(beathead_state, interrupt_control_r)
-	AM_RANGE(0x41000100, 0x4100011f) AM_WRITE(interrupt_control_w)
+	AM_RANGE(0x41000100, 0x4100011f) AM_WRITE_MEMBER(beathead_state, interrupt_control_w)
 	AM_RANGE(0x41000200, 0x41000203) AM_READ_PORT("IN1")
 	AM_RANGE(0x41000204, 0x41000207) AM_READ_PORT("IN0")
-	AM_RANGE(0x41000208, 0x4100020f) AM_WRITE(sound_reset_w)
+	AM_RANGE(0x41000208, 0x4100020f) AM_WRITE_MEMBER(beathead_state, sound_reset_w)
-	AM_RANGE(0x41000220, 0x41000227) AM_WRITE(coin_count_w)
+	AM_RANGE(0x41000220, 0x41000227) AM_WRITE_MEMBER(beathead_state, coin_count_w)
-	AM_RANGE(0x41000300, 0x41000303) AM_READ(input_2_r)
+	AM_RANGE(0x41000300, 0x41000303) AM_READ_MEMBER(beathead_state, input_2_r)
 	AM_RANGE(0x41000304, 0x41000307) AM_READ_PORT("IN3")
-	AM_RANGE(0x41000400, 0x41000403) AM_WRITEONLY AM_BASE_MEMBER(beathead_state, palette_select)
+	AM_RANGE(0x41000400, 0x41000403) AM_WRITEONLY AM_BASE_MEMBER(beathead_state, m_palette_select)
-	AM_RANGE(0x41000500, 0x41000503) AM_WRITE(eeprom_enable_w)
+	AM_RANGE(0x41000500, 0x41000503) AM_WRITE_MEMBER(beathead_state, eeprom_enable_w)
-	AM_RANGE(0x41000600, 0x41000603) AM_WRITE(beathead_finescroll_w)
+	AM_RANGE(0x41000600, 0x41000603) AM_WRITE_MEMBER(beathead_state, finescroll_w)
 	AM_RANGE(0x41000700, 0x41000703) AM_WRITE(watchdog_reset32_w)
-	AM_RANGE(0x42000000, 0x4201ffff) AM_RAM_WRITE(beathead_palette_w) AM_BASE_GENERIC(paletteram)
+	AM_RANGE(0x42000000, 0x4201ffff) AM_RAM_WRITE_MEMBER(beathead_state, palette_w) AM_BASE_MEMBER(beathead_state, m_paletteram)
-	AM_RANGE(0x43000000, 0x43000007) AM_READWRITE(beathead_hsync_ram_r, beathead_hsync_ram_w)
+	AM_RANGE(0x43000000, 0x43000007) AM_READWRITE_MEMBER(beathead_state, hsync_ram_r, hsync_ram_w)
 	AM_RANGE(0x8df80000, 0x8df80003) AM_READNOP	/* noisy x4 during scanline int */
-	AM_RANGE(0x8f380000, 0x8f3fffff) AM_WRITE(beathead_vram_latch_w)
+	AM_RANGE(0x8f380000, 0x8f3fffff) AM_WRITE_MEMBER(beathead_state, vram_latch_w)
-	AM_RANGE(0x8f900000, 0x8f97ffff) AM_WRITE(beathead_vram_transparent_w)
+	AM_RANGE(0x8f900000, 0x8f97ffff) AM_WRITE_MEMBER(beathead_state, vram_transparent_w)
-	AM_RANGE(0x8f980000, 0x8f9fffff) AM_RAM AM_BASE_GENERIC(videoram)
+	AM_RANGE(0x8f980000, 0x8f9fffff) AM_RAM AM_BASE_MEMBER(beathead_state, m_videoram)
-	AM_RANGE(0x8fb80000, 0x8fbfffff) AM_WRITE(beathead_vram_bulk_w)
+	AM_RANGE(0x8fb80000, 0x8fbfffff) AM_WRITE_MEMBER(beathead_state, vram_bulk_w)
-	AM_RANGE(0x8fff8000, 0x8fff8003) AM_WRITEONLY AM_BASE_MEMBER(beathead_state, vram_bulk_latch)
+	AM_RANGE(0x8fff8000, 0x8fff8003) AM_WRITEONLY AM_BASE_MEMBER(beathead_state, m_vram_bulk_latch)
-	AM_RANGE(0x9e280000, 0x9e2fffff) AM_WRITE(beathead_vram_copy_w)
+	AM_RANGE(0x9e280000, 0x9e2fffff) AM_WRITE_MEMBER(beathead_state, vram_copy_w)
 ADDRESS_MAP_END
 
 
@@ -480,26 +467,24 @@ ROM_END
 */
 
 
-static UINT32 *speedup_data;
+READ32_MEMBER( beathead_state::speedup_r )
-static READ32_HANDLER( speedup_r )
 {
-	int result = *speedup_data;
+	int result = *m_speedup_data;
-	if ((cpu_get_previouspc(space->cpu) & 0xfffff) == 0x006f0 && result == cpu_get_reg(space->cpu, ASAP_R3))
+	if ((cpu_get_previouspc(space.cpu) & 0xfffff) == 0x006f0 && result == cpu_get_reg(space.cpu, ASAP_R3))
-		cpu_spinuntil_int(space->cpu);
+		cpu_spinuntil_int(space.cpu);
 	return result;
 }
 
 
-static UINT32 *movie_speedup_data;
+READ32_MEMBER( beathead_state::movie_speedup_r )
-static READ32_HANDLER( movie_speedup_r )
 {
-	int result = *movie_speedup_data;
+	int result = *m_movie_speedup_data;
-	if ((cpu_get_previouspc(space->cpu) & 0xfffff) == 0x00a88 && (cpu_get_reg(space->cpu, ASAP_R28) & 0xfffff) == 0x397c0 &&
+	if ((cpu_get_previouspc(space.cpu) & 0xfffff) == 0x00a88 && (cpu_get_reg(space.cpu, ASAP_R28) & 0xfffff) == 0x397c0 &&
-		movie_speedup_data[4] == cpu_get_reg(space->cpu, ASAP_R1))
+		m_movie_speedup_data[4] == cpu_get_reg(space.cpu, ASAP_R1))
 	{
-		UINT32 temp = (INT16)result + movie_speedup_data[4] * 262;
+		UINT32 temp = (INT16)result + m_movie_speedup_data[4] * 262;
-		if (temp - (UINT32)cpu_get_reg(space->cpu, ASAP_R15) < (UINT32)cpu_get_reg(space->cpu, ASAP_R23))
+		if (temp - (UINT32)cpu_get_reg(space.cpu, ASAP_R15) < (UINT32)cpu_get_reg(space.cpu, ASAP_R23))
-			cpu_spinuntil_int(space->cpu);
+			cpu_spinuntil_int(space.cpu);
 	}
 	return result;
 }
@@ -514,12 +499,14 @@ static READ32_HANDLER( movie_speedup_r )
 
 static DRIVER_INIT( beathead )
 {
+	beathead_state *state = machine->driver_data<beathead_state>();
+
 	/* initialize the common systems */
 	atarijsa_init(machine, "IN2", 0x0040);
 
 	/* prepare the speedups */
-	speedup_data = memory_install_read32_handler(cputag_get_address_space(machine, "maincpu", ADDRESS_SPACE_PROGRAM), 0x00000ae8, 0x00000aeb, 0, 0, speedup_r);
+	state->m_speedup_data = state->m_maincpu.space(AS_PROGRAM)->install_handler(0x00000ae8, 0x00000aeb, 0, 0, read32_delegate_create(beathead_state, speedup_r, *state));
-	movie_speedup_data = memory_install_read32_handler(cputag_get_address_space(machine, "maincpu", ADDRESS_SPACE_PROGRAM), 0x00000804, 0x00000807, 0, 0, movie_speedup_r);
+	state->m_movie_speedup_data = state->m_maincpu.space(AS_PROGRAM)->install_handler(0x00000804, 0x00000807, 0, 0, read32_delegate_create(beathead_state, movie_speedup_r, *state));
 }
 
 

src/mame/drivers/cps3.c

@@ -607,7 +607,7 @@ INLINE void cps3_drawgfxzoom(bitmap_t *dest_bmp,const rectangle *clip,const gfx_
 
 
 
-static DIRECT_UPDATE_HANDLER( cps3_direct_handler );
+DIRECT_UPDATE_HANDLER( cps3_direct_handler );
 
 /* Encryption */
 
@@ -706,7 +706,9 @@ static DRIVER_INIT( cps3 )
 
 
 	cps3_0xc0000000_ram_decrypted = auto_alloc_array(machine, UINT32, 0x400/4);
-	memory_set_direct_update_handler(cputag_get_address_space(machine, "maincpu", ADDRESS_SPACE_PROGRAM), cps3_direct_handler);
+
+	address_space *main = machine->device<sh2_device>("maincpu")->space(AS_PROGRAM);
+	main->set_direct_update_handler(direct_update_delegate_create_static(cps3_direct_handler, *machine));
 
 	// flash roms
 
@@ -1263,38 +1265,37 @@ static WRITE32_HANDLER( cps3_0xc0000000_ram_w )
 
 
 
-static DIRECT_UPDATE_HANDLER( cps3_direct_handler )
+DIRECT_UPDATE_HANDLER( cps3_direct_handler )
 {
 //  if(DEBUG_PRINTF) printf("address %04x\n",address);
 
 	/* BIOS ROM */
 	if (address < 0x80000)
 	{
-		direct->raw = direct->decrypted = memory_region(space->machine, "user1");
+		direct.explicit_configure(0x00000, 0x7ffff, 0x7ffff, *direct.space().m_machine.region("user1"));
 		return ~0;
 	}
 	/* RAM */
 	else if (address >= 0x06000000 && address <= 0x06ffffff)
 	{
-		direct->decrypted = (UINT8*)decrypted_gamerom-0x06000000;
+		UINT8 *decrypted = (UINT8*)decrypted_gamerom;
-		direct->raw = (UINT8*)decrypted_gamerom-0x06000000;
+		UINT8 *raw = decrypted;
 
-		if (cps3_altEncryption) direct->raw = (UINT8*) cps3_user4region-0x06000000;
+		if (cps3_altEncryption) raw = (UINT8*) cps3_user4region;
 
+		direct.explicit_configure(0x06000000, 0x06ffffff, 0x00ffffff, raw, decrypted);
 
 		return ~0;
 	}
 	else if (address >= 0xc0000000 && address <= 0xc00003ff)
 	{
 		//direct->decrypted = (void*)cps3_0xc0000000_ram_decrypted;
-		direct->decrypted = (UINT8*)cps3_0xc0000000_ram_decrypted-0xc0000000;
+		direct.explicit_configure(0xc0000000, 0xc00003ff, 0x3ff, (UINT8*)cps3_0xc0000000_ram, (UINT8*)cps3_0xc0000000_ram_decrypted);
-		direct->raw = (UINT8*)cps3_0xc0000000_ram-0xc0000000;
 		return ~0;
 	}
 
 	/* anything else falls through to NOPs */
-	direct->decrypted = (UINT8*)cps3_nops-address;
+	direct.explicit_configure(address, address, 0, (UINT8*)cps3_nops, (UINT8*)cps3_nops);
-	direct->raw = (UINT8*)cps3_nops-address;
 	return ~0;
 }
 

src/mame/drivers/hng64.c

@@ -1106,9 +1106,9 @@ ADDRESS_MAP_END
 #define KL5C_MMU_A(xxx) ( (xxx==0) ? 0x0000 : (hng64_com_mmu_mem[((xxx-1)*2)+1] << 2) | ((hng64_com_mmu_mem[(xxx-1)*2] & 0xc0) >> 6) )
 #define KL5C_MMU_B(xxx) ( (xxx==0) ? 0x0000 : (hng64_com_mmu_mem[(xxx-1)*2] & 0x3f) )
 
-static DIRECT_UPDATE_HANDLER( KL5C80_direct_handler )
+DIRECT_UPDATE_HANDLER( KL5C80_direct_handler )
 {
-	direct->raw = direct->decrypted = hng64_com_op_base;
+	direct.explicit_configure(0x0000, 0xffff, 0xffff, hng64_com_op_base);
 	return ~0;
 }
 
@@ -1677,7 +1677,9 @@ static MACHINE_RESET(hyperneo)
 		hng64_com_virtual_mem[i] = rom[i];
 
 	KL5C80_virtual_mem_sync();
-	memory_set_direct_update_handler(cputag_get_address_space(machine, "comm", ADDRESS_SPACE_PROGRAM), KL5C80_direct_handler);
+
+	address_space *space = machine->device<z80_device>("comm")->space(AS_PROGRAM);
+	space->set_direct_update_handler(direct_update_delegate_create_static(KL5C80_direct_handler, *machine));
 
 	cputag_set_input_line(machine, "comm", INPUT_LINE_RESET, PULSE_LINE);     // reset the CPU and let 'er rip
 //  cputag_set_input_line(machine, "comm", INPUT_LINE_HALT, ASSERT_LINE);     // hold on there pardner...

src/mame/drivers/missile.c

@@ -445,7 +445,7 @@ static TIMER_CALLBACK( adjust_cpu_speed )
 }
 
 
-static DIRECT_UPDATE_HANDLER( missile_direct_handler )
+DIRECT_UPDATE_HANDLER( missile_direct_handler )
 {
 	/* offset accounts for lack of A15 decoding */
 	int offset = address & 0x8000;
@@ -454,14 +454,14 @@ static DIRECT_UPDATE_HANDLER( missile_direct_handler )
 	/* RAM? */
 	if (address < 0x4000)
 	{
-		direct->raw = direct->decrypted = space->machine->generic.videoram.u8 - offset;
+		direct.explicit_configure(0x0000 | offset, 0x3fff | offset, 0x3fff, direct.space().m_machine.generic.videoram.u8);
 		return ~0;
 	}
 
 	/* ROM? */
 	else if (address >= 0x5000)
 	{
-		direct->raw = direct->decrypted = memory_region(space->machine, "maincpu") - offset;
+		direct.explicit_configure(0x5000 | offset, 0x7fff | offset, 0x7fff, direct.space().m_machine.region("maincpu")->base() + 0x5000);
 		return ~0;
 	}
 
@@ -477,7 +477,8 @@ static MACHINE_START( missile )
 	flipscreen = 0;
 
 	/* set up an opcode base handler since we use mapped handlers for RAM */
-	memory_set_direct_update_handler(cputag_get_address_space(machine, "maincpu", ADDRESS_SPACE_PROGRAM), missile_direct_handler);
+	address_space *space = machine->device<m6502_device>("maincpu")->space(AS_PROGRAM);
+	space->set_direct_update_handler(direct_update_delegate_create_static(missile_direct_handler, *machine));
 
 	/* create a timer to speed/slow the CPU */
 	cpu_timer = timer_alloc(machine, adjust_cpu_speed, NULL);

src/mame/drivers/plygonet.c

@@ -319,26 +319,26 @@ static READ16_HANDLER( dsp56k_bootload_r )
 	return 0x7fff;
 }
 
-static DIRECT_UPDATE_HANDLER( plygonet_dsp56k_direct_handler )
+DIRECT_UPDATE_HANDLER( plygonet_dsp56k_direct_handler )
 {
-	polygonet_state *state = space->machine->driver_data<polygonet_state>();
+	polygonet_state *state = machine->driver_data<polygonet_state>();
 
 	/* Call the dsp's update handler first */
-	if (state->dsp56k_update_handler != NULL)
+	if (!state->dsp56k_update_handler.isnull())
 	{
-		if ((*state->dsp56k_update_handler)(space, address, direct) == ~0)
+		if (state->dsp56k_update_handler(direct, address) == ~0)
 			return ~0;
 	}
 
 	/* If the requested region wasn't in there, see if it needs to be caught driver-side */
 	if (address >= (0x7000<<1) && address <= (0x7fff<<1))
 	{
-		direct->raw = direct->decrypted = (UINT8*)(state->dsp56k_p_mirror) - (0x7000<<1);
+		direct.explicit_configure(0x7000<<1, 0x7fff<<1, 0xfff<<1, state->dsp56k_p_mirror);
 		return ~0;
 	}
 	else if (address >= (0x8000<<1) && address <= (0x87ff<<1))
 	{
-		direct->raw = direct->decrypted = (UINT8*)(state->dsp56k_p_8000) - (0x8000<<1);
+		direct.explicit_configure(0x8000<<1, 0x87ff<<1, 0x7ff<<1, state->dsp56k_p_8000);
 		return ~0;
 	}
 
@@ -764,7 +764,8 @@ static DRIVER_INIT(polygonet)
 	state->dsp56k_bank04_ram    = auto_alloc_array_clear(machine, UINT16, 2 * 8 * dsp56k_bank04_size);
 
 	/* The dsp56k occasionally executes out of mapped memory */
-	state->dsp56k_update_handler = memory_set_direct_update_handler(cputag_get_address_space(machine, "dsp", ADDRESS_SPACE_PROGRAM), plygonet_dsp56k_direct_handler);
+	address_space *space = machine->device<dsp56k_device>("dsp")->space(AS_PROGRAM);
+	state->dsp56k_update_handler = space->set_direct_update_handler(direct_update_delegate_create_static(plygonet_dsp56k_direct_handler, *machine));
 
     /* save states */
 	state_save_register_global_pointer(machine, state->dsp56k_bank00_ram,    2 * 8 * dsp56k_bank00_size);

src/mame/drivers/starwars.c

@@ -127,12 +127,12 @@ static WRITE8_HANDLER( esb_slapstic_w )
  *
  *************************************/
 
-static DIRECT_UPDATE_HANDLER( esb_setdirect )
+DIRECT_UPDATE_HANDLER( esb_setdirect )
 {
 	/* if we are in the slapstic region, process it */
 	if ((address & 0xe000) == 0x8000)
 	{
-		offs_t pc = cpu_get_pc(space->cpu);
+		offs_t pc = cpu_get_pc(&direct.space().device());
 
 		/* filter out duplicates; we get these because the handler gets called for
            multiple reasons:
@@ -143,7 +143,7 @@ static DIRECT_UPDATE_HANDLER( esb_setdirect )
 		{
 			slapstic_last_pc = pc;
 			slapstic_last_address = address;
-			esb_slapstic_tweak(space, address & 0x1fff);
+			esb_slapstic_tweak(&direct.space(), address & 0x1fff);
 		}
 		return ~0;
 	}
@@ -527,7 +527,8 @@ static DRIVER_INIT( esb )
 	slapstic_base = &rom[0x08000];
 
 	/* install an opcode base handler */
-	memory_set_direct_update_handler(cputag_get_address_space(machine, "maincpu", ADDRESS_SPACE_PROGRAM), esb_setdirect);
+	address_space *space = machine->device<m6809_device>("maincpu")->space(AS_PROGRAM);
+	space->set_direct_update_handler(direct_update_delegate_create_static(esb_setdirect, *machine));
 
 	/* install read/write handlers for it */
 	memory_install_readwrite8_handler(cputag_get_address_space(machine, "maincpu", ADDRESS_SPACE_PROGRAM), 0x8000, 0x9fff, 0, 0, esb_slapstic_r, esb_slapstic_w);

src/mame/drivers/vcombat.c

@@ -389,21 +389,21 @@ static MACHINE_RESET( shadfgtr )
 }
 
 
-static DIRECT_UPDATE_HANDLER( vid_0_direct_handler )
+DIRECT_UPDATE_HANDLER( vcombat_vid_0_direct_handler )
 {
 	if (address >= 0xfffc0000 && address <= 0xffffffff)
 	{
-		direct->raw = direct->decrypted = ((UINT8*)vid_0_shared_RAM) - 0xfffc0000;
+		direct.explicit_configure(0xfffc0000, 0xffffffff, 0x3ffff, vid_0_shared_RAM);
 		return ~0;
 	}
 	return address;
 }
 
-static DIRECT_UPDATE_HANDLER( vid_1_direct_handler )
+DIRECT_UPDATE_HANDLER( vcombat_vid_1_direct_handler )
 {
 	if (address >= 0xfffc0000 && address <= 0xffffffff)
 	{
-		direct->raw = direct->decrypted = ((UINT8*)vid_1_shared_RAM) - 0xfffc0000;
+		direct.explicit_configure(0xfffc0000, 0xffffffff, 0x3ffff, vid_1_shared_RAM);
 		return ~0;
 	}
 	return address;
@@ -415,8 +415,11 @@ static DRIVER_INIT( vcombat )
 	UINT8 *ROM = memory_region(machine, "maincpu");
 
 	/* The two i860s execute out of RAM */
-	memory_set_direct_update_handler(cputag_get_address_space(machine, "vid_0", ADDRESS_SPACE_PROGRAM), vid_0_direct_handler);
+	address_space *space = machine->device<i860_device>("vid_0")->space(AS_PROGRAM);
-	memory_set_direct_update_handler(cputag_get_address_space(machine, "vid_1", ADDRESS_SPACE_PROGRAM), vid_1_direct_handler);
+	space->set_direct_update_handler(direct_update_delegate_create_static(vcombat_vid_0_direct_handler, *machine));
+
+	space = machine->device<i860_device>("vid_1")->space(AS_PROGRAM);
+	space->set_direct_update_handler(direct_update_delegate_create_static(vcombat_vid_1_direct_handler, *machine));
 
 	/* Allocate the 68000 framebuffers */
 	m68k_framebuffer[0] = auto_alloc_array(machine, UINT16, 0x8000);
@@ -459,7 +462,8 @@ static DRIVER_INIT( shadfgtr )
 	i860_framebuffer[1][1] = NULL;
 
 	/* The i860 executes out of RAM */
-	memory_set_direct_update_handler(cputag_get_address_space(machine, "vid_0", ADDRESS_SPACE_PROGRAM), vid_0_direct_handler);
+	address_space *space = machine->device<i860_device>("vid_0")->space(AS_PROGRAM);
+	space->set_direct_update_handler(direct_update_delegate_create_static(vcombat_vid_0_direct_handler, *machine));
 }
 
 

src/mame/drivers/vegas.c

@@ -1675,6 +1675,8 @@ static void remap_dynamic_addresses(running_machine *machine)
 
 	/* now remap everything */
 	if (LOG_DYNAMIC) logerror("remap_dynamic_addresses:\n");
+	address_space *space = const_cast<address_space *>(machine->device<cpu_device>("maincpu")->space(AS_PROGRAM));
+	assert(space != NULL);
 	for (addr = 0; addr < dynamic_count; addr++)
 	{
 		if (LOG_DYNAMIC) logerror("  installing: %08X-%08X %s,%s\n", dynamic[addr].start, dynamic[addr].end, dynamic[addr].rdname, dynamic[addr].wrname);
@@ -1682,12 +1684,15 @@ static void remap_dynamic_addresses(running_machine *machine)
 		if (dynamic[addr].mread == NOP_HANDLER)
 			memory_nop_read(cputag_get_address_space(machine, "maincpu", ADDRESS_SPACE_PROGRAM), dynamic[addr].start, dynamic[addr].end, 0, 0);
 		else if (dynamic[addr].mread != NULL)
-			_memory_install_handler32(cputag_get_address_space(machine, "maincpu", ADDRESS_SPACE_PROGRAM), dynamic[addr].start, dynamic[addr].end, 0, 0, dynamic[addr].mread, dynamic[addr].rdname, NULL, NULL, 0);
+			space->install_legacy_handler(dynamic[addr].start, dynamic[addr].end, 0, 0, dynamic[addr].mread, dynamic[addr].rdname);
 		if (dynamic[addr].mwrite != NULL)
-			_memory_install_handler32(cputag_get_address_space(machine, "maincpu", ADDRESS_SPACE_PROGRAM), dynamic[addr].start, dynamic[addr].end, 0, 0, NULL, NULL, dynamic[addr].mwrite, dynamic[addr].wrname, 0);
+			space->install_legacy_handler(dynamic[addr].start, dynamic[addr].end, 0, 0, dynamic[addr].mwrite, dynamic[addr].wrname);
 
 		if (dynamic[addr].dread != NULL || dynamic[addr].dwrite != NULL)
-			_memory_install_device_handler32(cputag_get_address_space(machine, "maincpu", ADDRESS_SPACE_PROGRAM), dynamic[addr].device, dynamic[addr].start, dynamic[addr].end, 0, 0, dynamic[addr].dread, dynamic[addr].rdname, dynamic[addr].dwrite, dynamic[addr].wrname, 0);
+		{
+			space->install_legacy_handler(*dynamic[addr].device, dynamic[addr].start, dynamic[addr].end, 0, 0, dynamic[addr].dread, dynamic[addr].rdname);
+			space->install_legacy_handler(*dynamic[addr].device, dynamic[addr].start, dynamic[addr].end, 0, 0, dynamic[addr].dwrite, dynamic[addr].wrname);
+		}
 	}
 
 	if (LOG_DYNAMIC)

src/mame/includes/beathead.h

@@ -5,6 +5,8 @@
 *************************************************************************/
 
 #include "machine/atarigen.h"
+#include "cpu/asap/asap.h"
+#include "audio/atarijsa.h"
 
 class beathead_state : public atarigen_state
 {
@@ -12,28 +14,61 @@ public:
 	static driver_data_t *alloc(running_machine &machine) { return auto_alloc_clear(&machine, beathead_state(machine)); }
 
 	beathead_state(running_machine &machine)
-		: atarigen_state(machine) { }
+		: atarigen_state(machine),
+		  m_maincpu(*machine.device<asap_device>("maincpu")) { }
+	
+	asap_device &	m_maincpu;
 
-	UINT32 *		vram_bulk_latch;
+	UINT32 *		m_videoram;
-	UINT32 *		palette_select;
+	UINT32 *		m_paletteram;
 
-	UINT32			finescroll;
+	UINT32 *		m_vram_bulk_latch;
-	offs_t			vram_latch_offset;
+	UINT32 *		m_palette_select;
 
-	offs_t			hsyncram_offset;
+	UINT32			m_finescroll;
-	offs_t			hsyncram_start;
+	offs_t			m_vram_latch_offset;
-	UINT8			hsyncram[0x800];
 
-	UINT32 *		ram_base;
+	offs_t			m_hsyncram_offset;
-	UINT32 *		rom_base;
+	offs_t			m_hsyncram_start;
+	UINT8			m_hsyncram[0x800];
 
-	double			hblank_offset;
+	UINT32 *		m_ram_base;
+	UINT32 *		m_rom_base;
 
-	UINT8			irq_line_state;
+	double			m_hblank_offset;
-	UINT8			irq_enable[3];
-	UINT8			irq_state[3];
 
-	UINT8			eeprom_enabled;
+	UINT8			m_irq_line_state;
+	UINT8			m_irq_enable[3];
+	UINT8			m_irq_state[3];
+
+	UINT8			m_eeprom_enabled;
+
+	UINT32 *		m_speedup_data;
+	UINT32 *		m_movie_speedup_data;
+
+	// in drivers/beathead.c
+	void update_interrupts();
+	DECLARE_WRITE32_MEMBER( interrupt_control_w );
+	DECLARE_READ32_MEMBER( interrupt_control_r );
+	DECLARE_WRITE32_MEMBER( eeprom_data_w );
+	DECLARE_WRITE32_MEMBER( eeprom_enable_w );
+	DECLARE_READ32_MEMBER( input_2_r );
+	DECLARE_READ32_MEMBER( sound_data_r );
+	DECLARE_WRITE32_MEMBER( sound_data_w );
+	DECLARE_WRITE32_MEMBER( sound_reset_w );
+	DECLARE_WRITE32_MEMBER( coin_count_w );
+	DECLARE_READ32_MEMBER( speedup_r );
+	DECLARE_READ32_MEMBER( movie_speedup_r );
+
+	// in video/beathead.c
+	DECLARE_WRITE32_MEMBER( vram_transparent_w );
+	DECLARE_WRITE32_MEMBER( vram_bulk_w );
+	DECLARE_WRITE32_MEMBER( vram_latch_w );
+	DECLARE_WRITE32_MEMBER( vram_copy_w );
+	DECLARE_WRITE32_MEMBER( finescroll_w );
+	DECLARE_WRITE32_MEMBER( palette_w );
+	DECLARE_READ32_MEMBER( hsync_ram_r );
+	DECLARE_WRITE32_MEMBER( hsync_ram_w );
 };
 
 
@@ -41,12 +76,3 @@ public:
 
 VIDEO_START( beathead );
 VIDEO_UPDATE( beathead );
-
-WRITE32_HANDLER( beathead_vram_transparent_w );
-WRITE32_HANDLER( beathead_vram_bulk_w );
-WRITE32_HANDLER( beathead_vram_latch_w );
-WRITE32_HANDLER( beathead_vram_copy_w );
-WRITE32_HANDLER( beathead_finescroll_w );
-WRITE32_HANDLER( beathead_palette_w );
-READ32_HANDLER( beathead_hsync_ram_r );
-WRITE32_HANDLER( beathead_hsync_ram_w );

src/mame/includes/plygonet.h

@@ -18,7 +18,7 @@ public:
 	UINT16* dsp56k_bank04_ram;
 	int cur_sound_region;
 
-	direct_update_func dsp56k_update_handler;
+	direct_update_delegate dsp56k_update_handler;
 
 	/* TTL text plane stuff */
 	int ttl_gfx_index;

src/mame/machine/archimds.c

@@ -279,7 +279,7 @@ WRITE32_HANDLER(archimedes_memc_logical_w)
 	}
 }
 
-static DIRECT_UPDATE_HANDLER( a310_setopbase )
+DIRECT_UPDATE_HANDLER( a310_setopbase )
 {
 	// if we're not in logical memory, MAME can do the right thing
 	if (address > 0x1ffffff)
@@ -290,19 +290,14 @@ static DIRECT_UPDATE_HANDLER( a310_setopbase )
 	// if the boot ROM is mapped in, do some trickery to make it show up
 	if (memc_latchrom)
 	{
-		direct->bytemask = 0x1fffff;
+		direct.explicit_configure(0x000000, 0x1fffff, 0x1fffff, *direct.space().m_machine.region("maincpu"));
-		direct->bytestart = 0;
-		direct->byteend = 0x1fffff;
-		direct->raw = direct->decrypted = memory_region(space->machine, "maincpu");
 	}
 	else	// executing from logical memory
 	{
-		UINT32 page = address / page_sizes[memc_pagesize];
+		offs_t pagesize = page_sizes[memc_pagesize];
-
+		UINT32 page = address / pagesize;
-		direct->bytemask = page_sizes[memc_pagesize]-1;
+		
-		direct->bytestart = page * page_sizes[memc_pagesize];
+		direct.explicit_configure(page * pagesize, page * pagesize - 1, pagesize - 1, &archimedes_memc_physmem[(memc_pages[page] * pagesize)>>2]);
-		direct->byteend = direct->bytestart + direct->bytemask;
-		direct->raw = direct->decrypted = (UINT8 *)&archimedes_memc_physmem[(memc_pages[page] * page_sizes[memc_pagesize])>>2];
 	}
 
 	return ~0;
@@ -310,7 +305,8 @@ static DIRECT_UPDATE_HANDLER( a310_setopbase )
 
 void archimedes_driver_init(running_machine *machine)
 {
-	memory_set_direct_update_handler( cputag_get_address_space( machine, "maincpu", ADDRESS_SPACE_PROGRAM ), a310_setopbase);
+	address_space *space = machine->device<arm_device>("maincpu")->space(AS_PROGRAM);
+	space->set_direct_update_handler(direct_update_delegate_create_static(a310_setopbase, *machine));
 }
 
 static const char *const ioc_regnames[] =

src/mame/machine/atarigen.c

@@ -491,9 +491,9 @@ static STATE_POSTLOAD( slapstic_postload )
 }
 
 
-static DIRECT_UPDATE_HANDLER( atarigen_slapstic_setdirect )
+DIRECT_UPDATE_HANDLER( atarigen_slapstic_setdirect )
 {
-	atarigen_state *state = space->machine->driver_data<atarigen_state>();
+	atarigen_state *state = machine->driver_data<atarigen_state>();
 
 	/* if we jump to an address in the slapstic region, tweak the slapstic
        at that address and return ~0; this will cause us to be called on
@@ -501,12 +501,12 @@ static DIRECT_UPDATE_HANDLER( atarigen_slapstic_setdirect )
 	address &= ~state->slapstic_mirror;
 	if (address >= state->slapstic_base && address < state->slapstic_base + 0x8000)
 	{
-		offs_t pc = cpu_get_previouspc(space->cpu);
+		offs_t pc = cpu_get_previouspc(&direct.space().device());
 		if (pc != state->slapstic_last_pc || address != state->slapstic_last_address)
 		{
 			state->slapstic_last_pc = pc;
 			state->slapstic_last_address = address;
-			atarigen_slapstic_r(space, (address >> 1) & 0x3fff, 0xffff);
+			atarigen_slapstic_r(&direct.space(), (address >> 1) & 0x3fff, 0xffff);
 		}
 		return ~0;
 	}
@@ -548,7 +548,9 @@ void atarigen_slapstic_init(running_device *device, offs_t base, offs_t mirror,
 		/* install an opcode base handler if we are a 68000 or variant */
 		state->slapstic_base = base;
 		state->slapstic_mirror = mirror;
-		memory_set_direct_update_handler(cpu_get_address_space(device, ADDRESS_SPACE_PROGRAM), atarigen_slapstic_setdirect);
+
+		address_space *space = downcast<cpu_device *>(device)->space(AS_PROGRAM);
+		space->set_direct_update_handler(direct_update_delegate_create_static(atarigen_slapstic_setdirect, *device->machine));
 	}
 }
 

src/mame/machine/fddebug.c

@@ -460,7 +460,7 @@ INLINE int addr_is_valid(const address_space *space, UINT32 addr, UINT32 flags)
 		return 0;
 
 	/* if we're invalid, fail */
-	if (strcmp(memory_get_handler_string(space, 0, addr), "segaic16_memory_mapper_lsb_r") == 0)
+	if (strcmp(const_cast<address_space *>(space)->get_handler_string(ROW_READ, addr), "segaic16_memory_mapper_lsb_r") == 0)
 		return 2;
 
 	return 1;

src/mame/machine/n64.c

@@ -1965,7 +1965,7 @@ static UINT32 cic_status = 0x00000000;
 READ32_HANDLER( n64_pif_ram_r )
 {
     /*mame_printf_debug( "pif_ram_r: %08X, %08X = %08X\n", offset << 2, mem_mask, ( ( pif_ram[offset*4+0] << 24 ) | ( pif_ram[offset*4+1] << 16 ) | ( pif_ram[offset*4+2] <<  8 ) | ( pif_ram[offset*4+3] <<  0 ) ) & mem_mask );*/
-    if(!space->debugger_access)
+    if(!space->debugger_access())
     {
     	if( offset == ( 0x24 / 4 ) )
     	{

src/mame/machine/snes.c

@@ -957,7 +957,7 @@ READ8_HANDLER( snes_r_bank1 )
 	else
 		value = snes_ram[offset];
 
-	if(!space->debugger_access)
+	if(!space->debugger_access())
 		cpu_adjust_icount(space->cpu, -snes_bank_0x00_0x3f_cycles(space->machine, offset));
 
 	return value;
@@ -1020,7 +1020,7 @@ READ8_HANDLER( snes_r_bank2 )
 	else
 		value = snes_ram[0x300000 + offset];
 
-	if(!space->debugger_access)
+	if(!space->debugger_access())
 		cpu_adjust_icount(space->cpu, -snes_bank_0x00_0x3f_cycles(space->machine, offset));
 
 	return value;
@@ -1061,7 +1061,7 @@ READ8_HANDLER( snes_r_bank3 )
 	else											/* Mode 21 & 25 + SuperFX games */
 		value = snes_ram[0x400000 + offset];
 
-	if(!space->debugger_access)
+	if(!space->debugger_access())
 		cpu_adjust_icount(space->cpu, -8);
 
 	return value;
@@ -1099,7 +1099,7 @@ READ8_HANDLER( snes_r_bank4 )
 	else if (state->cart[0].mode & 0x0a)					/* Mode 21 & 25 */
 		value = snes_ram[0x600000 + offset];
 
-	if(!space->debugger_access)
+	if(!space->debugger_access())
 		cpu_adjust_icount(space->cpu, -8);
 
 	return value;
@@ -1135,7 +1135,7 @@ READ8_HANDLER( snes_r_bank5 )
 	else
 		value = snes_ram[0x700000 + offset];
 
-	if(!space->debugger_access)
+	if(!space->debugger_access())
 		cpu_adjust_icount(space->cpu, -8);
 
 	return value;
@@ -1183,7 +1183,7 @@ READ8_HANDLER( snes_r_bank6 )
 	else
 		value = snes_ram[0x800000 + offset];
 
-	if(!space->debugger_access)
+	if(!space->debugger_access())
 		cpu_adjust_icount(space->cpu, -snes_bank_0x80_0xbf_cycles(space->machine, offset));
 
 	return value;
@@ -1236,7 +1236,7 @@ READ8_HANDLER( snes_r_bank7 )
 	else								/* Mode 21 & 25 + SuperFX Games */
 		value = snes_ram[0xc00000 + offset];
 
-	if(!space->debugger_access)
+	if(!space->debugger_access())
 		cpu_adjust_icount(space->cpu, -((snes_ram[MEMSEL] & 1) ? 6 : 8));
 
 	return value;
@@ -1290,7 +1290,7 @@ WRITE8_HANDLER( snes_w_bank1 )
 	else
 		logerror( "(PC=%06x) Attempt to write to ROM address: %X\n",cpu_get_pc(space->cpu),offset );
 
-	if(!space->debugger_access)
+	if(!space->debugger_access())
 		cpu_adjust_icount(space->cpu, -snes_bank_0x00_0x3f_cycles(space->machine, offset));
 }
 
@@ -1347,7 +1347,7 @@ WRITE8_HANDLER( snes_w_bank2 )
 	else
 		logerror("(PC=%06x) Attempt to write to ROM address: %X\n",cpu_get_pc(space->cpu),offset + 0x300000);
 
-	if(!space->debugger_access)
+	if(!space->debugger_access())
 		cpu_adjust_icount(space->cpu, -snes_bank_0x00_0x3f_cycles(space->machine, offset));
 }
 
@@ -1373,7 +1373,7 @@ WRITE8_HANDLER( snes_w_bank4 )
 	else if (state->cart[0].mode & 0x0a)
 		logerror("(PC=%06x) Attempt to write to ROM address: %X\n",cpu_get_pc(space->cpu),offset + 0x600000);
 
-	if(!space->debugger_access)
+	if(!space->debugger_access())
 		cpu_adjust_icount(space->cpu, -8);
 }
 
@@ -1398,7 +1398,7 @@ WRITE8_HANDLER( snes_w_bank5 )
 	else if (state->cart[0].mode & 0x0a)
 		logerror("(PC=%06x) Attempt to write to ROM address: %X\n",cpu_get_pc(space->cpu),offset + 0x700000);
 
-	if(!space->debugger_access)
+	if(!space->debugger_access())
 		cpu_adjust_icount(space->cpu, -8);
 }
 
@@ -1446,7 +1446,7 @@ WRITE8_HANDLER( snes_w_bank6 )
 	else
 		logerror("(PC=%06x) Attempt to write to ROM address: %X\n",cpu_get_pc(space->cpu),offset + 0x800000);
 
-	if(!space->debugger_access)
+	if(!space->debugger_access())
 		cpu_adjust_icount(space->cpu, -snes_bank_0x80_0xbf_cycles(space->machine, offset));
 }
 
@@ -1486,7 +1486,7 @@ WRITE8_HANDLER( snes_w_bank7 )
 	else if (state->cart[0].mode & 0x0a)
 		logerror("(PC=%06x) Attempt to write to ROM address: %X\n",cpu_get_pc(space->cpu),offset + 0xc00000);
 
-	if(!space->debugger_access)
+	if(!space->debugger_access())
 		cpu_adjust_icount(space->cpu, -((snes_ram[MEMSEL] & 1) ? 6 : 8));
 }
 
@@ -1677,15 +1677,15 @@ static void snes_init_ram( running_machine *machine )
 }
 
 
-static DIRECT_UPDATE_HANDLER( spc_direct )
+DIRECT_UPDATE_HANDLER( snes_spc_direct )
 {
-	direct->raw = direct->decrypted = spc_get_ram(space->machine->device("spc700"));
+	direct.explicit_configure(0x0000, 0xffff, 0xffff, spc_get_ram(machine->device("spc700")));
 	return ~0;
 }
 
-static DIRECT_UPDATE_HANDLER( snes_direct )
+DIRECT_UPDATE_HANDLER( snes_direct )
 {
-	direct->raw = direct->decrypted = snes_ram;
+	direct.explicit_configure(0x0000, 0xffff, 0xffff, snes_ram);
 	return ~0;
 }
 
@@ -1694,14 +1694,14 @@ MACHINE_START( snes )
 	snes_state *state = machine->driver_data<snes_state>();
 	int i;
 
-	memory_set_direct_update_handler(cputag_get_address_space(machine, "maincpu", ADDRESS_SPACE_PROGRAM), snes_direct);
-	memory_set_direct_update_handler(cputag_get_address_space(machine, "soundcpu", ADDRESS_SPACE_PROGRAM), spc_direct);
-
 	state->maincpu = machine->device<_5a22_device>("maincpu");
 	state->soundcpu = machine->device<spc700_device>("soundcpu");
 	state->spc700 = machine->device<snes_sound_sound_device>("spc700");
 	state->superfx = machine->device<cpu_device>("superfx");
 
+	state->maincpu->space(AS_PROGRAM)->set_direct_update_handler(direct_update_delegate_create_static(snes_direct, *machine));
+	state->soundcpu->space(AS_PROGRAM)->set_direct_update_handler(direct_update_delegate_create_static(snes_spc_direct, *machine));
+
 	// power-on sets these registers like this
 	snes_ram[WRIO] = 0xff;
 	snes_ram[WRMPYA] = 0xff;

src/mame/video/beathead.c

@@ -18,11 +18,11 @@
 VIDEO_START( beathead )
 {
 	beathead_state *state = machine->driver_data<beathead_state>();
-	state_save_register_global(machine, state->finescroll);
+	state_save_register_global(machine, state->m_finescroll);
-	state_save_register_global(machine, state->vram_latch_offset);
+	state_save_register_global(machine, state->m_vram_latch_offset);
-	state_save_register_global(machine, state->hsyncram_offset);
+	state_save_register_global(machine, state->m_hsyncram_offset);
-	state_save_register_global(machine, state->hsyncram_start);
+	state_save_register_global(machine, state->m_hsyncram_start);
-	state_save_register_global_array(machine, state->hsyncram);
+	state_save_register_global_array(machine, state->m_hsyncram);
 }
 
 
@@ -33,21 +33,19 @@ VIDEO_START( beathead )
  *
  *************************************/
 
-WRITE32_HANDLER( beathead_vram_transparent_w )
+WRITE32_MEMBER( beathead_state::vram_transparent_w )
 {
 	/* writes to this area appear to handle transparency */
 	if (!(data & 0x000000ff)) mem_mask &= ~0x000000ff;
 	if (!(data & 0x0000ff00)) mem_mask &= ~0x0000ff00;
 	if (!(data & 0x00ff0000)) mem_mask &= ~0x00ff0000;
 	if (!(data & 0xff000000)) mem_mask &= ~0xff000000;
-	COMBINE_DATA(&space->machine->generic.videoram.u32[offset]);
+	COMBINE_DATA(&m_videoram[offset]);
 }
 
 
-WRITE32_HANDLER( beathead_vram_bulk_w )
+WRITE32_MEMBER( beathead_state::vram_bulk_w )
 {
-	beathead_state *state = space->machine->driver_data<beathead_state>();
-
 	/* it appears that writes to this area pass in a mask for 4 words in VRAM */
 	/* allowing them to be filled from a preset latch */
 	offset &= ~3;
@@ -55,29 +53,24 @@ WRITE32_HANDLER( beathead_vram_bulk_w )
 
 	/* for now, just handle the bulk fill case; the others we'll catch later */
 	if (data == 0x0f0f0f0f)
-		space->machine->generic.videoram.u32[offset+0] =
+		m_videoram[offset+0] = m_videoram[offset+1] = m_videoram[offset+2] = m_videoram[offset+3] = *m_vram_bulk_latch;
-		space->machine->generic.videoram.u32[offset+1] =
-		space->machine->generic.videoram.u32[offset+2] =
-		space->machine->generic.videoram.u32[offset+3] = *state->vram_bulk_latch;
 	else
 		logerror("Detected bulk VRAM write with mask %08x\n", data);
 }
 
 
-WRITE32_HANDLER( beathead_vram_latch_w )
+WRITE32_MEMBER( beathead_state::vram_latch_w )
 {
 	/* latch the address */
-	beathead_state *state = space->machine->driver_data<beathead_state>();
+	m_vram_latch_offset = (4 * offset) & 0x7ffff;
-	state->vram_latch_offset = (4 * offset) & 0x7ffff;
 }
 
 
-WRITE32_HANDLER( beathead_vram_copy_w )
+WRITE32_MEMBER( beathead_state::vram_copy_w )
 {
 	/* copy from VRAM to VRAM, for 1024 bytes */
-	beathead_state *state = space->machine->driver_data<beathead_state>();
 	offs_t dest_offset = (4 * offset) & 0x7ffff;
-	memcpy(&space->machine->generic.videoram.u32[dest_offset / 4], &space->machine->generic.videoram.u32[state->vram_latch_offset / 4], 0x400);
+	memcpy(&m_videoram[dest_offset / 4], &m_videoram[m_vram_latch_offset / 4], 0x400);
 }
 
 
@@ -88,17 +81,16 @@ WRITE32_HANDLER( beathead_vram_copy_w )
  *
  *************************************/
 
-WRITE32_HANDLER( beathead_finescroll_w )
+WRITE32_MEMBER( beathead_state::finescroll_w )
 {
-	beathead_state *state = space->machine->driver_data<beathead_state>();
+	UINT32 oldword = m_finescroll;
-	UINT32 oldword = state->finescroll;
+	UINT32 newword = COMBINE_DATA(&m_finescroll);
-	UINT32 newword = COMBINE_DATA(&state->finescroll);
 
 	/* if VBLANK is going off on a scanline other than the last, suspend time */
-	if ((oldword & 8) && !(newword & 8) && space->machine->primary_screen->vpos() != 261)
+	if ((oldword & 8) && !(newword & 8) && space.machine->primary_screen->vpos() != 261)
 	{
-		logerror("Suspending time! (scanline = %d)\n", space->machine->primary_screen->vpos());
+		logerror("Suspending time! (scanline = %d)\n", space.machine->primary_screen->vpos());
-		cputag_set_input_line(space->machine, "maincpu", INPUT_LINE_HALT, ASSERT_LINE);
+		cputag_set_input_line(space.machine, "maincpu", INPUT_LINE_HALT, ASSERT_LINE);
 	}
 }
 
@@ -110,13 +102,13 @@ WRITE32_HANDLER( beathead_finescroll_w )
  *
  *************************************/
 
-WRITE32_HANDLER( beathead_palette_w )
+WRITE32_MEMBER( beathead_state::palette_w )
 {
-	int newword = COMBINE_DATA(&space->machine->generic.paletteram.u32[offset]);
+	int newword = COMBINE_DATA(&m_paletteram[offset]);
 	int r = ((newword >> 9) & 0x3e) | ((newword >> 15) & 0x01);
 	int g = ((newword >> 4) & 0x3e) | ((newword >> 15) & 0x01);
 	int b = ((newword << 1) & 0x3e) | ((newword >> 15) & 0x01);
-	palette_set_color_rgb(space->machine, offset, pal6bit(r), pal6bit(g), pal6bit(b));
+	palette_set_color_rgb(space.machine, offset, pal6bit(r), pal6bit(g), pal6bit(b));
 }
 
 
@@ -127,36 +119,32 @@ WRITE32_HANDLER( beathead_palette_w )
  *
  *************************************/
 
-READ32_HANDLER( beathead_hsync_ram_r )
+READ32_MEMBER( beathead_state::hsync_ram_r )
 {
-	beathead_state *state = space->machine->driver_data<beathead_state>();
-
 	/* offset 0 is probably write-only */
 	if (offset == 0)
-		logerror("%08X:Unexpected HSYNC RAM read at offset 0\n", cpu_get_previouspc(space->cpu));
+		logerror("%08X:Unexpected HSYNC RAM read at offset 0\n", cpu_get_previouspc(space.cpu));
 
 	/* offset 1 reads the data */
 	else
-		return state->hsyncram[state->hsyncram_offset];
+		return m_hsyncram[m_hsyncram_offset];
 
 	return 0;
 }
 
-WRITE32_HANDLER( beathead_hsync_ram_w )
+WRITE32_MEMBER( beathead_state::hsync_ram_w )
 {
-	beathead_state *state = space->machine->driver_data<beathead_state>();
-
 	/* offset 0 selects the address, and can specify the start address */
 	if (offset == 0)
 	{
-		COMBINE_DATA(&state->hsyncram_offset);
+		COMBINE_DATA(&m_hsyncram_offset);
-		if (state->hsyncram_offset & 0x800)
+		if (m_hsyncram_offset & 0x800)
-			state->hsyncram_start = state->hsyncram_offset & 0x7ff;
+			m_hsyncram_start = m_hsyncram_offset & 0x7ff;
 	}
 
 	/* offset 1 writes the data */
 	else
-		COMBINE_DATA(&state->hsyncram[state->hsyncram_offset]);
+		COMBINE_DATA(&m_hsyncram[m_hsyncram_offset]);
 }
 
 
@@ -170,24 +158,24 @@ WRITE32_HANDLER( beathead_hsync_ram_w )
 VIDEO_UPDATE( beathead )
 {
 	beathead_state *state = screen->machine->driver_data<beathead_state>();
-	UINT8 *videoram = screen->machine->generic.videoram.u8;
+	UINT8 *videoram = reinterpret_cast<UINT8 *>(state->m_videoram);
 	int x, y;
 
 	/* generate the final screen */
 	for (y = cliprect->min_y; y <= cliprect->max_y; y++)
 	{
-		pen_t pen_base = (*state->palette_select & 0x7f) * 256;
+		pen_t pen_base = (*state->m_palette_select & 0x7f) * 256;
 		UINT16 scanline[336];
 
 		/* blanking */
-		if (state->finescroll & 8)
+		if (state->m_finescroll & 8)
 			for (x = cliprect->min_x; x <= cliprect->max_x; x++)
 				scanline[x] = pen_base;
 
 		/* non-blanking */
 		else
 		{
-			offs_t scanline_offset = state->vram_latch_offset + (state->finescroll & 3);
+			offs_t scanline_offset = state->m_vram_latch_offset + (state->m_finescroll & 3);
 			offs_t src = scanline_offset + cliprect->min_x;
 
 			/* unswizzle the scanline first */