mirror of
https://github.com/holub/mame
synced 2025-04-19 23:12:11 +03:00
addrmap: De-hand-templatize address_map_entry, remove then unneeded entry parameter [O. Galibert]
This commit is contained in:
Olivier Galibert
parent
8536c82ba1
commit
5799b36a3a
@ -97,11 +97,11 @@ void address_map_entry::set_submap(const char *tag, address_map_delegate func, i
|
||||
|
||||
|
||||
//-------------------------------------------------
|
||||
// internal_set_handler - handler setters for
|
||||
// set_handler - handler setters for
|
||||
// 8-bit read/write handlers
|
||||
//-------------------------------------------------
|
||||
|
||||
void address_map_entry::internal_set_handler(read8_delegate func, uint64_t unitmask)
|
||||
void address_map_entry::set_handler(read8_delegate func, uint64_t unitmask)
|
||||
{
|
||||
assert(!func.isnull());
|
||||
assert(unitmask_is_appropriate(8, unitmask, func.name()));
|
||||
@ -113,7 +113,7 @@ void address_map_entry::internal_set_handler(read8_delegate func, uint64_t unitm
|
||||
}
|
||||
|
||||
|
||||
void address_map_entry::internal_set_handler(write8_delegate func, uint64_t unitmask)
|
||||
void address_map_entry::set_handler(write8_delegate func, uint64_t unitmask)
|
||||
{
|
||||
assert(!func.isnull());
|
||||
assert(unitmask_is_appropriate(8, unitmask, func.name()));
|
||||
@ -125,19 +125,19 @@ void address_map_entry::internal_set_handler(write8_delegate func, uint64_t unit
|
||||
}
|
||||
|
||||
|
||||
void address_map_entry::internal_set_handler(read8_delegate rfunc, write8_delegate wfunc, uint64_t unitmask)
|
||||
void address_map_entry::set_handler(read8_delegate rfunc, write8_delegate wfunc, uint64_t unitmask)
|
||||
{
|
||||
internal_set_handler(rfunc, unitmask);
|
||||
internal_set_handler(wfunc, unitmask);
|
||||
set_handler(rfunc, unitmask);
|
||||
set_handler(wfunc, unitmask);
|
||||
}
|
||||
|
||||
|
||||
//-------------------------------------------------
|
||||
// internal_set_handler - handler setters for
|
||||
// set_handler - handler setters for
|
||||
// 16-bit read/write handlers
|
||||
//-------------------------------------------------
|
||||
|
||||
void address_map_entry::internal_set_handler(read16_delegate func, uint64_t unitmask)
|
||||
void address_map_entry::set_handler(read16_delegate func, uint64_t unitmask)
|
||||
{
|
||||
assert(!func.isnull());
|
||||
assert(unitmask_is_appropriate(16, unitmask, func.name()));
|
||||
@ -149,7 +149,7 @@ void address_map_entry::internal_set_handler(read16_delegate func, uint64_t unit
|
||||
}
|
||||
|
||||
|
||||
void address_map_entry::internal_set_handler(write16_delegate func, uint64_t unitmask)
|
||||
void address_map_entry::set_handler(write16_delegate func, uint64_t unitmask)
|
||||
{
|
||||
assert(!func.isnull());
|
||||
assert(unitmask_is_appropriate(16, unitmask, func.name()));
|
||||
@ -161,19 +161,19 @@ void address_map_entry::internal_set_handler(write16_delegate func, uint64_t uni
|
||||
}
|
||||
|
||||
|
||||
void address_map_entry::internal_set_handler(read16_delegate rfunc, write16_delegate wfunc, uint64_t unitmask)
|
||||
void address_map_entry::set_handler(read16_delegate rfunc, write16_delegate wfunc, uint64_t unitmask)
|
||||
{
|
||||
internal_set_handler(rfunc, unitmask);
|
||||
internal_set_handler(wfunc, unitmask);
|
||||
set_handler(rfunc, unitmask);
|
||||
set_handler(wfunc, unitmask);
|
||||
}
|
||||
|
||||
|
||||
//-------------------------------------------------
|
||||
// internal_set_handler - handler setters for
|
||||
// set_handler - handler setters for
|
||||
// 32-bit read/write handlers
|
||||
//-------------------------------------------------
|
||||
|
||||
void address_map_entry::internal_set_handler(read32_delegate func, uint64_t unitmask)
|
||||
void address_map_entry::set_handler(read32_delegate func, uint64_t unitmask)
|
||||
{
|
||||
assert(!func.isnull());
|
||||
assert(unitmask_is_appropriate(32, unitmask, func.name()));
|
||||
@ -185,7 +185,7 @@ void address_map_entry::internal_set_handler(read32_delegate func, uint64_t unit
|
||||
}
|
||||
|
||||
|
||||
void address_map_entry::internal_set_handler(write32_delegate func, uint64_t unitmask)
|
||||
void address_map_entry::set_handler(write32_delegate func, uint64_t unitmask)
|
||||
{
|
||||
assert(!func.isnull());
|
||||
assert(unitmask_is_appropriate(32, unitmask, func.name()));
|
||||
@ -197,19 +197,19 @@ void address_map_entry::internal_set_handler(write32_delegate func, uint64_t uni
|
||||
}
|
||||
|
||||
|
||||
void address_map_entry::internal_set_handler(read32_delegate rfunc, write32_delegate wfunc, uint64_t unitmask)
|
||||
void address_map_entry::set_handler(read32_delegate rfunc, write32_delegate wfunc, uint64_t unitmask)
|
||||
{
|
||||
internal_set_handler(rfunc, unitmask);
|
||||
internal_set_handler(wfunc, unitmask);
|
||||
set_handler(rfunc, unitmask);
|
||||
set_handler(wfunc, unitmask);
|
||||
}
|
||||
|
||||
|
||||
//-------------------------------------------------
|
||||
// internal_set_handler - handler setters for
|
||||
// set_handler - handler setters for
|
||||
// 64-bit read/write handlers
|
||||
//-------------------------------------------------
|
||||
|
||||
void address_map_entry::internal_set_handler(read64_delegate func, uint64_t unitmask)
|
||||
void address_map_entry::set_handler(read64_delegate func, uint64_t unitmask)
|
||||
{
|
||||
assert(!func.isnull());
|
||||
assert(unitmask_is_appropriate(64, unitmask, func.name()));
|
||||
@ -221,7 +221,7 @@ void address_map_entry::internal_set_handler(read64_delegate func, uint64_t unit
|
||||
}
|
||||
|
||||
|
||||
void address_map_entry::internal_set_handler(write64_delegate func, uint64_t unitmask)
|
||||
void address_map_entry::set_handler(write64_delegate func, uint64_t unitmask)
|
||||
{
|
||||
assert(!func.isnull());
|
||||
assert(unitmask_is_appropriate(64, unitmask, func.name()));
|
||||
@ -233,10 +233,10 @@ void address_map_entry::internal_set_handler(write64_delegate func, uint64_t uni
|
||||
}
|
||||
|
||||
|
||||
void address_map_entry::internal_set_handler(read64_delegate rfunc, write64_delegate wfunc, uint64_t unitmask)
|
||||
void address_map_entry::set_handler(read64_delegate rfunc, write64_delegate wfunc, uint64_t unitmask)
|
||||
{
|
||||
internal_set_handler(rfunc, unitmask);
|
||||
internal_set_handler(wfunc, unitmask);
|
||||
set_handler(rfunc, unitmask);
|
||||
set_handler(wfunc, unitmask);
|
||||
}
|
||||
|
||||
|
||||
@ -286,52 +286,6 @@ bool address_map_entry::unitmask_is_appropriate(uint8_t width, uint64_t unitmask
|
||||
}
|
||||
|
||||
|
||||
|
||||
//**************************************************************************
|
||||
// WIDTH-SPECIFIC ADDRESS MAP ENTRY CONSTRUCTORS
|
||||
//**************************************************************************
|
||||
|
||||
//-------------------------------------------------
|
||||
// address_map_entry8 - constructor
|
||||
//-------------------------------------------------
|
||||
|
||||
address_map_entry8::address_map_entry8(device_t &device, address_map &map, offs_t start, offs_t end)
|
||||
: address_map_entry(device, map, start, end)
|
||||
{
|
||||
}
|
||||
|
||||
|
||||
//-------------------------------------------------
|
||||
// address_map_entry16 - constructor
|
||||
//-------------------------------------------------
|
||||
|
||||
address_map_entry16::address_map_entry16(device_t &device, address_map &map, offs_t start, offs_t end)
|
||||
: address_map_entry(device, map, start, end)
|
||||
{
|
||||
}
|
||||
|
||||
|
||||
//-------------------------------------------------
|
||||
// address_map_entry32 - constructor
|
||||
//-------------------------------------------------
|
||||
|
||||
address_map_entry32::address_map_entry32(device_t &device, address_map &map, offs_t start, offs_t end)
|
||||
: address_map_entry(device, map, start, end)
|
||||
{
|
||||
}
|
||||
|
||||
|
||||
//-------------------------------------------------
|
||||
// address_map_entry64 - constructor
|
||||
//-------------------------------------------------
|
||||
|
||||
address_map_entry64::address_map_entry64(device_t &device, address_map &map, offs_t start, offs_t end)
|
||||
: address_map_entry(device, map, start, end)
|
||||
{
|
||||
}
|
||||
|
||||
|
||||
|
||||
//**************************************************************************
|
||||
// ADDRESS MAP
|
||||
//**************************************************************************
|
||||
@ -414,16 +368,16 @@ address_map::address_map(const address_space &space, offs_t start, offs_t end, i
|
||||
address_map_entry *e;
|
||||
switch(m_databits) {
|
||||
case 8:
|
||||
e = add(start, end, (address_map_entry8 *)nullptr);
|
||||
e = add(start, end);
|
||||
break;
|
||||
case 16:
|
||||
e = add(start, end, (address_map_entry16 *)nullptr);
|
||||
e = add(start, end);
|
||||
break;
|
||||
case 32:
|
||||
e = add(start, end, (address_map_entry32 *)nullptr);
|
||||
e = add(start, end);
|
||||
break;
|
||||
case 64:
|
||||
e = add(start, end, (address_map_entry64 *)nullptr);
|
||||
e = add(start, end);
|
||||
break;
|
||||
default:
|
||||
throw emu_fatalerror("Trying to dynamically map a device on a space with a corrupt databits width");
|
||||
@ -472,36 +426,12 @@ void address_map::set_global_mask(offs_t mask)
|
||||
|
||||
|
||||
//-------------------------------------------------
|
||||
// add - add a new entry of the appropriate type
|
||||
// add - add a new entry
|
||||
//-------------------------------------------------
|
||||
|
||||
address_map_entry8 *address_map::add(offs_t start, offs_t end, address_map_entry8 *ptr)
|
||||
address_map_entry *address_map::add(offs_t start, offs_t end)
|
||||
{
|
||||
ptr = global_alloc(address_map_entry8(*m_device, *this, start, end));
|
||||
m_entrylist.append(*ptr);
|
||||
return ptr;
|
||||
}
|
||||
|
||||
|
||||
address_map_entry16 *address_map::add(offs_t start, offs_t end, address_map_entry16 *ptr)
|
||||
{
|
||||
ptr = global_alloc(address_map_entry16(*m_device, *this, start, end));
|
||||
m_entrylist.append(*ptr);
|
||||
return ptr;
|
||||
}
|
||||
|
||||
|
||||
address_map_entry32 *address_map::add(offs_t start, offs_t end, address_map_entry32 *ptr)
|
||||
{
|
||||
ptr = global_alloc(address_map_entry32(*m_device, *this, start, end));
|
||||
m_entrylist.append(*ptr);
|
||||
return ptr;
|
||||
}
|
||||
|
||||
|
||||
address_map_entry64 *address_map::add(offs_t start, offs_t end, address_map_entry64 *ptr)
|
||||
{
|
||||
ptr = global_alloc(address_map_entry64(*m_device, *this, start, end));
|
||||
address_map_entry *ptr = global_alloc(address_map_entry(*m_device, *this, start, end));
|
||||
m_entrylist.append(*ptr);
|
||||
return ptr;
|
||||
}
|
||||
|
||||
@ -145,123 +145,31 @@ public:
|
||||
offs_t m_bytemirror; // byte-adjusted mirror bits
|
||||
offs_t m_bytemask; // byte-adjusted mask bits
|
||||
|
||||
protected:
|
||||
// internal handler setters for 8-bit functions
|
||||
void internal_set_handler(read8_delegate func, uint64_t mask);
|
||||
void internal_set_handler(write8_delegate func, uint64_t mask);
|
||||
void internal_set_handler(read8_delegate rfunc, write8_delegate wfunc, uint64_t mask);
|
||||
// handler setters for 8-bit functions
|
||||
void set_handler(read8_delegate func, uint64_t mask = 0);
|
||||
void set_handler(write8_delegate func, uint64_t mask = 0);
|
||||
void set_handler(read8_delegate rfunc, write8_delegate wfunc, uint64_t mask = 0);
|
||||
|
||||
// internal handler setters for 16-bit functions
|
||||
void internal_set_handler(read16_delegate func, uint64_t mask);
|
||||
void internal_set_handler(write16_delegate func, uint64_t mask);
|
||||
void internal_set_handler(read16_delegate rfunc, write16_delegate wfunc, uint64_t mask);
|
||||
// handler setters for 16-bit functions
|
||||
void set_handler(read16_delegate func, uint64_t mask = 0);
|
||||
void set_handler(write16_delegate func, uint64_t mask = 0);
|
||||
void set_handler(read16_delegate rfunc, write16_delegate wfunc, uint64_t mask = 0);
|
||||
|
||||
// internal handler setters for 32-bit functions
|
||||
void internal_set_handler(read32_delegate func, uint64_t mask);
|
||||
void internal_set_handler(write32_delegate func, uint64_t mask);
|
||||
void internal_set_handler(read32_delegate rfunc, write32_delegate wfunc, uint64_t mask);
|
||||
// handler setters for 32-bit functions
|
||||
void set_handler(read32_delegate func, uint64_t mask = 0);
|
||||
void set_handler(write32_delegate func, uint64_t mask = 0);
|
||||
void set_handler(read32_delegate rfunc, write32_delegate wfunc, uint64_t mask = 0);
|
||||
|
||||
// internal handler setters for 64-bit functions
|
||||
void internal_set_handler(read64_delegate func, uint64_t mask);
|
||||
void internal_set_handler(write64_delegate func, uint64_t mask);
|
||||
void internal_set_handler(read64_delegate rfunc, write64_delegate wfunc, uint64_t mask);
|
||||
// handler setters for 64-bit functions
|
||||
void set_handler(read64_delegate func, uint64_t mask = 0);
|
||||
void set_handler(write64_delegate func, uint64_t mask = 0);
|
||||
void set_handler(read64_delegate rfunc, write64_delegate wfunc, uint64_t mask = 0);
|
||||
|
||||
private:
|
||||
// helper functions
|
||||
bool unitmask_is_appropriate(uint8_t width, uint64_t unitmask, const char *string);
|
||||
};
|
||||
|
||||
|
||||
// ======================> address_map_entry8
|
||||
|
||||
// 8-bit address map version of address_map_entry which only permits valid 8-bit handlers
|
||||
class address_map_entry8 : public address_map_entry
|
||||
{
|
||||
public:
|
||||
address_map_entry8(device_t &device, address_map &map, offs_t start, offs_t end);
|
||||
|
||||
// native-size handlers
|
||||
void set_handler(read8_delegate func) { internal_set_handler(func, 0); }
|
||||
void set_handler(write8_delegate func) { internal_set_handler(func, 0); }
|
||||
void set_handler(read8_delegate rfunc, write8_delegate wfunc) { internal_set_handler(rfunc, wfunc, 0); }
|
||||
};
|
||||
|
||||
|
||||
// ======================> address_map_entry16
|
||||
|
||||
// 16-bit address map version of address_map_entry which only permits valid 16-bit handlers
|
||||
class address_map_entry16 : public address_map_entry
|
||||
{
|
||||
public:
|
||||
address_map_entry16(device_t &device, address_map &map, offs_t start, offs_t end);
|
||||
|
||||
// native-size handlers
|
||||
void set_handler(read16_delegate func) { internal_set_handler(func, 0); }
|
||||
void set_handler(write16_delegate func) { internal_set_handler(func, 0); }
|
||||
void set_handler(read16_delegate rfunc, write16_delegate wfunc) { internal_set_handler(rfunc, wfunc, 0); }
|
||||
|
||||
// 8-bit handlers
|
||||
void set_handler(read8_delegate func, uint16_t mask) { internal_set_handler(func, mask); }
|
||||
void set_handler(write8_delegate func, uint16_t mask) { internal_set_handler(func, mask); }
|
||||
void set_handler(read8_delegate rfunc, write8_delegate wfunc, uint16_t mask) { internal_set_handler(rfunc, wfunc, mask); }
|
||||
};
|
||||
|
||||
|
||||
// ======================> address_map_entry32
|
||||
|
||||
// 32-bit address map version of address_map_entry which only permits valid 32-bit handlers
|
||||
class address_map_entry32 : public address_map_entry
|
||||
{
|
||||
public:
|
||||
address_map_entry32(device_t &device, address_map &map, offs_t start, offs_t end);
|
||||
|
||||
// native-size handlers
|
||||
void set_handler(read32_delegate func) { internal_set_handler(func, 0); }
|
||||
void set_handler(write32_delegate func) { internal_set_handler(func, 0); }
|
||||
void set_handler(read32_delegate rfunc, write32_delegate wfunc) { internal_set_handler(rfunc, wfunc, 0); }
|
||||
|
||||
// 16-bit handlers
|
||||
void set_handler(read16_delegate func, uint32_t mask) { internal_set_handler(func, mask); }
|
||||
void set_handler(write16_delegate func, uint32_t mask) { internal_set_handler(func, mask); }
|
||||
void set_handler(read16_delegate rfunc, write16_delegate wfunc, uint32_t mask) { internal_set_handler(rfunc, wfunc, mask); }
|
||||
|
||||
// 8-bit handlers
|
||||
void set_handler(read8_delegate func, uint32_t mask) { internal_set_handler(func, mask); }
|
||||
void set_handler(write8_delegate func, uint32_t mask) { internal_set_handler(func, mask); }
|
||||
void set_handler(read8_delegate rfunc, write8_delegate wfunc, uint32_t mask) { internal_set_handler(rfunc, wfunc, mask); }
|
||||
};
|
||||
|
||||
|
||||
// ======================> address_map_entry64
|
||||
|
||||
// 64-bit address map version of address_map_entry which only permits valid 64-bit handlers
|
||||
class address_map_entry64 : public address_map_entry
|
||||
{
|
||||
public:
|
||||
address_map_entry64(device_t &device, address_map &map, offs_t start, offs_t end);
|
||||
|
||||
// native-size handlers
|
||||
void set_handler(read64_delegate func) { internal_set_handler(func, 0); }
|
||||
void set_handler(write64_delegate func) { internal_set_handler(func, 0); }
|
||||
void set_handler(read64_delegate rfunc, write64_delegate wfunc) { internal_set_handler(rfunc, wfunc, 0); }
|
||||
|
||||
// 32-bit handlers
|
||||
void set_handler(read32_delegate func, uint64_t mask) { internal_set_handler(func, mask); }
|
||||
void set_handler(write32_delegate func, uint64_t mask) { internal_set_handler(func, mask); }
|
||||
void set_handler(read32_delegate rfunc, write32_delegate wfunc, uint64_t mask) { internal_set_handler(rfunc, wfunc, mask); }
|
||||
|
||||
// 16-bit handlers
|
||||
void set_handler(read16_delegate func, uint64_t mask) { internal_set_handler(func, mask); }
|
||||
void set_handler(write16_delegate func, uint64_t mask) { internal_set_handler(func, mask); }
|
||||
void set_handler(read16_delegate rfunc, write16_delegate wfunc, uint64_t mask) { internal_set_handler(rfunc, wfunc, mask); }
|
||||
|
||||
// 8-bit handlers
|
||||
void set_handler(read8_delegate func, uint64_t mask) { internal_set_handler(func, mask); }
|
||||
void set_handler(write8_delegate func, uint64_t mask) { internal_set_handler(func, mask); }
|
||||
void set_handler(read8_delegate rfunc, write8_delegate wfunc, uint64_t mask) { internal_set_handler(rfunc, wfunc, mask); }
|
||||
};
|
||||
|
||||
|
||||
// ======================> address_map
|
||||
|
||||
// address_map holds global map parameters plus the head of the list of entries
|
||||
@ -282,10 +190,7 @@ public:
|
||||
void set_unmap_value(uint8_t value) { m_unmapval = value; }
|
||||
|
||||
// add a new entry of the given type
|
||||
address_map_entry8 *add(offs_t start, offs_t end, address_map_entry8 *ptr);
|
||||
address_map_entry16 *add(offs_t start, offs_t end, address_map_entry16 *ptr);
|
||||
address_map_entry32 *add(offs_t start, offs_t end, address_map_entry32 *ptr);
|
||||
address_map_entry64 *add(offs_t start, offs_t end, address_map_entry64 *ptr);
|
||||
address_map_entry *add(offs_t start, offs_t end);
|
||||
|
||||
// public data
|
||||
address_spacenum m_spacenum; // space number of the map
|
||||
@ -315,7 +220,7 @@ void ADDRESS_MAP_NAME(_name)(address_map &map) \
|
||||
{ \
|
||||
typedef read##_bits##_delegate read_delegate ATTR_UNUSED; \
|
||||
typedef write##_bits##_delegate write_delegate ATTR_UNUSED; \
|
||||
address_map_entry##_bits *curentry = nullptr; \
|
||||
address_map_entry *curentry = nullptr; \
|
||||
(void)curentry; \
|
||||
map.configure(_space, _bits); \
|
||||
typedef _class drivdata_class ATTR_UNUSED;
|
||||
@ -324,7 +229,7 @@ void _class :: _name(::address_map &map) \
|
||||
{ \
|
||||
typedef read##_bits##_delegate read_delegate ATTR_UNUSED; \
|
||||
typedef write##_bits##_delegate write_delegate ATTR_UNUSED; \
|
||||
address_map_entry##_bits *curentry = nullptr; \
|
||||
address_map_entry *curentry = nullptr; \
|
||||
(void)curentry; \
|
||||
map.configure(AS_PROGRAM, _bits); \
|
||||
typedef _class drivdata_class ATTR_UNUSED;
|
||||
@ -358,7 +263,7 @@ void _class :: _name(::address_map &map) \
|
||||
|
||||
// address ranges
|
||||
#define AM_RANGE(_start, _end) \
|
||||
curentry = map.add(_start, _end, curentry);
|
||||
curentry = map.add(_start, _end);
|
||||
#define AM_MASK(_mask) \
|
||||
curentry->set_mask(_mask);
|
||||
#define AM_MIRROR(_mirror) \
|
||||
|
||||
@ -27,11 +27,11 @@ static void construct_address_map_tranz330_mem(address_map &map)
|
||||
{
|
||||
map.configure(AS_PROGRAM, 8);
|
||||
|
||||
address_map_entry8 *curentry = nullptr;
|
||||
curentry = map.add(0x0000, 0x7fff, curentry);
|
||||
address_map_entry *curentry = nullptr;
|
||||
curentry = map.add(0x0000, 0x7fff);
|
||||
curentry->set_read_type(AMH_ROM);
|
||||
|
||||
curentry = map.add(0x8000, 0xffff, curentry);
|
||||
curentry = map.add(0x8000, 0xffff);
|
||||
curentry->set_read_type(AMH_RAM);
|
||||
curentry->set_write_type(AMH_RAM);
|
||||
}
|
||||
@ -41,20 +41,20 @@ static void construct_address_map_tranz330_io(address_map &map)
|
||||
map.configure(AS_IO, 8);
|
||||
map.set_global_mask(0xff);
|
||||
|
||||
address_map_entry8 *curentry = nullptr;
|
||||
curentry = map.add(0x00, 0x03, curentry);
|
||||
address_map_entry *curentry = nullptr;
|
||||
curentry = map.add(0x00, 0x03);
|
||||
curentry->set_handler(read8_delegate(&z80pio_device::read_alt, "z80pio_device::read_alt", PIO_TAG, (z80pio_device *)nullptr),
|
||||
write8_delegate(&z80pio_device::write_alt, "z80pio_device::write_alt", PIO_TAG, (z80pio_device *)nullptr));
|
||||
|
||||
curentry = map.add(0x10, 0x13, curentry);
|
||||
curentry = map.add(0x10, 0x13);
|
||||
curentry->set_handler(read8_delegate(&z80ctc_device::read, "z80ctc_device::read", CTC_TAG, (z80ctc_device *)nullptr),
|
||||
write8_delegate(&z80ctc_device::write, "z80ctc_device::write", CTC_TAG, (z80ctc_device *)nullptr));
|
||||
|
||||
curentry = map.add(0x20, 0x23, curentry);
|
||||
curentry = map.add(0x20, 0x23);
|
||||
curentry->set_handler(read8_delegate(&z80dart_device::ba_cd_r, "z80dart_device::ba_cd_r", DART_TAG, (z80dart_device *)nullptr),
|
||||
write8_delegate(&z80dart_device::ba_cd_w, "z80dart_device::ba_cd_w", DART_TAG, (z80dart_device *)nullptr));
|
||||
|
||||
curentry = map.add(0x30, 0x3f, curentry);
|
||||
curentry = map.add(0x30, 0x3f);
|
||||
curentry->set_handler(read8_delegate(&msm6242_device::read, "msm6242_device::read", RTC_TAG, (msm6242_device *)nullptr),
|
||||
write8_delegate(&msm6242_device::write, "msm6242_device::write", RTC_TAG, (msm6242_device *)nullptr));
|
||||
}
|
||||
|
||||
Loading…
Reference in New Issue
Block a user