Sprinter/mame
2
0
Fork 0
mirror of https://github.com/holub/mame synced 2025-06-23 12:58:37 +03:00
Code Issues Actions 4 Packages Projects Releases Wiki Activity

addrmap: Change setters into passthroughs [O. Galibert]

Browse Source
This commit is contained in:
Olivier Galibert 2016-11-09 16:24:57 +01:00
parent cddd8bbe7a
commit bb7dc53d0a
2 changed files with 57 additions and 42 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

45
src/emu/addrmap.cpp
View File

@ -65,11 +65,12 @@ address_map_entry::address_map_entry(device_t &device, address_map &map, offs_t
// set_mask - set the mask value // set_mask - set the mask value
//------------------------------------------------- //-------------------------------------------------
void address_map_entry::set_mask(offs_t _mask) address_map_entry *address_map_entry::set_mask(offs_t _mask)
{ {
m_addrmask = _mask; m_addrmask = _mask;
if (m_map.m_globalmask != 0) if (m_map.m_globalmask != 0)
m_addrmask &= m_map.m_globalmask; m_addrmask &= m_map.m_globalmask;
return this;
} }
@ -78,7 +79,7 @@ void address_map_entry::set_mask(offs_t _mask)
// retrieve a submap from a device // retrieve a submap from a device
//------------------------------------------------- //-------------------------------------------------
void address_map_entry::set_submap(const char *tag, address_map_delegate func, int bits, uint64_t mask) address_map_entry *address_map_entry::set_submap(const char *tag, address_map_delegate func, int bits, uint64_t mask)
{ {
if(!bits) if(!bits)
bits = m_map.m_databits; bits = m_map.m_databits;
@ -93,6 +94,7 @@ void address_map_entry::set_submap(const char *tag, address_map_delegate func, i
m_write.m_mask = mask; m_write.m_mask = mask;
m_submap_delegate = func; m_submap_delegate = func;
m_submap_bits = bits; m_submap_bits = bits;
return this;
} }
@ -101,7 +103,7 @@ void address_map_entry::set_submap(const char *tag, address_map_delegate func, i
// 8-bit read/write handlers // 8-bit read/write handlers
//------------------------------------------------- //-------------------------------------------------
void address_map_entry::set_handler(read8_delegate func, uint64_t unitmask) address_map_entry *address_map_entry::set_handler(read8_delegate func, uint64_t unitmask)
{ {
assert(!func.isnull()); assert(!func.isnull());
assert(unitmask_is_appropriate(8, unitmask, func.name())); assert(unitmask_is_appropriate(8, unitmask, func.name()));
@ -110,10 +112,11 @@ void address_map_entry::set_handler(read8_delegate func, uint64_t unitmask)
m_read.m_mask = unitmask; m_read.m_mask = unitmask;
m_read.m_name = func.name(); m_read.m_name = func.name();
m_rproto8 = func; m_rproto8 = func;
return this;
} }
void address_map_entry::set_handler(write8_delegate func, uint64_t unitmask) address_map_entry *address_map_entry::set_handler(write8_delegate func, uint64_t unitmask)
{ {
assert(!func.isnull()); assert(!func.isnull());
assert(unitmask_is_appropriate(8, unitmask, func.name())); assert(unitmask_is_appropriate(8, unitmask, func.name()));
@ -122,13 +125,15 @@ void address_map_entry::set_handler(write8_delegate func, uint64_t unitmask)
m_write.m_mask = unitmask; m_write.m_mask = unitmask;
m_write.m_name = func.name(); m_write.m_name = func.name();
m_wproto8 = func; m_wproto8 = func;
return this;
} }
void address_map_entry::set_handler(read8_delegate rfunc, write8_delegate wfunc, uint64_t unitmask) address_map_entry *address_map_entry::set_handler(read8_delegate rfunc, write8_delegate wfunc, uint64_t unitmask)
{ {
set_handler(rfunc, unitmask); set_handler(rfunc, unitmask);
set_handler(wfunc, unitmask); set_handler(wfunc, unitmask);
return this;
} }
@ -137,7 +142,7 @@ void address_map_entry::set_handler(read8_delegate rfunc, write8_delegate wfunc,
// 16-bit read/write handlers // 16-bit read/write handlers
//------------------------------------------------- //-------------------------------------------------
void address_map_entry::set_handler(read16_delegate func, uint64_t unitmask) address_map_entry *address_map_entry::set_handler(read16_delegate func, uint64_t unitmask)
{ {
assert(!func.isnull()); assert(!func.isnull());
assert(unitmask_is_appropriate(16, unitmask, func.name())); assert(unitmask_is_appropriate(16, unitmask, func.name()));
@ -146,10 +151,11 @@ void address_map_entry::set_handler(read16_delegate func, uint64_t unitmask)
m_read.m_mask = unitmask; m_read.m_mask = unitmask;
m_read.m_name = func.name(); m_read.m_name = func.name();
m_rproto16 = func; m_rproto16 = func;
return this;
} }
void address_map_entry::set_handler(write16_delegate func, uint64_t unitmask) address_map_entry *address_map_entry::set_handler(write16_delegate func, uint64_t unitmask)
{ {
assert(!func.isnull()); assert(!func.isnull());
assert(unitmask_is_appropriate(16, unitmask, func.name())); assert(unitmask_is_appropriate(16, unitmask, func.name()));
@ -158,13 +164,15 @@ void address_map_entry::set_handler(write16_delegate func, uint64_t unitmask)
m_write.m_mask = unitmask; m_write.m_mask = unitmask;
m_write.m_name = func.name(); m_write.m_name = func.name();
m_wproto16 = func; m_wproto16 = func;
return this;
} }
void address_map_entry::set_handler(read16_delegate rfunc, write16_delegate wfunc, uint64_t unitmask) address_map_entry *address_map_entry::set_handler(read16_delegate rfunc, write16_delegate wfunc, uint64_t unitmask)
{ {
set_handler(rfunc, unitmask); set_handler(rfunc, unitmask);
set_handler(wfunc, unitmask); set_handler(wfunc, unitmask);
return this;
} }
@ -173,7 +181,7 @@ void address_map_entry::set_handler(read16_delegate rfunc, write16_delegate wfun
// 32-bit read/write handlers // 32-bit read/write handlers
//------------------------------------------------- //-------------------------------------------------
void address_map_entry::set_handler(read32_delegate func, uint64_t unitmask) address_map_entry *address_map_entry::set_handler(read32_delegate func, uint64_t unitmask)
{ {
assert(!func.isnull()); assert(!func.isnull());
assert(unitmask_is_appropriate(32, unitmask, func.name())); assert(unitmask_is_appropriate(32, unitmask, func.name()));
@ -182,10 +190,11 @@ void address_map_entry::set_handler(read32_delegate func, uint64_t unitmask)
m_read.m_mask = unitmask; m_read.m_mask = unitmask;
m_read.m_name = func.name(); m_read.m_name = func.name();
m_rproto32 = func; m_rproto32 = func;
return this;
} }
void address_map_entry::set_handler(write32_delegate func, uint64_t unitmask) address_map_entry *address_map_entry::set_handler(write32_delegate func, uint64_t unitmask)
{ {
assert(!func.isnull()); assert(!func.isnull());
assert(unitmask_is_appropriate(32, unitmask, func.name())); assert(unitmask_is_appropriate(32, unitmask, func.name()));
@ -194,13 +203,15 @@ void address_map_entry::set_handler(write32_delegate func, uint64_t unitmask)
m_write.m_mask = unitmask; m_write.m_mask = unitmask;
m_write.m_name = func.name(); m_write.m_name = func.name();
m_wproto32 = func; m_wproto32 = func;
return this;
} }
void address_map_entry::set_handler(read32_delegate rfunc, write32_delegate wfunc, uint64_t unitmask) address_map_entry *address_map_entry::set_handler(read32_delegate rfunc, write32_delegate wfunc, uint64_t unitmask)
{ {
set_handler(rfunc, unitmask); set_handler(rfunc, unitmask);
set_handler(wfunc, unitmask); set_handler(wfunc, unitmask);
return this;
} }
@ -209,7 +220,7 @@ void address_map_entry::set_handler(read32_delegate rfunc, write32_delegate wfun
// 64-bit read/write handlers // 64-bit read/write handlers
//------------------------------------------------- //-------------------------------------------------
void address_map_entry::set_handler(read64_delegate func, uint64_t unitmask) address_map_entry *address_map_entry::set_handler(read64_delegate func, uint64_t unitmask)
{ {
assert(!func.isnull()); assert(!func.isnull());
assert(unitmask_is_appropriate(64, unitmask, func.name())); assert(unitmask_is_appropriate(64, unitmask, func.name()));
@ -218,10 +229,11 @@ void address_map_entry::set_handler(read64_delegate func, uint64_t unitmask)
m_read.m_mask = 0; m_read.m_mask = 0;
m_read.m_name = func.name(); m_read.m_name = func.name();
m_rproto64 = func; m_rproto64 = func;
return this;
} }
void address_map_entry::set_handler(write64_delegate func, uint64_t unitmask) address_map_entry *address_map_entry::set_handler(write64_delegate func, uint64_t unitmask)
{ {
assert(!func.isnull()); assert(!func.isnull());
assert(unitmask_is_appropriate(64, unitmask, func.name())); assert(unitmask_is_appropriate(64, unitmask, func.name()));
@ -230,13 +242,15 @@ void address_map_entry::set_handler(write64_delegate func, uint64_t unitmask)
m_write.m_mask = 0; m_write.m_mask = 0;
m_write.m_name = func.name(); m_write.m_name = func.name();
m_wproto64 = func; m_wproto64 = func;
return this;
} }
void address_map_entry::set_handler(read64_delegate rfunc, write64_delegate wfunc, uint64_t unitmask) address_map_entry *address_map_entry::set_handler(read64_delegate rfunc, write64_delegate wfunc, uint64_t unitmask)
{ {
set_handler(rfunc, unitmask); set_handler(rfunc, unitmask);
set_handler(wfunc, unitmask); set_handler(wfunc, unitmask);
return this;
} }
@ -244,7 +258,7 @@ void address_map_entry::set_handler(read64_delegate rfunc, write64_delegate wfun
// set_handler - handler setter for setoffset // set_handler - handler setter for setoffset
//------------------------------------------------- //-------------------------------------------------
void address_map_entry::set_handler(setoffset_delegate func) address_map_entry *address_map_entry::set_handler(setoffset_delegate func)
{ {
assert(!func.isnull()); assert(!func.isnull());
m_setoffsethd.m_type = AMH_DEVICE_DELEGATE; m_setoffsethd.m_type = AMH_DEVICE_DELEGATE;
@ -252,6 +266,7 @@ void address_map_entry::set_handler(setoffset_delegate func)
m_setoffsethd.m_mask = 0; m_setoffsethd.m_mask = 0;
m_setoffsethd.m_name = func.name(); m_setoffsethd.m_name = func.name();
m_soproto = func; m_soproto = func;
return this;
} }
//------------------------------------------------- //-------------------------------------------------

54
src/emu/addrmap.h
View File

@ -80,31 +80,31 @@ public:
address_map_entry *next() const { return m_next; } address_map_entry *next() const { return m_next; }
// simple inline setters // simple inline setters
void set_mirror(offs_t _mirror) { m_addrmirror = _mirror; } address_map_entry *set_mirror(offs_t _mirror) { m_addrmirror = _mirror; return this; }
void set_select(offs_t _select) { m_addrselect = _select; } address_map_entry *set_select(offs_t _select) { m_addrselect = _select; return this; }
void set_read_type(map_handler_type _type) { m_read.m_type = _type; } address_map_entry *set_read_type(map_handler_type _type) { m_read.m_type = _type; return this; }
void set_write_type(map_handler_type _type) { m_write.m_type = _type; } address_map_entry *set_write_type(map_handler_type _type) { m_write.m_type = _type; return this; }
void set_region(const char *tag, offs_t offset) { m_region = tag; m_rgnoffs = offset; } address_map_entry *set_region(const char *tag, offs_t offset) { m_region = tag; m_rgnoffs = offset; return this; }
void set_share(const char *tag) { m_share = tag; } address_map_entry *set_share(const char *tag) { m_share = tag; return this; }
// mask setting // mask setting
void set_mask(offs_t _mask); address_map_entry *set_mask(offs_t _mask);
// I/O port configuration // I/O port configuration
void set_read_port(const char *tag) { m_read.m_type = AMH_PORT; m_read.m_tag = tag; } address_map_entry *set_read_port(const char *tag) { m_read.m_type = AMH_PORT; m_read.m_tag = tag; return this; }
void set_write_port(const char *tag) { m_write.m_type = AMH_PORT; m_write.m_tag = tag; } address_map_entry *set_write_port(const char *tag) { m_write.m_type = AMH_PORT; m_write.m_tag = tag; return this; }
void set_readwrite_port(const char *tag) { set_read_port(tag); set_write_port(tag); } address_map_entry *set_readwrite_port(const char *tag) { set_read_port(tag); set_write_port(tag); return this; }
// memory bank configuration // memory bank configuration
void set_read_bank(const char *tag) { m_read.m_type = AMH_BANK; m_read.m_tag = tag; } address_map_entry *set_read_bank(const char *tag) { m_read.m_type = AMH_BANK; m_read.m_tag = tag; return this; }
void set_write_bank(const char *tag) { m_write.m_type = AMH_BANK; m_write.m_tag = tag; } address_map_entry *set_write_bank(const char *tag) { m_write.m_type = AMH_BANK; m_write.m_tag = tag; return this; }
void set_readwrite_bank(const char *tag) { set_read_bank(tag); set_write_bank(tag); } address_map_entry *set_readwrite_bank(const char *tag) { set_read_bank(tag); set_write_bank(tag); return this; }
// set offset handler (only one version, since there is no data width to consider) // set offset handler (only one version, since there is no data width to consider)
void set_handler(setoffset_delegate func); address_map_entry *set_handler(setoffset_delegate func);
// submap referencing // submap referencing
void set_submap(const char *tag, address_map_delegate func, int bits, uint64_t mask); address_map_entry *set_submap(const char *tag, address_map_delegate func, int bits, uint64_t mask);
// public state // public state
address_map_entry * m_next; // pointer to the next entry address_map_entry * m_next; // pointer to the next entry
@ -146,24 +146,24 @@ public:
offs_t m_bytemask; // byte-adjusted mask bits offs_t m_bytemask; // byte-adjusted mask bits
// handler setters for 8-bit functions // handler setters for 8-bit functions
void set_handler(read8_delegate func, uint64_t mask = 0); address_map_entry *set_handler(read8_delegate func, uint64_t mask = 0);
void set_handler(write8_delegate func, uint64_t mask = 0); address_map_entry *set_handler(write8_delegate func, uint64_t mask = 0);
void set_handler(read8_delegate rfunc, write8_delegate wfunc, uint64_t mask = 0); address_map_entry *set_handler(read8_delegate rfunc, write8_delegate wfunc, uint64_t mask = 0);
// handler setters for 16-bit functions // handler setters for 16-bit functions
void set_handler(read16_delegate func, uint64_t mask = 0); address_map_entry *set_handler(read16_delegate func, uint64_t mask = 0);
void set_handler(write16_delegate func, uint64_t mask = 0); address_map_entry *set_handler(write16_delegate func, uint64_t mask = 0);
void set_handler(read16_delegate rfunc, write16_delegate wfunc, uint64_t mask = 0); address_map_entry *set_handler(read16_delegate rfunc, write16_delegate wfunc, uint64_t mask = 0);
// handler setters for 32-bit functions // handler setters for 32-bit functions
void set_handler(read32_delegate func, uint64_t mask = 0); address_map_entry *set_handler(read32_delegate func, uint64_t mask = 0);
void set_handler(write32_delegate func, uint64_t mask = 0); address_map_entry *set_handler(write32_delegate func, uint64_t mask = 0);
void set_handler(read32_delegate rfunc, write32_delegate wfunc, uint64_t mask = 0); address_map_entry *set_handler(read32_delegate rfunc, write32_delegate wfunc, uint64_t mask = 0);
// handler setters for 64-bit functions // handler setters for 64-bit functions
void set_handler(read64_delegate func, uint64_t mask = 0); address_map_entry *set_handler(read64_delegate func, uint64_t mask = 0);
void set_handler(write64_delegate func, uint64_t mask = 0); address_map_entry *set_handler(write64_delegate func, uint64_t mask = 0);
void set_handler(read64_delegate rfunc, write64_delegate wfunc, uint64_t mask = 0); address_map_entry *set_handler(read64_delegate rfunc, write64_delegate wfunc, uint64_t mask = 0);
private: private:
// helper functions // helper functions