mirror of
https://github.com/holub/mame
synced 2025-06-20 11:16:37 +03:00
memory,devcb: Put capabilities at parity [O. Galibert]
This commit is contained in:
Olivier Galibert
parent
a4c5cb55bb
commit
e78ca34bac
@ -162,7 +162,7 @@ address_map_entry &address_map_entry::m(device_t *device, address_map_constructo
|
||||
address_map_entry &address_map_entry::r(read8_delegate func)
|
||||
{
|
||||
assert(!func.isnull());
|
||||
m_read.m_type = AMH_DEVICE_DELEGATE_F;
|
||||
m_read.m_type = AMH_DEVICE_DELEGATE;
|
||||
m_read.m_bits = 8;
|
||||
m_read.m_name = func.name();
|
||||
m_rproto8 = func;
|
||||
@ -172,13 +172,33 @@ address_map_entry &address_map_entry::r(read8_delegate func)
|
||||
address_map_entry &address_map_entry::w(write8_delegate func)
|
||||
{
|
||||
assert(!func.isnull());
|
||||
m_write.m_type = AMH_DEVICE_DELEGATE_F;
|
||||
m_write.m_type = AMH_DEVICE_DELEGATE;
|
||||
m_write.m_bits = 8;
|
||||
m_write.m_name = func.name();
|
||||
m_wproto8 = func;
|
||||
return *this;
|
||||
}
|
||||
|
||||
address_map_entry &address_map_entry::r(read8m_delegate func)
|
||||
{
|
||||
assert(!func.isnull());
|
||||
m_read.m_type = AMH_DEVICE_DELEGATE_M;
|
||||
m_read.m_bits = 8;
|
||||
m_read.m_name = func.name();
|
||||
m_rproto8m = func;
|
||||
return *this;
|
||||
}
|
||||
|
||||
address_map_entry &address_map_entry::w(write8m_delegate func)
|
||||
{
|
||||
assert(!func.isnull());
|
||||
m_write.m_type = AMH_DEVICE_DELEGATE_M;
|
||||
m_write.m_bits = 8;
|
||||
m_write.m_name = func.name();
|
||||
m_wproto8m = func;
|
||||
return *this;
|
||||
}
|
||||
|
||||
address_map_entry &address_map_entry::r(read8s_delegate func)
|
||||
{
|
||||
assert(!func.isnull());
|
||||
@ -219,6 +239,26 @@ address_map_entry &address_map_entry::w(write8sm_delegate func)
|
||||
return *this;
|
||||
}
|
||||
|
||||
address_map_entry &address_map_entry::r(read8mo_delegate func)
|
||||
{
|
||||
assert(!func.isnull());
|
||||
m_read.m_type = AMH_DEVICE_DELEGATE_MO;
|
||||
m_read.m_bits = 8;
|
||||
m_read.m_name = func.name();
|
||||
m_rproto8mo = func;
|
||||
return *this;
|
||||
}
|
||||
|
||||
address_map_entry &address_map_entry::w(write8mo_delegate func)
|
||||
{
|
||||
assert(!func.isnull());
|
||||
m_write.m_type = AMH_DEVICE_DELEGATE_MO;
|
||||
m_write.m_bits = 8;
|
||||
m_write.m_name = func.name();
|
||||
m_wproto8mo = func;
|
||||
return *this;
|
||||
}
|
||||
|
||||
address_map_entry &address_map_entry::r(read8smo_delegate func)
|
||||
{
|
||||
assert(!func.isnull());
|
||||
@ -248,7 +288,7 @@ address_map_entry &address_map_entry::w(write8smo_delegate func)
|
||||
address_map_entry &address_map_entry::r(read16_delegate func)
|
||||
{
|
||||
assert(!func.isnull());
|
||||
m_read.m_type = AMH_DEVICE_DELEGATE_F;
|
||||
m_read.m_type = AMH_DEVICE_DELEGATE;
|
||||
m_read.m_bits = 16;
|
||||
m_read.m_name = func.name();
|
||||
m_rproto16 = func;
|
||||
@ -258,13 +298,33 @@ address_map_entry &address_map_entry::r(read16_delegate func)
|
||||
address_map_entry &address_map_entry::w(write16_delegate func)
|
||||
{
|
||||
assert(!func.isnull());
|
||||
m_write.m_type = AMH_DEVICE_DELEGATE_F;
|
||||
m_write.m_type = AMH_DEVICE_DELEGATE;
|
||||
m_write.m_bits = 16;
|
||||
m_write.m_name = func.name();
|
||||
m_wproto16 = func;
|
||||
return *this;
|
||||
}
|
||||
|
||||
address_map_entry &address_map_entry::r(read16m_delegate func)
|
||||
{
|
||||
assert(!func.isnull());
|
||||
m_read.m_type = AMH_DEVICE_DELEGATE_M;
|
||||
m_read.m_bits = 16;
|
||||
m_read.m_name = func.name();
|
||||
m_rproto16m = func;
|
||||
return *this;
|
||||
}
|
||||
|
||||
address_map_entry &address_map_entry::w(write16m_delegate func)
|
||||
{
|
||||
assert(!func.isnull());
|
||||
m_write.m_type = AMH_DEVICE_DELEGATE_M;
|
||||
m_write.m_bits = 16;
|
||||
m_write.m_name = func.name();
|
||||
m_wproto16m = func;
|
||||
return *this;
|
||||
}
|
||||
|
||||
address_map_entry &address_map_entry::r(read16s_delegate func)
|
||||
{
|
||||
assert(!func.isnull());
|
||||
@ -305,6 +365,26 @@ address_map_entry &address_map_entry::w(write16sm_delegate func)
|
||||
return *this;
|
||||
}
|
||||
|
||||
address_map_entry &address_map_entry::r(read16mo_delegate func)
|
||||
{
|
||||
assert(!func.isnull());
|
||||
m_read.m_type = AMH_DEVICE_DELEGATE_MO;
|
||||
m_read.m_bits = 16;
|
||||
m_read.m_name = func.name();
|
||||
m_rproto16mo = func;
|
||||
return *this;
|
||||
}
|
||||
|
||||
address_map_entry &address_map_entry::w(write16mo_delegate func)
|
||||
{
|
||||
assert(!func.isnull());
|
||||
m_write.m_type = AMH_DEVICE_DELEGATE_MO;
|
||||
m_write.m_bits = 16;
|
||||
m_write.m_name = func.name();
|
||||
m_wproto16mo = func;
|
||||
return *this;
|
||||
}
|
||||
|
||||
address_map_entry &address_map_entry::r(read16smo_delegate func)
|
||||
{
|
||||
assert(!func.isnull());
|
||||
@ -334,7 +414,7 @@ address_map_entry &address_map_entry::w(write16smo_delegate func)
|
||||
address_map_entry &address_map_entry::r(read32_delegate func)
|
||||
{
|
||||
assert(!func.isnull());
|
||||
m_read.m_type = AMH_DEVICE_DELEGATE_F;
|
||||
m_read.m_type = AMH_DEVICE_DELEGATE;
|
||||
m_read.m_bits = 32;
|
||||
m_read.m_name = func.name();
|
||||
m_rproto32 = func;
|
||||
@ -344,13 +424,33 @@ address_map_entry &address_map_entry::r(read32_delegate func)
|
||||
address_map_entry &address_map_entry::w(write32_delegate func)
|
||||
{
|
||||
assert(!func.isnull());
|
||||
m_write.m_type = AMH_DEVICE_DELEGATE_F;
|
||||
m_write.m_type = AMH_DEVICE_DELEGATE;
|
||||
m_write.m_bits = 32;
|
||||
m_write.m_name = func.name();
|
||||
m_wproto32 = func;
|
||||
return *this;
|
||||
}
|
||||
|
||||
address_map_entry &address_map_entry::r(read32m_delegate func)
|
||||
{
|
||||
assert(!func.isnull());
|
||||
m_read.m_type = AMH_DEVICE_DELEGATE_M;
|
||||
m_read.m_bits = 32;
|
||||
m_read.m_name = func.name();
|
||||
m_rproto32m = func;
|
||||
return *this;
|
||||
}
|
||||
|
||||
address_map_entry &address_map_entry::w(write32m_delegate func)
|
||||
{
|
||||
assert(!func.isnull());
|
||||
m_write.m_type = AMH_DEVICE_DELEGATE_M;
|
||||
m_write.m_bits = 32;
|
||||
m_write.m_name = func.name();
|
||||
m_wproto32m = func;
|
||||
return *this;
|
||||
}
|
||||
|
||||
address_map_entry &address_map_entry::r(read32s_delegate func)
|
||||
{
|
||||
assert(!func.isnull());
|
||||
@ -391,6 +491,26 @@ address_map_entry &address_map_entry::w(write32sm_delegate func)
|
||||
return *this;
|
||||
}
|
||||
|
||||
address_map_entry &address_map_entry::r(read32mo_delegate func)
|
||||
{
|
||||
assert(!func.isnull());
|
||||
m_read.m_type = AMH_DEVICE_DELEGATE_MO;
|
||||
m_read.m_bits = 32;
|
||||
m_read.m_name = func.name();
|
||||
m_rproto32mo = func;
|
||||
return *this;
|
||||
}
|
||||
|
||||
address_map_entry &address_map_entry::w(write32mo_delegate func)
|
||||
{
|
||||
assert(!func.isnull());
|
||||
m_write.m_type = AMH_DEVICE_DELEGATE_MO;
|
||||
m_write.m_bits = 32;
|
||||
m_write.m_name = func.name();
|
||||
m_wproto32mo = func;
|
||||
return *this;
|
||||
}
|
||||
|
||||
address_map_entry &address_map_entry::r(read32smo_delegate func)
|
||||
{
|
||||
assert(!func.isnull());
|
||||
@ -419,7 +539,7 @@ address_map_entry &address_map_entry::w(write32smo_delegate func)
|
||||
address_map_entry &address_map_entry::r(read64_delegate func)
|
||||
{
|
||||
assert(!func.isnull());
|
||||
m_read.m_type = AMH_DEVICE_DELEGATE_F;
|
||||
m_read.m_type = AMH_DEVICE_DELEGATE;
|
||||
m_read.m_bits = 64;
|
||||
m_read.m_name = func.name();
|
||||
m_rproto64 = func;
|
||||
@ -429,13 +549,33 @@ address_map_entry &address_map_entry::r(read64_delegate func)
|
||||
address_map_entry &address_map_entry::w(write64_delegate func)
|
||||
{
|
||||
assert(!func.isnull());
|
||||
m_write.m_type = AMH_DEVICE_DELEGATE_F;
|
||||
m_write.m_type = AMH_DEVICE_DELEGATE;
|
||||
m_write.m_bits = 64;
|
||||
m_write.m_name = func.name();
|
||||
m_wproto64 = func;
|
||||
return *this;
|
||||
}
|
||||
|
||||
address_map_entry &address_map_entry::r(read64m_delegate func)
|
||||
{
|
||||
assert(!func.isnull());
|
||||
m_read.m_type = AMH_DEVICE_DELEGATE_M;
|
||||
m_read.m_bits = 64;
|
||||
m_read.m_name = func.name();
|
||||
m_rproto64m = func;
|
||||
return *this;
|
||||
}
|
||||
|
||||
address_map_entry &address_map_entry::w(write64m_delegate func)
|
||||
{
|
||||
assert(!func.isnull());
|
||||
m_write.m_type = AMH_DEVICE_DELEGATE_M;
|
||||
m_write.m_bits = 64;
|
||||
m_write.m_name = func.name();
|
||||
m_wproto64m = func;
|
||||
return *this;
|
||||
}
|
||||
|
||||
address_map_entry &address_map_entry::r(read64s_delegate func)
|
||||
{
|
||||
assert(!func.isnull());
|
||||
@ -476,6 +616,26 @@ address_map_entry &address_map_entry::w(write64sm_delegate func)
|
||||
return *this;
|
||||
}
|
||||
|
||||
address_map_entry &address_map_entry::r(read64mo_delegate func)
|
||||
{
|
||||
assert(!func.isnull());
|
||||
m_read.m_type = AMH_DEVICE_DELEGATE_MO;
|
||||
m_read.m_bits = 64;
|
||||
m_read.m_name = func.name();
|
||||
m_rproto64mo = func;
|
||||
return *this;
|
||||
}
|
||||
|
||||
address_map_entry &address_map_entry::w(write64mo_delegate func)
|
||||
{
|
||||
assert(!func.isnull());
|
||||
m_write.m_type = AMH_DEVICE_DELEGATE_MO;
|
||||
m_write.m_bits = 64;
|
||||
m_write.m_name = func.name();
|
||||
m_wproto64mo = func;
|
||||
return *this;
|
||||
}
|
||||
|
||||
address_map_entry &address_map_entry::r(read64smo_delegate func)
|
||||
{
|
||||
assert(!func.isnull());
|
||||
@ -952,52 +1112,68 @@ void address_map::map_validity_check(validity_checker &valid, int spacenum) cons
|
||||
}
|
||||
|
||||
// make sure all devices exist
|
||||
if (entry.m_read.m_type == AMH_DEVICE_DELEGATE_F || entry.m_read.m_type == AMH_DEVICE_DELEGATE_S || entry.m_read.m_type == AMH_DEVICE_DELEGATE_SM || entry.m_read.m_type == AMH_DEVICE_DELEGATE_SMO)
|
||||
if (entry.m_read.m_type == AMH_DEVICE_DELEGATE || entry.m_read.m_type == AMH_DEVICE_DELEGATE_M || entry.m_read.m_type == AMH_DEVICE_DELEGATE_S || entry.m_read.m_type == AMH_DEVICE_DELEGATE_SM || entry.m_read.m_type == AMH_DEVICE_DELEGATE_MO || entry.m_read.m_type == AMH_DEVICE_DELEGATE_SMO)
|
||||
{
|
||||
// extract the device tag from the proto-delegate
|
||||
const char *devtag = nullptr;
|
||||
switch (entry.m_read.m_bits)
|
||||
{
|
||||
case 8:
|
||||
if (entry.m_read.m_type == AMH_DEVICE_DELEGATE_F)
|
||||
if (entry.m_read.m_type == AMH_DEVICE_DELEGATE)
|
||||
devtag = entry.m_rproto8.device_name();
|
||||
else if (entry.m_read.m_type == AMH_DEVICE_DELEGATE_M)
|
||||
devtag = entry.m_rproto8m.device_name();
|
||||
else if (entry.m_read.m_type == AMH_DEVICE_DELEGATE_S)
|
||||
devtag = entry.m_rproto8s.device_name();
|
||||
else if (entry.m_read.m_type == AMH_DEVICE_DELEGATE_SM)
|
||||
devtag = entry.m_rproto8sm.device_name();
|
||||
else if (entry.m_read.m_type == AMH_DEVICE_DELEGATE_MO)
|
||||
devtag = entry.m_rproto8mo.device_name();
|
||||
else
|
||||
devtag = entry.m_rproto8smo.device_name();
|
||||
break;
|
||||
|
||||
case 16:
|
||||
if (entry.m_read.m_type == AMH_DEVICE_DELEGATE_F)
|
||||
if (entry.m_read.m_type == AMH_DEVICE_DELEGATE)
|
||||
devtag = entry.m_rproto16.device_name();
|
||||
else if (entry.m_read.m_type == AMH_DEVICE_DELEGATE_M)
|
||||
devtag = entry.m_rproto16m.device_name();
|
||||
else if (entry.m_read.m_type == AMH_DEVICE_DELEGATE_S)
|
||||
devtag = entry.m_rproto16s.device_name();
|
||||
else if (entry.m_read.m_type == AMH_DEVICE_DELEGATE_SM)
|
||||
devtag = entry.m_rproto16sm.device_name();
|
||||
else if (entry.m_read.m_type == AMH_DEVICE_DELEGATE_MO)
|
||||
devtag = entry.m_rproto16mo.device_name();
|
||||
else
|
||||
devtag = entry.m_rproto16smo.device_name();
|
||||
break;
|
||||
|
||||
case 32:
|
||||
if (entry.m_read.m_type == AMH_DEVICE_DELEGATE_F)
|
||||
if (entry.m_read.m_type == AMH_DEVICE_DELEGATE)
|
||||
devtag = entry.m_rproto32.device_name();
|
||||
else if (entry.m_read.m_type == AMH_DEVICE_DELEGATE_M)
|
||||
devtag = entry.m_rproto32m.device_name();
|
||||
else if (entry.m_read.m_type == AMH_DEVICE_DELEGATE_S)
|
||||
devtag = entry.m_rproto32s.device_name();
|
||||
else if (entry.m_read.m_type == AMH_DEVICE_DELEGATE_SM)
|
||||
devtag = entry.m_rproto32sm.device_name();
|
||||
else if (entry.m_read.m_type == AMH_DEVICE_DELEGATE_MO)
|
||||
devtag = entry.m_rproto32mo.device_name();
|
||||
else
|
||||
devtag = entry.m_rproto32smo.device_name();
|
||||
break;
|
||||
|
||||
case 64:
|
||||
if (entry.m_read.m_type == AMH_DEVICE_DELEGATE_F)
|
||||
if (entry.m_read.m_type == AMH_DEVICE_DELEGATE)
|
||||
devtag = entry.m_rproto64.device_name();
|
||||
else if (entry.m_read.m_type == AMH_DEVICE_DELEGATE_M)
|
||||
devtag = entry.m_rproto64m.device_name();
|
||||
else if (entry.m_read.m_type == AMH_DEVICE_DELEGATE_S)
|
||||
devtag = entry.m_rproto64s.device_name();
|
||||
else if (entry.m_read.m_type == AMH_DEVICE_DELEGATE_SM)
|
||||
devtag = entry.m_rproto64sm.device_name();
|
||||
else if (entry.m_read.m_type == AMH_DEVICE_DELEGATE_MO)
|
||||
devtag = entry.m_rproto64mo.device_name();
|
||||
else
|
||||
devtag = entry.m_rproto64smo.device_name();
|
||||
break;
|
||||
@ -1008,52 +1184,68 @@ void address_map::map_validity_check(validity_checker &valid, int spacenum) cons
|
||||
(void)entry.unitmask_is_appropriate(entry.m_read.m_bits, entry.m_mask, entry.m_read.m_name);
|
||||
#endif
|
||||
}
|
||||
if (entry.m_write.m_type == AMH_DEVICE_DELEGATE_F || entry.m_write.m_type == AMH_DEVICE_DELEGATE_S || entry.m_write.m_type == AMH_DEVICE_DELEGATE_SM || entry.m_write.m_type == AMH_DEVICE_DELEGATE_SMO)
|
||||
if (entry.m_write.m_type == AMH_DEVICE_DELEGATE || entry.m_read.m_type == AMH_DEVICE_DELEGATE_M || entry.m_write.m_type == AMH_DEVICE_DELEGATE_S || entry.m_write.m_type == AMH_DEVICE_DELEGATE_SM || entry.m_read.m_type == AMH_DEVICE_DELEGATE_MO || entry.m_write.m_type == AMH_DEVICE_DELEGATE_SMO)
|
||||
{
|
||||
// extract the device tag from the proto-delegate
|
||||
const char *devtag = nullptr;
|
||||
switch (entry.m_write.m_bits)
|
||||
{
|
||||
case 8:
|
||||
if (entry.m_write.m_type == AMH_DEVICE_DELEGATE_F)
|
||||
if (entry.m_write.m_type == AMH_DEVICE_DELEGATE)
|
||||
devtag = entry.m_wproto8.device_name();
|
||||
else if (entry.m_write.m_type == AMH_DEVICE_DELEGATE_M)
|
||||
devtag = entry.m_wproto8m.device_name();
|
||||
else if (entry.m_write.m_type == AMH_DEVICE_DELEGATE_S)
|
||||
devtag = entry.m_wproto8s.device_name();
|
||||
else if (entry.m_write.m_type == AMH_DEVICE_DELEGATE_SM)
|
||||
devtag = entry.m_wproto8sm.device_name();
|
||||
else if (entry.m_write.m_type == AMH_DEVICE_DELEGATE_MO)
|
||||
devtag = entry.m_wproto8mo.device_name();
|
||||
else
|
||||
devtag = entry.m_wproto8smo.device_name();
|
||||
break;
|
||||
|
||||
case 16:
|
||||
if (entry.m_write.m_type == AMH_DEVICE_DELEGATE_F)
|
||||
if (entry.m_write.m_type == AMH_DEVICE_DELEGATE)
|
||||
devtag = entry.m_wproto16.device_name();
|
||||
else if (entry.m_write.m_type == AMH_DEVICE_DELEGATE_M)
|
||||
devtag = entry.m_wproto16m.device_name();
|
||||
else if (entry.m_write.m_type == AMH_DEVICE_DELEGATE_S)
|
||||
devtag = entry.m_wproto16s.device_name();
|
||||
else if (entry.m_write.m_type == AMH_DEVICE_DELEGATE_SM)
|
||||
devtag = entry.m_wproto16sm.device_name();
|
||||
else if (entry.m_write.m_type == AMH_DEVICE_DELEGATE_MO)
|
||||
devtag = entry.m_wproto16mo.device_name();
|
||||
else
|
||||
devtag = entry.m_wproto16smo.device_name();
|
||||
break;
|
||||
|
||||
case 32:
|
||||
if (entry.m_write.m_type == AMH_DEVICE_DELEGATE_F)
|
||||
if (entry.m_write.m_type == AMH_DEVICE_DELEGATE)
|
||||
devtag = entry.m_wproto32.device_name();
|
||||
else if (entry.m_write.m_type == AMH_DEVICE_DELEGATE_M)
|
||||
devtag = entry.m_wproto32m.device_name();
|
||||
else if (entry.m_write.m_type == AMH_DEVICE_DELEGATE_S)
|
||||
devtag = entry.m_wproto32s.device_name();
|
||||
else if (entry.m_write.m_type == AMH_DEVICE_DELEGATE_SM)
|
||||
devtag = entry.m_wproto32sm.device_name();
|
||||
else if (entry.m_write.m_type == AMH_DEVICE_DELEGATE_MO)
|
||||
devtag = entry.m_wproto32mo.device_name();
|
||||
else
|
||||
devtag = entry.m_wproto32smo.device_name();
|
||||
break;
|
||||
|
||||
case 64:
|
||||
if (entry.m_write.m_type == AMH_DEVICE_DELEGATE_F)
|
||||
if (entry.m_write.m_type == AMH_DEVICE_DELEGATE)
|
||||
devtag = entry.m_wproto64.device_name();
|
||||
else if (entry.m_write.m_type == AMH_DEVICE_DELEGATE_M)
|
||||
devtag = entry.m_wproto64m.device_name();
|
||||
else if (entry.m_write.m_type == AMH_DEVICE_DELEGATE_S)
|
||||
devtag = entry.m_wproto64s.device_name();
|
||||
else if (entry.m_write.m_type == AMH_DEVICE_DELEGATE_SM)
|
||||
devtag = entry.m_wproto64sm.device_name();
|
||||
else if (entry.m_write.m_type == AMH_DEVICE_DELEGATE_MO)
|
||||
devtag = entry.m_wproto64mo.device_name();
|
||||
else
|
||||
devtag = entry.m_wproto64smo.device_name();
|
||||
break;
|
||||
|
||||
@ -32,9 +32,11 @@ enum map_handler_type
|
||||
AMH_ROM,
|
||||
AMH_NOP,
|
||||
AMH_UNMAP,
|
||||
AMH_DEVICE_DELEGATE_F,
|
||||
AMH_DEVICE_DELEGATE,
|
||||
AMH_DEVICE_DELEGATE_M,
|
||||
AMH_DEVICE_DELEGATE_S,
|
||||
AMH_DEVICE_DELEGATE_SM,
|
||||
AMH_DEVICE_DELEGATE_MO,
|
||||
AMH_DEVICE_DELEGATE_SMO,
|
||||
AMH_PORT,
|
||||
AMH_BANK,
|
||||
@ -338,6 +340,15 @@ public:
|
||||
write32_delegate m_wproto32; // 32-bit write proto-delegate
|
||||
write64_delegate m_wproto64; // 64-bit write proto-delegate
|
||||
|
||||
read8m_delegate m_rproto8m; // 8-bit read proto-delegate
|
||||
read16m_delegate m_rproto16m; // 16-bit read proto-delegate
|
||||
read32m_delegate m_rproto32m; // 32-bit read proto-delegate
|
||||
read64m_delegate m_rproto64m; // 64-bit read proto-delegate
|
||||
write8m_delegate m_wproto8m; // 8-bit write proto-delegate
|
||||
write16m_delegate m_wproto16m; // 16-bit write proto-delegate
|
||||
write32m_delegate m_wproto32m; // 32-bit write proto-delegate
|
||||
write64m_delegate m_wproto64m; // 64-bit write proto-delegate
|
||||
|
||||
read8s_delegate m_rproto8s; // 8-bit read proto-delegate
|
||||
read16s_delegate m_rproto16s; // 16-bit read proto-delegate
|
||||
read32s_delegate m_rproto32s; // 32-bit read proto-delegate
|
||||
@ -356,6 +367,15 @@ public:
|
||||
write32sm_delegate m_wproto32sm; // 32-bit write proto-delegate
|
||||
write64sm_delegate m_wproto64sm; // 64-bit write proto-delegate
|
||||
|
||||
read8mo_delegate m_rproto8mo; // 8-bit read proto-delegate
|
||||
read16mo_delegate m_rproto16mo; // 16-bit read proto-delegate
|
||||
read32mo_delegate m_rproto32mo; // 32-bit read proto-delegate
|
||||
read64mo_delegate m_rproto64mo; // 64-bit read proto-delegate
|
||||
write8mo_delegate m_wproto8mo; // 8-bit write proto-delegate
|
||||
write16mo_delegate m_wproto16mo; // 16-bit write proto-delegate
|
||||
write32mo_delegate m_wproto32mo; // 32-bit write proto-delegate
|
||||
write64mo_delegate m_wproto64mo; // 64-bit write proto-delegate
|
||||
|
||||
read8smo_delegate m_rproto8smo; // 8-bit read proto-delegate
|
||||
read16smo_delegate m_rproto16smo; // 16-bit read proto-delegate
|
||||
read32smo_delegate m_rproto32smo; // 32-bit read proto-delegate
|
||||
@ -374,40 +394,56 @@ public:
|
||||
// handler setters for 8-bit delegates
|
||||
address_map_entry &r(read8_delegate func);
|
||||
address_map_entry &w(write8_delegate func);
|
||||
address_map_entry &r(read8m_delegate func);
|
||||
address_map_entry &w(write8m_delegate func);
|
||||
address_map_entry &r(read8s_delegate func);
|
||||
address_map_entry &w(write8s_delegate func);
|
||||
address_map_entry &r(read8sm_delegate func);
|
||||
address_map_entry &w(write8sm_delegate func);
|
||||
address_map_entry &r(read8mo_delegate func);
|
||||
address_map_entry &w(write8mo_delegate func);
|
||||
address_map_entry &r(read8smo_delegate func);
|
||||
address_map_entry &w(write8smo_delegate func);
|
||||
|
||||
// handler setters for 16-bit delegates
|
||||
address_map_entry &r(read16_delegate func);
|
||||
address_map_entry &w(write16_delegate func);
|
||||
address_map_entry &r(read16m_delegate func);
|
||||
address_map_entry &w(write16m_delegate func);
|
||||
address_map_entry &r(read16s_delegate func);
|
||||
address_map_entry &w(write16s_delegate func);
|
||||
address_map_entry &r(read16sm_delegate func);
|
||||
address_map_entry &w(write16sm_delegate func);
|
||||
address_map_entry &r(read16mo_delegate func);
|
||||
address_map_entry &w(write16mo_delegate func);
|
||||
address_map_entry &r(read16smo_delegate func);
|
||||
address_map_entry &w(write16smo_delegate func);
|
||||
|
||||
// handler setters for 32-bit delegates
|
||||
address_map_entry &r(read32_delegate func);
|
||||
address_map_entry &w(write32_delegate func);
|
||||
address_map_entry &r(read32m_delegate func);
|
||||
address_map_entry &w(write32m_delegate func);
|
||||
address_map_entry &r(read32s_delegate func);
|
||||
address_map_entry &w(write32s_delegate func);
|
||||
address_map_entry &r(read32sm_delegate func);
|
||||
address_map_entry &w(write32sm_delegate func);
|
||||
address_map_entry &r(read32mo_delegate func);
|
||||
address_map_entry &w(write32mo_delegate func);
|
||||
address_map_entry &r(read32smo_delegate func);
|
||||
address_map_entry &w(write32smo_delegate func);
|
||||
|
||||
// handler setters for 64-bit delegates
|
||||
address_map_entry &r(read64_delegate func);
|
||||
address_map_entry &w(write64_delegate func);
|
||||
address_map_entry &r(read64m_delegate func);
|
||||
address_map_entry &w(write64m_delegate func);
|
||||
address_map_entry &r(read64s_delegate func);
|
||||
address_map_entry &w(write64s_delegate func);
|
||||
address_map_entry &r(read64sm_delegate func);
|
||||
address_map_entry &w(write64sm_delegate func);
|
||||
address_map_entry &r(read64mo_delegate func);
|
||||
address_map_entry &w(write64mo_delegate func);
|
||||
address_map_entry &r(read64smo_delegate func);
|
||||
address_map_entry &w(write64smo_delegate func);
|
||||
|
||||
|
||||
@ -11,6 +11,7 @@
|
||||
#include "emu.h"
|
||||
#include "devcb.h"
|
||||
|
||||
|
||||
template class devcb_read<u8>;
|
||||
template class devcb_read<u16>;
|
||||
template class devcb_read<u32>;
|
||||
@ -21,36 +22,108 @@ template class devcb_read8::delegate_builder<read8_delegate>;
|
||||
template class devcb_read8::delegate_builder<read16_delegate>;
|
||||
template class devcb_read8::delegate_builder<read32_delegate>;
|
||||
template class devcb_read8::delegate_builder<read64_delegate>;
|
||||
template class devcb_read8::delegate_builder<read8s_delegate>;
|
||||
template class devcb_read8::delegate_builder<read16s_delegate>;
|
||||
template class devcb_read8::delegate_builder<read32s_delegate>;
|
||||
template class devcb_read8::delegate_builder<read64s_delegate>;
|
||||
template class devcb_read8::delegate_builder<read8sm_delegate>;
|
||||
template class devcb_read8::delegate_builder<read16sm_delegate>;
|
||||
template class devcb_read8::delegate_builder<read32sm_delegate>;
|
||||
template class devcb_read8::delegate_builder<read64sm_delegate>;
|
||||
template class devcb_read8::delegate_builder<read8smo_delegate>;
|
||||
template class devcb_read8::delegate_builder<read16smo_delegate>;
|
||||
template class devcb_read8::delegate_builder<read32smo_delegate>;
|
||||
template class devcb_read8::delegate_builder<read64smo_delegate>;
|
||||
template class devcb_read8::delegate_builder<read_line_delegate>;
|
||||
|
||||
template class devcb_read16::delegate_builder<read8_delegate>;
|
||||
template class devcb_read16::delegate_builder<read16_delegate>;
|
||||
template class devcb_read16::delegate_builder<read32_delegate>;
|
||||
template class devcb_read16::delegate_builder<read64_delegate>;
|
||||
template class devcb_read16::delegate_builder<read8s_delegate>;
|
||||
template class devcb_read16::delegate_builder<read16s_delegate>;
|
||||
template class devcb_read16::delegate_builder<read32s_delegate>;
|
||||
template class devcb_read16::delegate_builder<read64s_delegate>;
|
||||
template class devcb_read16::delegate_builder<read8sm_delegate>;
|
||||
template class devcb_read16::delegate_builder<read16sm_delegate>;
|
||||
template class devcb_read16::delegate_builder<read32sm_delegate>;
|
||||
template class devcb_read16::delegate_builder<read64sm_delegate>;
|
||||
template class devcb_read16::delegate_builder<read8smo_delegate>;
|
||||
template class devcb_read16::delegate_builder<read16smo_delegate>;
|
||||
template class devcb_read16::delegate_builder<read32smo_delegate>;
|
||||
template class devcb_read16::delegate_builder<read64smo_delegate>;
|
||||
template class devcb_read16::delegate_builder<read_line_delegate>;
|
||||
|
||||
template class devcb_read32::delegate_builder<read8_delegate>;
|
||||
template class devcb_read32::delegate_builder<read16_delegate>;
|
||||
template class devcb_read32::delegate_builder<read32_delegate>;
|
||||
template class devcb_read32::delegate_builder<read64_delegate>;
|
||||
template class devcb_read32::delegate_builder<read8s_delegate>;
|
||||
template class devcb_read32::delegate_builder<read16s_delegate>;
|
||||
template class devcb_read32::delegate_builder<read32s_delegate>;
|
||||
template class devcb_read32::delegate_builder<read64s_delegate>;
|
||||
template class devcb_read32::delegate_builder<read8sm_delegate>;
|
||||
template class devcb_read32::delegate_builder<read16sm_delegate>;
|
||||
template class devcb_read32::delegate_builder<read32sm_delegate>;
|
||||
template class devcb_read32::delegate_builder<read64sm_delegate>;
|
||||
template class devcb_read32::delegate_builder<read8smo_delegate>;
|
||||
template class devcb_read32::delegate_builder<read16smo_delegate>;
|
||||
template class devcb_read32::delegate_builder<read32smo_delegate>;
|
||||
template class devcb_read32::delegate_builder<read64smo_delegate>;
|
||||
template class devcb_read32::delegate_builder<read_line_delegate>;
|
||||
|
||||
template class devcb_read64::delegate_builder<read8_delegate>;
|
||||
template class devcb_read64::delegate_builder<read16_delegate>;
|
||||
template class devcb_read64::delegate_builder<read32_delegate>;
|
||||
template class devcb_read64::delegate_builder<read64_delegate>;
|
||||
template class devcb_read64::delegate_builder<read8s_delegate>;
|
||||
template class devcb_read64::delegate_builder<read16s_delegate>;
|
||||
template class devcb_read64::delegate_builder<read32s_delegate>;
|
||||
template class devcb_read64::delegate_builder<read64s_delegate>;
|
||||
template class devcb_read64::delegate_builder<read8sm_delegate>;
|
||||
template class devcb_read64::delegate_builder<read16sm_delegate>;
|
||||
template class devcb_read64::delegate_builder<read32sm_delegate>;
|
||||
template class devcb_read64::delegate_builder<read64sm_delegate>;
|
||||
template class devcb_read64::delegate_builder<read8smo_delegate>;
|
||||
template class devcb_read64::delegate_builder<read16smo_delegate>;
|
||||
template class devcb_read64::delegate_builder<read32smo_delegate>;
|
||||
template class devcb_read64::delegate_builder<read64smo_delegate>;
|
||||
template class devcb_read64::delegate_builder<read_line_delegate>;
|
||||
|
||||
template class devcb_read_line::delegate_builder<read8_delegate>;
|
||||
template class devcb_read_line::delegate_builder<read16_delegate>;
|
||||
template class devcb_read_line::delegate_builder<read32_delegate>;
|
||||
template class devcb_read_line::delegate_builder<read64_delegate>;
|
||||
template class devcb_read_line::delegate_builder<read8s_delegate>;
|
||||
template class devcb_read_line::delegate_builder<read16s_delegate>;
|
||||
template class devcb_read_line::delegate_builder<read32s_delegate>;
|
||||
template class devcb_read_line::delegate_builder<read64s_delegate>;
|
||||
template class devcb_read_line::delegate_builder<read8sm_delegate>;
|
||||
template class devcb_read_line::delegate_builder<read16sm_delegate>;
|
||||
template class devcb_read_line::delegate_builder<read32sm_delegate>;
|
||||
template class devcb_read_line::delegate_builder<read64sm_delegate>;
|
||||
template class devcb_read_line::delegate_builder<read8smo_delegate>;
|
||||
template class devcb_read_line::delegate_builder<read16smo_delegate>;
|
||||
template class devcb_read_line::delegate_builder<read32smo_delegate>;
|
||||
template class devcb_read_line::delegate_builder<read64smo_delegate>;
|
||||
template class devcb_read_line::delegate_builder<read_line_delegate>;
|
||||
|
||||
template class devcb_read8::creator_impl<devcb_read8::delegate_builder<read8_delegate> >;
|
||||
template class devcb_read8::creator_impl<devcb_read8::delegate_builder<read16_delegate> >;
|
||||
template class devcb_read8::creator_impl<devcb_read8::delegate_builder<read32_delegate> >;
|
||||
template class devcb_read8::creator_impl<devcb_read8::delegate_builder<read64_delegate> >;
|
||||
template class devcb_read8::creator_impl<devcb_read8::delegate_builder<read8s_delegate> >;
|
||||
template class devcb_read8::creator_impl<devcb_read8::delegate_builder<read16s_delegate> >;
|
||||
template class devcb_read8::creator_impl<devcb_read8::delegate_builder<read32s_delegate> >;
|
||||
template class devcb_read8::creator_impl<devcb_read8::delegate_builder<read64s_delegate> >;
|
||||
template class devcb_read8::creator_impl<devcb_read8::delegate_builder<read8sm_delegate> >;
|
||||
template class devcb_read8::creator_impl<devcb_read8::delegate_builder<read16sm_delegate> >;
|
||||
template class devcb_read8::creator_impl<devcb_read8::delegate_builder<read32sm_delegate> >;
|
||||
template class devcb_read8::creator_impl<devcb_read8::delegate_builder<read64sm_delegate> >;
|
||||
template class devcb_read8::creator_impl<devcb_read8::delegate_builder<read8smo_delegate> >;
|
||||
template class devcb_read8::creator_impl<devcb_read8::delegate_builder<read16smo_delegate> >;
|
||||
template class devcb_read8::creator_impl<devcb_read8::delegate_builder<read32smo_delegate> >;
|
||||
template class devcb_read8::creator_impl<devcb_read8::delegate_builder<read64smo_delegate> >;
|
||||
template class devcb_read8::creator_impl<devcb_read8::delegate_builder<read_line_delegate> >;
|
||||
template class devcb_read8::creator_impl<devcb_read8::ioport_builder>;
|
||||
|
||||
@ -58,6 +131,18 @@ template class devcb_read16::creator_impl<devcb_read16::delegate_builder<read8_d
|
||||
template class devcb_read16::creator_impl<devcb_read16::delegate_builder<read16_delegate> >;
|
||||
template class devcb_read16::creator_impl<devcb_read16::delegate_builder<read32_delegate> >;
|
||||
template class devcb_read16::creator_impl<devcb_read16::delegate_builder<read64_delegate> >;
|
||||
template class devcb_read16::creator_impl<devcb_read16::delegate_builder<read8s_delegate> >;
|
||||
template class devcb_read16::creator_impl<devcb_read16::delegate_builder<read16s_delegate> >;
|
||||
template class devcb_read16::creator_impl<devcb_read16::delegate_builder<read32s_delegate> >;
|
||||
template class devcb_read16::creator_impl<devcb_read16::delegate_builder<read64s_delegate> >;
|
||||
template class devcb_read16::creator_impl<devcb_read16::delegate_builder<read8sm_delegate> >;
|
||||
template class devcb_read16::creator_impl<devcb_read16::delegate_builder<read16sm_delegate> >;
|
||||
template class devcb_read16::creator_impl<devcb_read16::delegate_builder<read32sm_delegate> >;
|
||||
template class devcb_read16::creator_impl<devcb_read16::delegate_builder<read64sm_delegate> >;
|
||||
template class devcb_read16::creator_impl<devcb_read16::delegate_builder<read8smo_delegate> >;
|
||||
template class devcb_read16::creator_impl<devcb_read16::delegate_builder<read16smo_delegate> >;
|
||||
template class devcb_read16::creator_impl<devcb_read16::delegate_builder<read32smo_delegate> >;
|
||||
template class devcb_read16::creator_impl<devcb_read16::delegate_builder<read64smo_delegate> >;
|
||||
template class devcb_read16::creator_impl<devcb_read16::delegate_builder<read_line_delegate> >;
|
||||
template class devcb_read16::creator_impl<devcb_read16::ioport_builder>;
|
||||
|
||||
@ -65,6 +150,18 @@ template class devcb_read32::creator_impl<devcb_read32::delegate_builder<read8_d
|
||||
template class devcb_read32::creator_impl<devcb_read32::delegate_builder<read16_delegate> >;
|
||||
template class devcb_read32::creator_impl<devcb_read32::delegate_builder<read32_delegate> >;
|
||||
template class devcb_read32::creator_impl<devcb_read32::delegate_builder<read64_delegate> >;
|
||||
template class devcb_read32::creator_impl<devcb_read32::delegate_builder<read8s_delegate> >;
|
||||
template class devcb_read32::creator_impl<devcb_read32::delegate_builder<read16s_delegate> >;
|
||||
template class devcb_read32::creator_impl<devcb_read32::delegate_builder<read32s_delegate> >;
|
||||
template class devcb_read32::creator_impl<devcb_read32::delegate_builder<read64s_delegate> >;
|
||||
template class devcb_read32::creator_impl<devcb_read32::delegate_builder<read8sm_delegate> >;
|
||||
template class devcb_read32::creator_impl<devcb_read32::delegate_builder<read16sm_delegate> >;
|
||||
template class devcb_read32::creator_impl<devcb_read32::delegate_builder<read32sm_delegate> >;
|
||||
template class devcb_read32::creator_impl<devcb_read32::delegate_builder<read64sm_delegate> >;
|
||||
template class devcb_read32::creator_impl<devcb_read32::delegate_builder<read8smo_delegate> >;
|
||||
template class devcb_read32::creator_impl<devcb_read32::delegate_builder<read16smo_delegate> >;
|
||||
template class devcb_read32::creator_impl<devcb_read32::delegate_builder<read32smo_delegate> >;
|
||||
template class devcb_read32::creator_impl<devcb_read32::delegate_builder<read64smo_delegate> >;
|
||||
template class devcb_read32::creator_impl<devcb_read32::delegate_builder<read_line_delegate> >;
|
||||
template class devcb_read32::creator_impl<devcb_read32::ioport_builder>;
|
||||
|
||||
@ -72,6 +169,18 @@ template class devcb_read64::creator_impl<devcb_read64::delegate_builder<read8_d
|
||||
template class devcb_read64::creator_impl<devcb_read64::delegate_builder<read16_delegate> >;
|
||||
template class devcb_read64::creator_impl<devcb_read64::delegate_builder<read32_delegate> >;
|
||||
template class devcb_read64::creator_impl<devcb_read64::delegate_builder<read64_delegate> >;
|
||||
template class devcb_read64::creator_impl<devcb_read64::delegate_builder<read8s_delegate> >;
|
||||
template class devcb_read64::creator_impl<devcb_read64::delegate_builder<read16s_delegate> >;
|
||||
template class devcb_read64::creator_impl<devcb_read64::delegate_builder<read32s_delegate> >;
|
||||
template class devcb_read64::creator_impl<devcb_read64::delegate_builder<read64s_delegate> >;
|
||||
template class devcb_read64::creator_impl<devcb_read64::delegate_builder<read8sm_delegate> >;
|
||||
template class devcb_read64::creator_impl<devcb_read64::delegate_builder<read16sm_delegate> >;
|
||||
template class devcb_read64::creator_impl<devcb_read64::delegate_builder<read32sm_delegate> >;
|
||||
template class devcb_read64::creator_impl<devcb_read64::delegate_builder<read64sm_delegate> >;
|
||||
template class devcb_read64::creator_impl<devcb_read64::delegate_builder<read8smo_delegate> >;
|
||||
template class devcb_read64::creator_impl<devcb_read64::delegate_builder<read16smo_delegate> >;
|
||||
template class devcb_read64::creator_impl<devcb_read64::delegate_builder<read32smo_delegate> >;
|
||||
template class devcb_read64::creator_impl<devcb_read64::delegate_builder<read64smo_delegate> >;
|
||||
template class devcb_read64::creator_impl<devcb_read64::delegate_builder<read_line_delegate> >;
|
||||
template class devcb_read64::creator_impl<devcb_read64::ioport_builder>;
|
||||
|
||||
@ -79,6 +188,18 @@ template class devcb_read_line::creator_impl<devcb_read_line::delegate_builder<r
|
||||
template class devcb_read_line::creator_impl<devcb_read_line::delegate_builder<read16_delegate> >;
|
||||
template class devcb_read_line::creator_impl<devcb_read_line::delegate_builder<read32_delegate> >;
|
||||
template class devcb_read_line::creator_impl<devcb_read_line::delegate_builder<read64_delegate> >;
|
||||
template class devcb_read_line::creator_impl<devcb_read_line::delegate_builder<read8s_delegate> >;
|
||||
template class devcb_read_line::creator_impl<devcb_read_line::delegate_builder<read16s_delegate> >;
|
||||
template class devcb_read_line::creator_impl<devcb_read_line::delegate_builder<read32s_delegate> >;
|
||||
template class devcb_read_line::creator_impl<devcb_read_line::delegate_builder<read64s_delegate> >;
|
||||
template class devcb_read_line::creator_impl<devcb_read_line::delegate_builder<read8sm_delegate> >;
|
||||
template class devcb_read_line::creator_impl<devcb_read_line::delegate_builder<read16sm_delegate> >;
|
||||
template class devcb_read_line::creator_impl<devcb_read_line::delegate_builder<read32sm_delegate> >;
|
||||
template class devcb_read_line::creator_impl<devcb_read_line::delegate_builder<read64sm_delegate> >;
|
||||
template class devcb_read_line::creator_impl<devcb_read_line::delegate_builder<read8smo_delegate> >;
|
||||
template class devcb_read_line::creator_impl<devcb_read_line::delegate_builder<read16smo_delegate> >;
|
||||
template class devcb_read_line::creator_impl<devcb_read_line::delegate_builder<read32smo_delegate> >;
|
||||
template class devcb_read_line::creator_impl<devcb_read_line::delegate_builder<read64smo_delegate> >;
|
||||
template class devcb_read_line::creator_impl<devcb_read_line::delegate_builder<read_line_delegate> >;
|
||||
template class devcb_read_line::creator_impl<devcb_read_line::ioport_builder>;
|
||||
|
||||
@ -92,36 +213,108 @@ template class devcb_write8::delegate_builder<write8_delegate>;
|
||||
template class devcb_write8::delegate_builder<write16_delegate>;
|
||||
template class devcb_write8::delegate_builder<write32_delegate>;
|
||||
template class devcb_write8::delegate_builder<write64_delegate>;
|
||||
template class devcb_write8::delegate_builder<write8s_delegate>;
|
||||
template class devcb_write8::delegate_builder<write16s_delegate>;
|
||||
template class devcb_write8::delegate_builder<write32s_delegate>;
|
||||
template class devcb_write8::delegate_builder<write64s_delegate>;
|
||||
template class devcb_write8::delegate_builder<write8sm_delegate>;
|
||||
template class devcb_write8::delegate_builder<write16sm_delegate>;
|
||||
template class devcb_write8::delegate_builder<write32sm_delegate>;
|
||||
template class devcb_write8::delegate_builder<write64sm_delegate>;
|
||||
template class devcb_write8::delegate_builder<write8smo_delegate>;
|
||||
template class devcb_write8::delegate_builder<write16smo_delegate>;
|
||||
template class devcb_write8::delegate_builder<write32smo_delegate>;
|
||||
template class devcb_write8::delegate_builder<write64smo_delegate>;
|
||||
template class devcb_write8::delegate_builder<write_line_delegate>;
|
||||
|
||||
template class devcb_write16::delegate_builder<write8_delegate>;
|
||||
template class devcb_write16::delegate_builder<write16_delegate>;
|
||||
template class devcb_write16::delegate_builder<write32_delegate>;
|
||||
template class devcb_write16::delegate_builder<write64_delegate>;
|
||||
template class devcb_write16::delegate_builder<write8s_delegate>;
|
||||
template class devcb_write16::delegate_builder<write16s_delegate>;
|
||||
template class devcb_write16::delegate_builder<write32s_delegate>;
|
||||
template class devcb_write16::delegate_builder<write64s_delegate>;
|
||||
template class devcb_write16::delegate_builder<write8sm_delegate>;
|
||||
template class devcb_write16::delegate_builder<write16sm_delegate>;
|
||||
template class devcb_write16::delegate_builder<write32sm_delegate>;
|
||||
template class devcb_write16::delegate_builder<write64sm_delegate>;
|
||||
template class devcb_write16::delegate_builder<write8smo_delegate>;
|
||||
template class devcb_write16::delegate_builder<write16smo_delegate>;
|
||||
template class devcb_write16::delegate_builder<write32smo_delegate>;
|
||||
template class devcb_write16::delegate_builder<write64smo_delegate>;
|
||||
template class devcb_write16::delegate_builder<write_line_delegate>;
|
||||
|
||||
template class devcb_write32::delegate_builder<write8_delegate>;
|
||||
template class devcb_write32::delegate_builder<write16_delegate>;
|
||||
template class devcb_write32::delegate_builder<write32_delegate>;
|
||||
template class devcb_write32::delegate_builder<write64_delegate>;
|
||||
template class devcb_write32::delegate_builder<write8s_delegate>;
|
||||
template class devcb_write32::delegate_builder<write16s_delegate>;
|
||||
template class devcb_write32::delegate_builder<write32s_delegate>;
|
||||
template class devcb_write32::delegate_builder<write64s_delegate>;
|
||||
template class devcb_write32::delegate_builder<write8sm_delegate>;
|
||||
template class devcb_write32::delegate_builder<write16sm_delegate>;
|
||||
template class devcb_write32::delegate_builder<write32sm_delegate>;
|
||||
template class devcb_write32::delegate_builder<write64sm_delegate>;
|
||||
template class devcb_write32::delegate_builder<write8smo_delegate>;
|
||||
template class devcb_write32::delegate_builder<write16smo_delegate>;
|
||||
template class devcb_write32::delegate_builder<write32smo_delegate>;
|
||||
template class devcb_write32::delegate_builder<write64smo_delegate>;
|
||||
template class devcb_write32::delegate_builder<write_line_delegate>;
|
||||
|
||||
template class devcb_write64::delegate_builder<write8_delegate>;
|
||||
template class devcb_write64::delegate_builder<write16_delegate>;
|
||||
template class devcb_write64::delegate_builder<write32_delegate>;
|
||||
template class devcb_write64::delegate_builder<write64_delegate>;
|
||||
template class devcb_write64::delegate_builder<write8s_delegate>;
|
||||
template class devcb_write64::delegate_builder<write16s_delegate>;
|
||||
template class devcb_write64::delegate_builder<write32s_delegate>;
|
||||
template class devcb_write64::delegate_builder<write64s_delegate>;
|
||||
template class devcb_write64::delegate_builder<write8sm_delegate>;
|
||||
template class devcb_write64::delegate_builder<write16sm_delegate>;
|
||||
template class devcb_write64::delegate_builder<write32sm_delegate>;
|
||||
template class devcb_write64::delegate_builder<write64sm_delegate>;
|
||||
template class devcb_write64::delegate_builder<write8smo_delegate>;
|
||||
template class devcb_write64::delegate_builder<write16smo_delegate>;
|
||||
template class devcb_write64::delegate_builder<write32smo_delegate>;
|
||||
template class devcb_write64::delegate_builder<write64smo_delegate>;
|
||||
template class devcb_write64::delegate_builder<write_line_delegate>;
|
||||
|
||||
template class devcb_write_line::delegate_builder<write8_delegate>;
|
||||
template class devcb_write_line::delegate_builder<write16_delegate>;
|
||||
template class devcb_write_line::delegate_builder<write32_delegate>;
|
||||
template class devcb_write_line::delegate_builder<write64_delegate>;
|
||||
template class devcb_write_line::delegate_builder<write8s_delegate>;
|
||||
template class devcb_write_line::delegate_builder<write16s_delegate>;
|
||||
template class devcb_write_line::delegate_builder<write32s_delegate>;
|
||||
template class devcb_write_line::delegate_builder<write64s_delegate>;
|
||||
template class devcb_write_line::delegate_builder<write8sm_delegate>;
|
||||
template class devcb_write_line::delegate_builder<write16sm_delegate>;
|
||||
template class devcb_write_line::delegate_builder<write32sm_delegate>;
|
||||
template class devcb_write_line::delegate_builder<write64sm_delegate>;
|
||||
template class devcb_write_line::delegate_builder<write8smo_delegate>;
|
||||
template class devcb_write_line::delegate_builder<write16smo_delegate>;
|
||||
template class devcb_write_line::delegate_builder<write32smo_delegate>;
|
||||
template class devcb_write_line::delegate_builder<write64smo_delegate>;
|
||||
template class devcb_write_line::delegate_builder<write_line_delegate>;
|
||||
|
||||
template class devcb_write8::creator_impl<devcb_write8::delegate_builder<write8_delegate> >;
|
||||
template class devcb_write8::creator_impl<devcb_write8::delegate_builder<write16_delegate> >;
|
||||
template class devcb_write8::creator_impl<devcb_write8::delegate_builder<write32_delegate> >;
|
||||
template class devcb_write8::creator_impl<devcb_write8::delegate_builder<write64_delegate> >;
|
||||
template class devcb_write8::creator_impl<devcb_write8::delegate_builder<write8s_delegate> >;
|
||||
template class devcb_write8::creator_impl<devcb_write8::delegate_builder<write16s_delegate> >;
|
||||
template class devcb_write8::creator_impl<devcb_write8::delegate_builder<write32s_delegate> >;
|
||||
template class devcb_write8::creator_impl<devcb_write8::delegate_builder<write64s_delegate> >;
|
||||
template class devcb_write8::creator_impl<devcb_write8::delegate_builder<write8sm_delegate> >;
|
||||
template class devcb_write8::creator_impl<devcb_write8::delegate_builder<write16sm_delegate> >;
|
||||
template class devcb_write8::creator_impl<devcb_write8::delegate_builder<write32sm_delegate> >;
|
||||
template class devcb_write8::creator_impl<devcb_write8::delegate_builder<write64sm_delegate> >;
|
||||
template class devcb_write8::creator_impl<devcb_write8::delegate_builder<write8smo_delegate> >;
|
||||
template class devcb_write8::creator_impl<devcb_write8::delegate_builder<write16smo_delegate> >;
|
||||
template class devcb_write8::creator_impl<devcb_write8::delegate_builder<write32smo_delegate> >;
|
||||
template class devcb_write8::creator_impl<devcb_write8::delegate_builder<write64smo_delegate> >;
|
||||
template class devcb_write8::creator_impl<devcb_write8::delegate_builder<write_line_delegate> >;
|
||||
template class devcb_write8::creator_impl<devcb_write8::inputline_builder>;
|
||||
template class devcb_write8::creator_impl<devcb_write8::latched_inputline_builder>;
|
||||
@ -134,6 +327,18 @@ template class devcb_write16::creator_impl<devcb_write16::delegate_builder<write
|
||||
template class devcb_write16::creator_impl<devcb_write16::delegate_builder<write16_delegate> >;
|
||||
template class devcb_write16::creator_impl<devcb_write16::delegate_builder<write32_delegate> >;
|
||||
template class devcb_write16::creator_impl<devcb_write16::delegate_builder<write64_delegate> >;
|
||||
template class devcb_write16::creator_impl<devcb_write16::delegate_builder<write8s_delegate> >;
|
||||
template class devcb_write16::creator_impl<devcb_write16::delegate_builder<write16s_delegate> >;
|
||||
template class devcb_write16::creator_impl<devcb_write16::delegate_builder<write32s_delegate> >;
|
||||
template class devcb_write16::creator_impl<devcb_write16::delegate_builder<write64s_delegate> >;
|
||||
template class devcb_write16::creator_impl<devcb_write16::delegate_builder<write8sm_delegate> >;
|
||||
template class devcb_write16::creator_impl<devcb_write16::delegate_builder<write16sm_delegate> >;
|
||||
template class devcb_write16::creator_impl<devcb_write16::delegate_builder<write32sm_delegate> >;
|
||||
template class devcb_write16::creator_impl<devcb_write16::delegate_builder<write64sm_delegate> >;
|
||||
template class devcb_write16::creator_impl<devcb_write16::delegate_builder<write8smo_delegate> >;
|
||||
template class devcb_write16::creator_impl<devcb_write16::delegate_builder<write16smo_delegate> >;
|
||||
template class devcb_write16::creator_impl<devcb_write16::delegate_builder<write32smo_delegate> >;
|
||||
template class devcb_write16::creator_impl<devcb_write16::delegate_builder<write64smo_delegate> >;
|
||||
template class devcb_write16::creator_impl<devcb_write16::delegate_builder<write_line_delegate> >;
|
||||
template class devcb_write16::creator_impl<devcb_write16::inputline_builder>;
|
||||
template class devcb_write16::creator_impl<devcb_write16::latched_inputline_builder>;
|
||||
@ -146,6 +351,18 @@ template class devcb_write32::creator_impl<devcb_write32::delegate_builder<write
|
||||
template class devcb_write32::creator_impl<devcb_write32::delegate_builder<write16_delegate> >;
|
||||
template class devcb_write32::creator_impl<devcb_write32::delegate_builder<write32_delegate> >;
|
||||
template class devcb_write32::creator_impl<devcb_write32::delegate_builder<write64_delegate> >;
|
||||
template class devcb_write32::creator_impl<devcb_write32::delegate_builder<write8s_delegate> >;
|
||||
template class devcb_write32::creator_impl<devcb_write32::delegate_builder<write16s_delegate> >;
|
||||
template class devcb_write32::creator_impl<devcb_write32::delegate_builder<write32s_delegate> >;
|
||||
template class devcb_write32::creator_impl<devcb_write32::delegate_builder<write64s_delegate> >;
|
||||
template class devcb_write32::creator_impl<devcb_write32::delegate_builder<write8sm_delegate> >;
|
||||
template class devcb_write32::creator_impl<devcb_write32::delegate_builder<write16sm_delegate> >;
|
||||
template class devcb_write32::creator_impl<devcb_write32::delegate_builder<write32sm_delegate> >;
|
||||
template class devcb_write32::creator_impl<devcb_write32::delegate_builder<write64sm_delegate> >;
|
||||
template class devcb_write32::creator_impl<devcb_write32::delegate_builder<write8smo_delegate> >;
|
||||
template class devcb_write32::creator_impl<devcb_write32::delegate_builder<write16smo_delegate> >;
|
||||
template class devcb_write32::creator_impl<devcb_write32::delegate_builder<write32smo_delegate> >;
|
||||
template class devcb_write32::creator_impl<devcb_write32::delegate_builder<write64smo_delegate> >;
|
||||
template class devcb_write32::creator_impl<devcb_write32::delegate_builder<write_line_delegate> >;
|
||||
template class devcb_write32::creator_impl<devcb_write32::inputline_builder>;
|
||||
template class devcb_write32::creator_impl<devcb_write32::latched_inputline_builder>;
|
||||
@ -158,6 +375,18 @@ template class devcb_write64::creator_impl<devcb_write64::delegate_builder<write
|
||||
template class devcb_write64::creator_impl<devcb_write64::delegate_builder<write16_delegate> >;
|
||||
template class devcb_write64::creator_impl<devcb_write64::delegate_builder<write32_delegate> >;
|
||||
template class devcb_write64::creator_impl<devcb_write64::delegate_builder<write64_delegate> >;
|
||||
template class devcb_write64::creator_impl<devcb_write64::delegate_builder<write8s_delegate> >;
|
||||
template class devcb_write64::creator_impl<devcb_write64::delegate_builder<write16s_delegate> >;
|
||||
template class devcb_write64::creator_impl<devcb_write64::delegate_builder<write32s_delegate> >;
|
||||
template class devcb_write64::creator_impl<devcb_write64::delegate_builder<write64s_delegate> >;
|
||||
template class devcb_write64::creator_impl<devcb_write64::delegate_builder<write8sm_delegate> >;
|
||||
template class devcb_write64::creator_impl<devcb_write64::delegate_builder<write16sm_delegate> >;
|
||||
template class devcb_write64::creator_impl<devcb_write64::delegate_builder<write32sm_delegate> >;
|
||||
template class devcb_write64::creator_impl<devcb_write64::delegate_builder<write64sm_delegate> >;
|
||||
template class devcb_write64::creator_impl<devcb_write64::delegate_builder<write8smo_delegate> >;
|
||||
template class devcb_write64::creator_impl<devcb_write64::delegate_builder<write16smo_delegate> >;
|
||||
template class devcb_write64::creator_impl<devcb_write64::delegate_builder<write32smo_delegate> >;
|
||||
template class devcb_write64::creator_impl<devcb_write64::delegate_builder<write64smo_delegate> >;
|
||||
template class devcb_write64::creator_impl<devcb_write64::delegate_builder<write_line_delegate> >;
|
||||
template class devcb_write64::creator_impl<devcb_write64::inputline_builder>;
|
||||
template class devcb_write64::creator_impl<devcb_write64::latched_inputline_builder>;
|
||||
@ -170,6 +399,18 @@ template class devcb_write_line::creator_impl<devcb_write_line::delegate_builder
|
||||
template class devcb_write_line::creator_impl<devcb_write_line::delegate_builder<write16_delegate> >;
|
||||
template class devcb_write_line::creator_impl<devcb_write_line::delegate_builder<write32_delegate> >;
|
||||
template class devcb_write_line::creator_impl<devcb_write_line::delegate_builder<write64_delegate> >;
|
||||
template class devcb_write_line::creator_impl<devcb_write_line::delegate_builder<write8s_delegate> >;
|
||||
template class devcb_write_line::creator_impl<devcb_write_line::delegate_builder<write16s_delegate> >;
|
||||
template class devcb_write_line::creator_impl<devcb_write_line::delegate_builder<write32s_delegate> >;
|
||||
template class devcb_write_line::creator_impl<devcb_write_line::delegate_builder<write64s_delegate> >;
|
||||
template class devcb_write_line::creator_impl<devcb_write_line::delegate_builder<write8sm_delegate> >;
|
||||
template class devcb_write_line::creator_impl<devcb_write_line::delegate_builder<write16sm_delegate> >;
|
||||
template class devcb_write_line::creator_impl<devcb_write_line::delegate_builder<write32sm_delegate> >;
|
||||
template class devcb_write_line::creator_impl<devcb_write_line::delegate_builder<write64sm_delegate> >;
|
||||
template class devcb_write_line::creator_impl<devcb_write_line::delegate_builder<write8smo_delegate> >;
|
||||
template class devcb_write_line::creator_impl<devcb_write_line::delegate_builder<write16smo_delegate> >;
|
||||
template class devcb_write_line::creator_impl<devcb_write_line::delegate_builder<write32smo_delegate> >;
|
||||
template class devcb_write_line::creator_impl<devcb_write_line::delegate_builder<write64smo_delegate> >;
|
||||
template class devcb_write_line::creator_impl<devcb_write_line::delegate_builder<write_line_delegate> >;
|
||||
template class devcb_write_line::creator_impl<devcb_write_line::inputline_builder>;
|
||||
template class devcb_write_line::creator_impl<devcb_write_line::latched_inputline_builder>;
|
||||
|
||||
339
src/emu/devcb.h
339
src/emu/devcb.h
@ -116,33 +116,12 @@ namespace emu { namespace detail {
|
||||
template <typename T, typename Enable = void> struct read_line_device_class { };
|
||||
template <typename T, typename Enable = void> struct write_line_device_class { };
|
||||
|
||||
template <typename T, typename Ret, typename... Params>
|
||||
struct read_line_device_class<Ret (T::*)(Params...), std::enable_if_t<std::is_constructible<read_line_delegate, Ret (T::*)(Params...), char const *, char const *, T *>::value> > { using type = T; };
|
||||
template <typename T, typename Ret, typename... Params>
|
||||
struct read_line_device_class<Ret (T::*)(Params...) const, std::enable_if_t<std::is_constructible<read_line_delegate, Ret (T::*)(Params...) const, char const *, char const *, T *>::value> > { using type = T; };
|
||||
template <typename T, typename Ret, typename... Params>
|
||||
struct read_line_device_class<Ret (*)(T &, Params...), std::enable_if_t<std::is_constructible<read_line_delegate, Ret (*)(T &, Params...), char const *, char const *, T *>::value> > { using type = T; };
|
||||
template <typename T, typename Ret, typename... Params>
|
||||
struct read_line_device_class<Ret (*)(T *, Params...), std::enable_if_t<std::is_constructible<read_line_delegate, Ret (*)(T *, Params...), char const *, char const *, T *>::value> > { using type = T; };
|
||||
|
||||
template <typename T, typename Ret, typename... Params>
|
||||
struct write_line_device_class<Ret (T::*)(Params...), std::enable_if_t<std::is_constructible<write_line_delegate, Ret (T::*)(Params...), char const *, char const *, T *>::value> > { using type = T; };
|
||||
template <typename T, typename Ret, typename... Params>
|
||||
struct write_line_device_class<Ret (T::*)(Params...) const, std::enable_if_t<std::is_constructible<write_line_delegate, Ret (T::*)(Params...) const, char const *, char const *, T *>::value> > { using type = T; };
|
||||
template <typename T, typename Ret, typename... Params>
|
||||
struct write_line_device_class<Ret (*)(T &, Params...), std::enable_if_t<std::is_constructible<write_line_delegate, Ret (*)(T &, Params...), char const *, char const *, T *>::value> > { using type = T; };
|
||||
template <typename T, typename Ret, typename... Params>
|
||||
struct write_line_device_class<Ret (*)(T *, Params...), std::enable_if_t<std::is_constructible<write_line_delegate, Ret (*)(T *, Params...), char const *, char const *, T *>::value> > { using type = T; };
|
||||
|
||||
template <typename T> using read_line_device_class_t = typename read_line_device_class<T>::type;
|
||||
template <typename T> using write_line_device_class_t = typename write_line_device_class<T>::type;
|
||||
|
||||
template <typename T>
|
||||
inline read_line_delegate make_delegate(T &&func, char const *name, char const *tag, read_line_device_class_t<std::remove_reference_t<T> > *obj)
|
||||
inline read_line_delegate make_delegate(T &&func, char const *name, char const *tag, rw_device_class_t<read_line_delegate, std::remove_reference_t<T> > *obj)
|
||||
{ return read_line_delegate(func, name, tag, obj); }
|
||||
|
||||
template <typename T>
|
||||
inline write_line_delegate make_delegate(T &&func, char const *name, char const *tag, write_line_device_class_t<std::remove_reference_t<T> > *obj)
|
||||
inline write_line_delegate make_delegate(T &&func, char const *name, char const *tag, rw_device_class_t<write_line_delegate, std::remove_reference_t<T> > *obj)
|
||||
{ return write_line_delegate(func, name, tag, obj); }
|
||||
|
||||
} } // namespace emu::detail
|
||||
@ -210,11 +189,35 @@ protected:
|
||||
template <typename T> struct delegate_type<T, void_t<emu::detail::rw_device_class_t<read16_delegate, std::remove_reference_t<T> > > > { using type = read16_delegate; using device_class = emu::detail::rw_device_class_t<type, std::remove_reference_t<T> >; };
|
||||
template <typename T> struct delegate_type<T, void_t<emu::detail::rw_device_class_t<read32_delegate, std::remove_reference_t<T> > > > { using type = read32_delegate; using device_class = emu::detail::rw_device_class_t<type, std::remove_reference_t<T> >; };
|
||||
template <typename T> struct delegate_type<T, void_t<emu::detail::rw_device_class_t<read64_delegate, std::remove_reference_t<T> > > > { using type = read64_delegate; using device_class = emu::detail::rw_device_class_t<type, std::remove_reference_t<T> >; };
|
||||
template <typename T> struct delegate_type<T, void_t<emu::detail::rw_device_class_t<read8s_delegate, std::remove_reference_t<T> > > > { using type = read8s_delegate; using device_class = emu::detail::rw_device_class_t<type, std::remove_reference_t<T> >; };
|
||||
template <typename T> struct delegate_type<T, void_t<emu::detail::rw_device_class_t<read16s_delegate, std::remove_reference_t<T> > > > { using type = read16s_delegate; using device_class = emu::detail::rw_device_class_t<type, std::remove_reference_t<T> >; };
|
||||
template <typename T> struct delegate_type<T, void_t<emu::detail::rw_device_class_t<read32s_delegate, std::remove_reference_t<T> > > > { using type = read32s_delegate; using device_class = emu::detail::rw_device_class_t<type, std::remove_reference_t<T> >; };
|
||||
template <typename T> struct delegate_type<T, void_t<emu::detail::rw_device_class_t<read64s_delegate, std::remove_reference_t<T> > > > { using type = read64s_delegate; using device_class = emu::detail::rw_device_class_t<type, std::remove_reference_t<T> >; };
|
||||
template <typename T> struct delegate_type<T, void_t<emu::detail::rw_device_class_t<read8sm_delegate, std::remove_reference_t<T> > > > { using type = read8sm_delegate; using device_class = emu::detail::rw_device_class_t<type, std::remove_reference_t<T> >; };
|
||||
template <typename T> struct delegate_type<T, void_t<emu::detail::rw_device_class_t<read16sm_delegate, std::remove_reference_t<T> > > > { using type = read16sm_delegate; using device_class = emu::detail::rw_device_class_t<type, std::remove_reference_t<T> >; };
|
||||
template <typename T> struct delegate_type<T, void_t<emu::detail::rw_device_class_t<read32sm_delegate, std::remove_reference_t<T> > > > { using type = read32sm_delegate; using device_class = emu::detail::rw_device_class_t<type, std::remove_reference_t<T> >; };
|
||||
template <typename T> struct delegate_type<T, void_t<emu::detail::rw_device_class_t<read64sm_delegate, std::remove_reference_t<T> > > > { using type = read64sm_delegate; using device_class = emu::detail::rw_device_class_t<type, std::remove_reference_t<T> >; };
|
||||
template <typename T> struct delegate_type<T, void_t<emu::detail::rw_device_class_t<read8smo_delegate, std::remove_reference_t<T> > > > { using type = read8smo_delegate; using device_class = emu::detail::rw_device_class_t<type, std::remove_reference_t<T> >; };
|
||||
template <typename T> struct delegate_type<T, void_t<emu::detail::rw_device_class_t<read16smo_delegate, std::remove_reference_t<T> > > > { using type = read16smo_delegate; using device_class = emu::detail::rw_device_class_t<type, std::remove_reference_t<T> >; };
|
||||
template <typename T> struct delegate_type<T, void_t<emu::detail::rw_device_class_t<read32smo_delegate, std::remove_reference_t<T> > > > { using type = read32smo_delegate; using device_class = emu::detail::rw_device_class_t<type, std::remove_reference_t<T> >; };
|
||||
template <typename T> struct delegate_type<T, void_t<emu::detail::rw_device_class_t<read64smo_delegate, std::remove_reference_t<T> > > > { using type = read64smo_delegate; using device_class = emu::detail::rw_device_class_t<type, std::remove_reference_t<T> >; };
|
||||
template <typename T> struct delegate_type<T, void_t<emu::detail::rw_device_class_t<read_line_delegate, std::remove_reference_t<T> > > > { using type = read_line_delegate; using device_class = emu::detail::rw_device_class_t<type, std::remove_reference_t<T> >; };
|
||||
template <typename T> struct delegate_type<T, void_t<emu::detail::rw_device_class_t<write8_delegate, std::remove_reference_t<T> > > > { using type = write8_delegate; using device_class = emu::detail::rw_device_class_t<type, std::remove_reference_t<T> >; };
|
||||
template <typename T> struct delegate_type<T, void_t<emu::detail::rw_device_class_t<write16_delegate, std::remove_reference_t<T> > > > { using type = write16_delegate; using device_class = emu::detail::rw_device_class_t<type, std::remove_reference_t<T> >; };
|
||||
template <typename T> struct delegate_type<T, void_t<emu::detail::rw_device_class_t<write32_delegate, std::remove_reference_t<T> > > > { using type = write32_delegate; using device_class = emu::detail::rw_device_class_t<type, std::remove_reference_t<T> >; };
|
||||
template <typename T> struct delegate_type<T, void_t<emu::detail::rw_device_class_t<write64_delegate, std::remove_reference_t<T> > > > { using type = write64_delegate; using device_class = emu::detail::rw_device_class_t<type, std::remove_reference_t<T> >; };
|
||||
template <typename T> struct delegate_type<T, void_t<emu::detail::rw_device_class_t<write8s_delegate, std::remove_reference_t<T> > > > { using type = write8s_delegate; using device_class = emu::detail::rw_device_class_t<type, std::remove_reference_t<T> >; };
|
||||
template <typename T> struct delegate_type<T, void_t<emu::detail::rw_device_class_t<write16s_delegate, std::remove_reference_t<T> > > > { using type = write16s_delegate; using device_class = emu::detail::rw_device_class_t<type, std::remove_reference_t<T> >; };
|
||||
template <typename T> struct delegate_type<T, void_t<emu::detail::rw_device_class_t<write32s_delegate, std::remove_reference_t<T> > > > { using type = write32s_delegate; using device_class = emu::detail::rw_device_class_t<type, std::remove_reference_t<T> >; };
|
||||
template <typename T> struct delegate_type<T, void_t<emu::detail::rw_device_class_t<write64s_delegate, std::remove_reference_t<T> > > > { using type = write64s_delegate; using device_class = emu::detail::rw_device_class_t<type, std::remove_reference_t<T> >; };
|
||||
template <typename T> struct delegate_type<T, void_t<emu::detail::rw_device_class_t<write8sm_delegate, std::remove_reference_t<T> > > > { using type = write8sm_delegate; using device_class = emu::detail::rw_device_class_t<type, std::remove_reference_t<T> >; };
|
||||
template <typename T> struct delegate_type<T, void_t<emu::detail::rw_device_class_t<write16sm_delegate, std::remove_reference_t<T> > > > { using type = write16sm_delegate; using device_class = emu::detail::rw_device_class_t<type, std::remove_reference_t<T> >; };
|
||||
template <typename T> struct delegate_type<T, void_t<emu::detail::rw_device_class_t<write32sm_delegate, std::remove_reference_t<T> > > > { using type = write32sm_delegate; using device_class = emu::detail::rw_device_class_t<type, std::remove_reference_t<T> >; };
|
||||
template <typename T> struct delegate_type<T, void_t<emu::detail::rw_device_class_t<write64sm_delegate, std::remove_reference_t<T> > > > { using type = write64sm_delegate; using device_class = emu::detail::rw_device_class_t<type, std::remove_reference_t<T> >; };
|
||||
template <typename T> struct delegate_type<T, void_t<emu::detail::rw_device_class_t<write8smo_delegate, std::remove_reference_t<T> > > > { using type = write8smo_delegate; using device_class = emu::detail::rw_device_class_t<type, std::remove_reference_t<T> >; };
|
||||
template <typename T> struct delegate_type<T, void_t<emu::detail::rw_device_class_t<write16smo_delegate, std::remove_reference_t<T> > > > { using type = write16smo_delegate; using device_class = emu::detail::rw_device_class_t<type, std::remove_reference_t<T> >; };
|
||||
template <typename T> struct delegate_type<T, void_t<emu::detail::rw_device_class_t<write32smo_delegate, std::remove_reference_t<T> > > > { using type = write32smo_delegate; using device_class = emu::detail::rw_device_class_t<type, std::remove_reference_t<T> >; };
|
||||
template <typename T> struct delegate_type<T, void_t<emu::detail::rw_device_class_t<write64smo_delegate, std::remove_reference_t<T> > > > { using type = write64smo_delegate; using device_class = emu::detail::rw_device_class_t<type, std::remove_reference_t<T> >; };
|
||||
template <typename T> struct delegate_type<T, void_t<emu::detail::rw_device_class_t<write_line_delegate, std::remove_reference_t<T> > > > { using type = write_line_delegate; using device_class = emu::detail::rw_device_class_t<type, std::remove_reference_t<T> >; };
|
||||
template <typename T> using delegate_type_t = typename delegate_type<T>::type;
|
||||
template <typename T> using delegate_device_class_t = typename delegate_type<T>::device_class;
|
||||
@ -334,6 +337,18 @@ protected:
|
||||
template <typename T> struct is_read_method<T, void_t<emu::detail::rw_device_class_t<read16_delegate, std::remove_reference_t<T> > > > { static constexpr bool value = true; };
|
||||
template <typename T> struct is_read_method<T, void_t<emu::detail::rw_device_class_t<read32_delegate, std::remove_reference_t<T> > > > { static constexpr bool value = true; };
|
||||
template <typename T> struct is_read_method<T, void_t<emu::detail::rw_device_class_t<read64_delegate, std::remove_reference_t<T> > > > { static constexpr bool value = true; };
|
||||
template <typename T> struct is_read_method<T, void_t<emu::detail::rw_device_class_t<read8s_delegate, std::remove_reference_t<T> > > > { static constexpr bool value = true; };
|
||||
template <typename T> struct is_read_method<T, void_t<emu::detail::rw_device_class_t<read16s_delegate, std::remove_reference_t<T> > > > { static constexpr bool value = true; };
|
||||
template <typename T> struct is_read_method<T, void_t<emu::detail::rw_device_class_t<read32s_delegate, std::remove_reference_t<T> > > > { static constexpr bool value = true; };
|
||||
template <typename T> struct is_read_method<T, void_t<emu::detail::rw_device_class_t<read64s_delegate, std::remove_reference_t<T> > > > { static constexpr bool value = true; };
|
||||
template <typename T> struct is_read_method<T, void_t<emu::detail::rw_device_class_t<read8sm_delegate, std::remove_reference_t<T> > > > { static constexpr bool value = true; };
|
||||
template <typename T> struct is_read_method<T, void_t<emu::detail::rw_device_class_t<read16sm_delegate, std::remove_reference_t<T> > > > { static constexpr bool value = true; };
|
||||
template <typename T> struct is_read_method<T, void_t<emu::detail::rw_device_class_t<read32sm_delegate, std::remove_reference_t<T> > > > { static constexpr bool value = true; };
|
||||
template <typename T> struct is_read_method<T, void_t<emu::detail::rw_device_class_t<read64sm_delegate, std::remove_reference_t<T> > > > { static constexpr bool value = true; };
|
||||
template <typename T> struct is_read_method<T, void_t<emu::detail::rw_device_class_t<read8smo_delegate, std::remove_reference_t<T> > > > { static constexpr bool value = true; };
|
||||
template <typename T> struct is_read_method<T, void_t<emu::detail::rw_device_class_t<read16smo_delegate, std::remove_reference_t<T> > > > { static constexpr bool value = true; };
|
||||
template <typename T> struct is_read_method<T, void_t<emu::detail::rw_device_class_t<read32smo_delegate, std::remove_reference_t<T> > > > { static constexpr bool value = true; };
|
||||
template <typename T> struct is_read_method<T, void_t<emu::detail::rw_device_class_t<read64smo_delegate, std::remove_reference_t<T> > > > { static constexpr bool value = true; };
|
||||
template <typename T> struct is_read_method<T, void_t<emu::detail::rw_device_class_t<read_line_delegate, std::remove_reference_t<T> > > > { static constexpr bool value = true; };
|
||||
|
||||
// Invoking read callbacks
|
||||
@ -350,6 +365,18 @@ protected:
|
||||
template <typename Dummy> struct delegate_traits<read16_delegate, Dummy> { static constexpr u16 default_mask = ~u16(0); };
|
||||
template <typename Dummy> struct delegate_traits<read32_delegate, Dummy> { static constexpr u32 default_mask = ~u32(0); };
|
||||
template <typename Dummy> struct delegate_traits<read64_delegate, Dummy> { static constexpr u64 default_mask = ~u64(0); };
|
||||
template <typename Dummy> struct delegate_traits<read8s_delegate, Dummy> { static constexpr u8 default_mask = ~u8(0); };
|
||||
template <typename Dummy> struct delegate_traits<read16s_delegate, Dummy> { static constexpr u16 default_mask = ~u16(0); };
|
||||
template <typename Dummy> struct delegate_traits<read32s_delegate, Dummy> { static constexpr u32 default_mask = ~u32(0); };
|
||||
template <typename Dummy> struct delegate_traits<read64s_delegate, Dummy> { static constexpr u64 default_mask = ~u64(0); };
|
||||
template <typename Dummy> struct delegate_traits<read8sm_delegate, Dummy> { static constexpr u8 default_mask = ~u8(0); };
|
||||
template <typename Dummy> struct delegate_traits<read16sm_delegate, Dummy> { static constexpr u16 default_mask = ~u16(0); };
|
||||
template <typename Dummy> struct delegate_traits<read32sm_delegate, Dummy> { static constexpr u32 default_mask = ~u32(0); };
|
||||
template <typename Dummy> struct delegate_traits<read64sm_delegate, Dummy> { static constexpr u64 default_mask = ~u64(0); };
|
||||
template <typename Dummy> struct delegate_traits<read8smo_delegate, Dummy> { static constexpr u8 default_mask = ~u8(0); };
|
||||
template <typename Dummy> struct delegate_traits<read16smo_delegate, Dummy> { static constexpr u16 default_mask = ~u16(0); };
|
||||
template <typename Dummy> struct delegate_traits<read32smo_delegate, Dummy> { static constexpr u32 default_mask = ~u32(0); };
|
||||
template <typename Dummy> struct delegate_traits<read64smo_delegate, Dummy> { static constexpr u64 default_mask = ~u64(0); };
|
||||
template <typename Dummy> struct delegate_traits<read_line_delegate, Dummy> { static constexpr unsigned default_mask = 1U; };
|
||||
|
||||
using devcb_base::devcb_base;
|
||||
@ -384,11 +411,23 @@ protected:
|
||||
template <typename T> struct is_write_method<T, void_t<emu::detail::rw_device_class_t<write16_delegate, std::remove_reference_t<T> > > > { static constexpr bool value = true; };
|
||||
template <typename T> struct is_write_method<T, void_t<emu::detail::rw_device_class_t<write32_delegate, std::remove_reference_t<T> > > > { static constexpr bool value = true; };
|
||||
template <typename T> struct is_write_method<T, void_t<emu::detail::rw_device_class_t<write64_delegate, std::remove_reference_t<T> > > > { static constexpr bool value = true; };
|
||||
template <typename T> struct is_write_method<T, void_t<emu::detail::rw_device_class_t<write8s_delegate, std::remove_reference_t<T> > > > { static constexpr bool value = true; };
|
||||
template <typename T> struct is_write_method<T, void_t<emu::detail::rw_device_class_t<write16s_delegate, std::remove_reference_t<T> > > > { static constexpr bool value = true; };
|
||||
template <typename T> struct is_write_method<T, void_t<emu::detail::rw_device_class_t<write32s_delegate, std::remove_reference_t<T> > > > { static constexpr bool value = true; };
|
||||
template <typename T> struct is_write_method<T, void_t<emu::detail::rw_device_class_t<write64s_delegate, std::remove_reference_t<T> > > > { static constexpr bool value = true; };
|
||||
template <typename T> struct is_write_method<T, void_t<emu::detail::rw_device_class_t<write8sm_delegate, std::remove_reference_t<T> > > > { static constexpr bool value = true; };
|
||||
template <typename T> struct is_write_method<T, void_t<emu::detail::rw_device_class_t<write16sm_delegate, std::remove_reference_t<T> > > > { static constexpr bool value = true; };
|
||||
template <typename T> struct is_write_method<T, void_t<emu::detail::rw_device_class_t<write32sm_delegate, std::remove_reference_t<T> > > > { static constexpr bool value = true; };
|
||||
template <typename T> struct is_write_method<T, void_t<emu::detail::rw_device_class_t<write64sm_delegate, std::remove_reference_t<T> > > > { static constexpr bool value = true; };
|
||||
template <typename T> struct is_write_method<T, void_t<emu::detail::rw_device_class_t<write8smo_delegate, std::remove_reference_t<T> > > > { static constexpr bool value = true; };
|
||||
template <typename T> struct is_write_method<T, void_t<emu::detail::rw_device_class_t<write16smo_delegate, std::remove_reference_t<T> > > > { static constexpr bool value = true; };
|
||||
template <typename T> struct is_write_method<T, void_t<emu::detail::rw_device_class_t<write32smo_delegate, std::remove_reference_t<T> > > > { static constexpr bool value = true; };
|
||||
template <typename T> struct is_write_method<T, void_t<emu::detail::rw_device_class_t<write64smo_delegate, std::remove_reference_t<T> > > > { static constexpr bool value = true; };
|
||||
template <typename T> struct is_write_method<T, void_t<emu::detail::rw_device_class_t<write_line_delegate, std::remove_reference_t<T> > > > { static constexpr bool value = true; };
|
||||
|
||||
// Invoking write callbacks
|
||||
template <typename Input, typename T> static std::enable_if_t<is_write_form1<Input, T>::value> invoke_write(T const &cb, address_space &space, offs_t &offset, Input data, std::make_unsigned_t<Input> mem_mask) { return cb(space, offset, data, mem_mask); }
|
||||
template <typename Input, typename T> static std::enable_if_t<is_write_form2<Input, T>::value> invoke_write(T const &cb, address_space &space, offs_t &offset, Input data, std::make_unsigned_t<Input> mem_mask) { return cb(space, data, offset); }
|
||||
template <typename Input, typename T> static std::enable_if_t<is_write_form2<Input, T>::value> invoke_write(T const &cb, address_space &space, offs_t &offset, Input data, std::make_unsigned_t<Input> mem_mask) { return cb(space, offset, data); }
|
||||
template <typename Input, typename T> static std::enable_if_t<is_write_form3<Input, T>::value> invoke_write(T const &cb, address_space &space, offs_t &offset, Input data, std::make_unsigned_t<Input> mem_mask) { return cb(offset, data, mem_mask); }
|
||||
template <typename Input, typename T> static std::enable_if_t<is_write_form4<Input, T>::value> invoke_write(T const &cb, address_space &space, offs_t &offset, Input data, std::make_unsigned_t<Input> mem_mask) { return cb(offset, data); }
|
||||
template <typename Input, typename T> static std::enable_if_t<is_write_form5<Input, T>::value> invoke_write(T const &cb, address_space &space, offs_t &offset, Input data, std::make_unsigned_t<Input> mem_mask) { return cb(space, data); }
|
||||
@ -400,6 +439,18 @@ protected:
|
||||
template <typename Dummy> struct delegate_traits<write16_delegate, Dummy> { using input_t = u16; static constexpr u16 default_mask = ~u16(0); };
|
||||
template <typename Dummy> struct delegate_traits<write32_delegate, Dummy> { using input_t = u32; static constexpr u32 default_mask = ~u32(0); };
|
||||
template <typename Dummy> struct delegate_traits<write64_delegate, Dummy> { using input_t = u64; static constexpr u64 default_mask = ~u64(0); };
|
||||
template <typename Dummy> struct delegate_traits<write8s_delegate, Dummy> { using input_t = u8; static constexpr u8 default_mask = ~u8(0); };
|
||||
template <typename Dummy> struct delegate_traits<write16s_delegate, Dummy> { using input_t = u16; static constexpr u16 default_mask = ~u16(0); };
|
||||
template <typename Dummy> struct delegate_traits<write32s_delegate, Dummy> { using input_t = u32; static constexpr u32 default_mask = ~u32(0); };
|
||||
template <typename Dummy> struct delegate_traits<write64s_delegate, Dummy> { using input_t = u64; static constexpr u64 default_mask = ~u64(0); };
|
||||
template <typename Dummy> struct delegate_traits<write8sm_delegate, Dummy> { using input_t = u8; static constexpr u8 default_mask = ~u8(0); };
|
||||
template <typename Dummy> struct delegate_traits<write16sm_delegate, Dummy> { using input_t = u16; static constexpr u16 default_mask = ~u16(0); };
|
||||
template <typename Dummy> struct delegate_traits<write32sm_delegate, Dummy> { using input_t = u32; static constexpr u32 default_mask = ~u32(0); };
|
||||
template <typename Dummy> struct delegate_traits<write64sm_delegate, Dummy> { using input_t = u64; static constexpr u64 default_mask = ~u64(0); };
|
||||
template <typename Dummy> struct delegate_traits<write8smo_delegate, Dummy> { using input_t = u8; static constexpr u8 default_mask = ~u8(0); };
|
||||
template <typename Dummy> struct delegate_traits<write16smo_delegate, Dummy> { using input_t = u16; static constexpr u16 default_mask = ~u16(0); };
|
||||
template <typename Dummy> struct delegate_traits<write32smo_delegate, Dummy> { using input_t = u32; static constexpr u32 default_mask = ~u32(0); };
|
||||
template <typename Dummy> struct delegate_traits<write64smo_delegate, Dummy> { using input_t = u64; static constexpr u64 default_mask = ~u64(0); };
|
||||
template <typename Dummy> struct delegate_traits<write_line_delegate, Dummy> { using input_t = int; static constexpr unsigned default_mask = 1U; };
|
||||
|
||||
using devcb_base::devcb_base;
|
||||
@ -2529,36 +2580,108 @@ extern template class devcb_read8::delegate_builder<read8_delegate>;
|
||||
extern template class devcb_read8::delegate_builder<read16_delegate>;
|
||||
extern template class devcb_read8::delegate_builder<read32_delegate>;
|
||||
extern template class devcb_read8::delegate_builder<read64_delegate>;
|
||||
extern template class devcb_read8::delegate_builder<read8s_delegate>;
|
||||
extern template class devcb_read8::delegate_builder<read16s_delegate>;
|
||||
extern template class devcb_read8::delegate_builder<read32s_delegate>;
|
||||
extern template class devcb_read8::delegate_builder<read64s_delegate>;
|
||||
extern template class devcb_read8::delegate_builder<read8sm_delegate>;
|
||||
extern template class devcb_read8::delegate_builder<read16sm_delegate>;
|
||||
extern template class devcb_read8::delegate_builder<read32sm_delegate>;
|
||||
extern template class devcb_read8::delegate_builder<read64sm_delegate>;
|
||||
extern template class devcb_read8::delegate_builder<read8smo_delegate>;
|
||||
extern template class devcb_read8::delegate_builder<read16smo_delegate>;
|
||||
extern template class devcb_read8::delegate_builder<read32smo_delegate>;
|
||||
extern template class devcb_read8::delegate_builder<read64smo_delegate>;
|
||||
extern template class devcb_read8::delegate_builder<read_line_delegate>;
|
||||
|
||||
extern template class devcb_read16::delegate_builder<read8_delegate>;
|
||||
extern template class devcb_read16::delegate_builder<read16_delegate>;
|
||||
extern template class devcb_read16::delegate_builder<read32_delegate>;
|
||||
extern template class devcb_read16::delegate_builder<read64_delegate>;
|
||||
extern template class devcb_read16::delegate_builder<read8s_delegate>;
|
||||
extern template class devcb_read16::delegate_builder<read16s_delegate>;
|
||||
extern template class devcb_read16::delegate_builder<read32s_delegate>;
|
||||
extern template class devcb_read16::delegate_builder<read64s_delegate>;
|
||||
extern template class devcb_read16::delegate_builder<read8sm_delegate>;
|
||||
extern template class devcb_read16::delegate_builder<read16sm_delegate>;
|
||||
extern template class devcb_read16::delegate_builder<read32sm_delegate>;
|
||||
extern template class devcb_read16::delegate_builder<read64sm_delegate>;
|
||||
extern template class devcb_read16::delegate_builder<read8smo_delegate>;
|
||||
extern template class devcb_read16::delegate_builder<read16smo_delegate>;
|
||||
extern template class devcb_read16::delegate_builder<read32smo_delegate>;
|
||||
extern template class devcb_read16::delegate_builder<read64smo_delegate>;
|
||||
extern template class devcb_read16::delegate_builder<read_line_delegate>;
|
||||
|
||||
extern template class devcb_read32::delegate_builder<read8_delegate>;
|
||||
extern template class devcb_read32::delegate_builder<read16_delegate>;
|
||||
extern template class devcb_read32::delegate_builder<read32_delegate>;
|
||||
extern template class devcb_read32::delegate_builder<read64_delegate>;
|
||||
extern template class devcb_read32::delegate_builder<read8s_delegate>;
|
||||
extern template class devcb_read32::delegate_builder<read16s_delegate>;
|
||||
extern template class devcb_read32::delegate_builder<read32s_delegate>;
|
||||
extern template class devcb_read32::delegate_builder<read64s_delegate>;
|
||||
extern template class devcb_read32::delegate_builder<read8sm_delegate>;
|
||||
extern template class devcb_read32::delegate_builder<read16sm_delegate>;
|
||||
extern template class devcb_read32::delegate_builder<read32sm_delegate>;
|
||||
extern template class devcb_read32::delegate_builder<read64sm_delegate>;
|
||||
extern template class devcb_read32::delegate_builder<read8smo_delegate>;
|
||||
extern template class devcb_read32::delegate_builder<read16smo_delegate>;
|
||||
extern template class devcb_read32::delegate_builder<read32smo_delegate>;
|
||||
extern template class devcb_read32::delegate_builder<read64smo_delegate>;
|
||||
extern template class devcb_read32::delegate_builder<read_line_delegate>;
|
||||
|
||||
extern template class devcb_read64::delegate_builder<read8_delegate>;
|
||||
extern template class devcb_read64::delegate_builder<read16_delegate>;
|
||||
extern template class devcb_read64::delegate_builder<read32_delegate>;
|
||||
extern template class devcb_read64::delegate_builder<read64_delegate>;
|
||||
extern template class devcb_read64::delegate_builder<read8s_delegate>;
|
||||
extern template class devcb_read64::delegate_builder<read16s_delegate>;
|
||||
extern template class devcb_read64::delegate_builder<read32s_delegate>;
|
||||
extern template class devcb_read64::delegate_builder<read64s_delegate>;
|
||||
extern template class devcb_read64::delegate_builder<read8sm_delegate>;
|
||||
extern template class devcb_read64::delegate_builder<read16sm_delegate>;
|
||||
extern template class devcb_read64::delegate_builder<read32sm_delegate>;
|
||||
extern template class devcb_read64::delegate_builder<read64sm_delegate>;
|
||||
extern template class devcb_read64::delegate_builder<read8smo_delegate>;
|
||||
extern template class devcb_read64::delegate_builder<read16smo_delegate>;
|
||||
extern template class devcb_read64::delegate_builder<read32smo_delegate>;
|
||||
extern template class devcb_read64::delegate_builder<read64smo_delegate>;
|
||||
extern template class devcb_read64::delegate_builder<read_line_delegate>;
|
||||
|
||||
extern template class devcb_read_line::delegate_builder<read8_delegate>;
|
||||
extern template class devcb_read_line::delegate_builder<read16_delegate>;
|
||||
extern template class devcb_read_line::delegate_builder<read32_delegate>;
|
||||
extern template class devcb_read_line::delegate_builder<read64_delegate>;
|
||||
extern template class devcb_read_line::delegate_builder<read8s_delegate>;
|
||||
extern template class devcb_read_line::delegate_builder<read16s_delegate>;
|
||||
extern template class devcb_read_line::delegate_builder<read32s_delegate>;
|
||||
extern template class devcb_read_line::delegate_builder<read64s_delegate>;
|
||||
extern template class devcb_read_line::delegate_builder<read8sm_delegate>;
|
||||
extern template class devcb_read_line::delegate_builder<read16sm_delegate>;
|
||||
extern template class devcb_read_line::delegate_builder<read32sm_delegate>;
|
||||
extern template class devcb_read_line::delegate_builder<read64sm_delegate>;
|
||||
extern template class devcb_read_line::delegate_builder<read8smo_delegate>;
|
||||
extern template class devcb_read_line::delegate_builder<read16smo_delegate>;
|
||||
extern template class devcb_read_line::delegate_builder<read32smo_delegate>;
|
||||
extern template class devcb_read_line::delegate_builder<read64smo_delegate>;
|
||||
extern template class devcb_read_line::delegate_builder<read_line_delegate>;
|
||||
|
||||
extern template class devcb_read8::creator_impl<devcb_read8::delegate_builder<read8_delegate> >;
|
||||
extern template class devcb_read8::creator_impl<devcb_read8::delegate_builder<read16_delegate> >;
|
||||
extern template class devcb_read8::creator_impl<devcb_read8::delegate_builder<read32_delegate> >;
|
||||
extern template class devcb_read8::creator_impl<devcb_read8::delegate_builder<read64_delegate> >;
|
||||
extern template class devcb_read8::creator_impl<devcb_read8::delegate_builder<read8s_delegate> >;
|
||||
extern template class devcb_read8::creator_impl<devcb_read8::delegate_builder<read16s_delegate> >;
|
||||
extern template class devcb_read8::creator_impl<devcb_read8::delegate_builder<read32s_delegate> >;
|
||||
extern template class devcb_read8::creator_impl<devcb_read8::delegate_builder<read64s_delegate> >;
|
||||
extern template class devcb_read8::creator_impl<devcb_read8::delegate_builder<read8sm_delegate> >;
|
||||
extern template class devcb_read8::creator_impl<devcb_read8::delegate_builder<read16sm_delegate> >;
|
||||
extern template class devcb_read8::creator_impl<devcb_read8::delegate_builder<read32sm_delegate> >;
|
||||
extern template class devcb_read8::creator_impl<devcb_read8::delegate_builder<read64sm_delegate> >;
|
||||
extern template class devcb_read8::creator_impl<devcb_read8::delegate_builder<read8smo_delegate> >;
|
||||
extern template class devcb_read8::creator_impl<devcb_read8::delegate_builder<read16smo_delegate> >;
|
||||
extern template class devcb_read8::creator_impl<devcb_read8::delegate_builder<read32smo_delegate> >;
|
||||
extern template class devcb_read8::creator_impl<devcb_read8::delegate_builder<read64smo_delegate> >;
|
||||
extern template class devcb_read8::creator_impl<devcb_read8::delegate_builder<read_line_delegate> >;
|
||||
extern template class devcb_read8::creator_impl<devcb_read8::ioport_builder>;
|
||||
|
||||
@ -2566,6 +2689,18 @@ extern template class devcb_read16::creator_impl<devcb_read16::delegate_builder<
|
||||
extern template class devcb_read16::creator_impl<devcb_read16::delegate_builder<read16_delegate> >;
|
||||
extern template class devcb_read16::creator_impl<devcb_read16::delegate_builder<read32_delegate> >;
|
||||
extern template class devcb_read16::creator_impl<devcb_read16::delegate_builder<read64_delegate> >;
|
||||
extern template class devcb_read16::creator_impl<devcb_read16::delegate_builder<read8s_delegate> >;
|
||||
extern template class devcb_read16::creator_impl<devcb_read16::delegate_builder<read16s_delegate> >;
|
||||
extern template class devcb_read16::creator_impl<devcb_read16::delegate_builder<read32s_delegate> >;
|
||||
extern template class devcb_read16::creator_impl<devcb_read16::delegate_builder<read64s_delegate> >;
|
||||
extern template class devcb_read16::creator_impl<devcb_read16::delegate_builder<read8sm_delegate> >;
|
||||
extern template class devcb_read16::creator_impl<devcb_read16::delegate_builder<read16sm_delegate> >;
|
||||
extern template class devcb_read16::creator_impl<devcb_read16::delegate_builder<read32sm_delegate> >;
|
||||
extern template class devcb_read16::creator_impl<devcb_read16::delegate_builder<read64sm_delegate> >;
|
||||
extern template class devcb_read16::creator_impl<devcb_read16::delegate_builder<read8smo_delegate> >;
|
||||
extern template class devcb_read16::creator_impl<devcb_read16::delegate_builder<read16smo_delegate> >;
|
||||
extern template class devcb_read16::creator_impl<devcb_read16::delegate_builder<read32smo_delegate> >;
|
||||
extern template class devcb_read16::creator_impl<devcb_read16::delegate_builder<read64smo_delegate> >;
|
||||
extern template class devcb_read16::creator_impl<devcb_read16::delegate_builder<read_line_delegate> >;
|
||||
extern template class devcb_read16::creator_impl<devcb_read16::ioport_builder>;
|
||||
|
||||
@ -2573,6 +2708,18 @@ extern template class devcb_read32::creator_impl<devcb_read32::delegate_builder<
|
||||
extern template class devcb_read32::creator_impl<devcb_read32::delegate_builder<read16_delegate> >;
|
||||
extern template class devcb_read32::creator_impl<devcb_read32::delegate_builder<read32_delegate> >;
|
||||
extern template class devcb_read32::creator_impl<devcb_read32::delegate_builder<read64_delegate> >;
|
||||
extern template class devcb_read32::creator_impl<devcb_read32::delegate_builder<read8s_delegate> >;
|
||||
extern template class devcb_read32::creator_impl<devcb_read32::delegate_builder<read16s_delegate> >;
|
||||
extern template class devcb_read32::creator_impl<devcb_read32::delegate_builder<read32s_delegate> >;
|
||||
extern template class devcb_read32::creator_impl<devcb_read32::delegate_builder<read64s_delegate> >;
|
||||
extern template class devcb_read32::creator_impl<devcb_read32::delegate_builder<read8sm_delegate> >;
|
||||
extern template class devcb_read32::creator_impl<devcb_read32::delegate_builder<read16sm_delegate> >;
|
||||
extern template class devcb_read32::creator_impl<devcb_read32::delegate_builder<read32sm_delegate> >;
|
||||
extern template class devcb_read32::creator_impl<devcb_read32::delegate_builder<read64sm_delegate> >;
|
||||
extern template class devcb_read32::creator_impl<devcb_read32::delegate_builder<read8smo_delegate> >;
|
||||
extern template class devcb_read32::creator_impl<devcb_read32::delegate_builder<read16smo_delegate> >;
|
||||
extern template class devcb_read32::creator_impl<devcb_read32::delegate_builder<read32smo_delegate> >;
|
||||
extern template class devcb_read32::creator_impl<devcb_read32::delegate_builder<read64smo_delegate> >;
|
||||
extern template class devcb_read32::creator_impl<devcb_read32::delegate_builder<read_line_delegate> >;
|
||||
extern template class devcb_read32::creator_impl<devcb_read32::ioport_builder>;
|
||||
|
||||
@ -2580,6 +2727,18 @@ extern template class devcb_read64::creator_impl<devcb_read64::delegate_builder<
|
||||
extern template class devcb_read64::creator_impl<devcb_read64::delegate_builder<read16_delegate> >;
|
||||
extern template class devcb_read64::creator_impl<devcb_read64::delegate_builder<read32_delegate> >;
|
||||
extern template class devcb_read64::creator_impl<devcb_read64::delegate_builder<read64_delegate> >;
|
||||
extern template class devcb_read64::creator_impl<devcb_read64::delegate_builder<read8s_delegate> >;
|
||||
extern template class devcb_read64::creator_impl<devcb_read64::delegate_builder<read16s_delegate> >;
|
||||
extern template class devcb_read64::creator_impl<devcb_read64::delegate_builder<read32s_delegate> >;
|
||||
extern template class devcb_read64::creator_impl<devcb_read64::delegate_builder<read64s_delegate> >;
|
||||
extern template class devcb_read64::creator_impl<devcb_read64::delegate_builder<read8sm_delegate> >;
|
||||
extern template class devcb_read64::creator_impl<devcb_read64::delegate_builder<read16sm_delegate> >;
|
||||
extern template class devcb_read64::creator_impl<devcb_read64::delegate_builder<read32sm_delegate> >;
|
||||
extern template class devcb_read64::creator_impl<devcb_read64::delegate_builder<read64sm_delegate> >;
|
||||
extern template class devcb_read64::creator_impl<devcb_read64::delegate_builder<read8smo_delegate> >;
|
||||
extern template class devcb_read64::creator_impl<devcb_read64::delegate_builder<read16smo_delegate> >;
|
||||
extern template class devcb_read64::creator_impl<devcb_read64::delegate_builder<read32smo_delegate> >;
|
||||
extern template class devcb_read64::creator_impl<devcb_read64::delegate_builder<read64smo_delegate> >;
|
||||
extern template class devcb_read64::creator_impl<devcb_read64::delegate_builder<read_line_delegate> >;
|
||||
extern template class devcb_read64::creator_impl<devcb_read64::ioport_builder>;
|
||||
|
||||
@ -2587,6 +2746,18 @@ extern template class devcb_read_line::creator_impl<devcb_read_line::delegate_bu
|
||||
extern template class devcb_read_line::creator_impl<devcb_read_line::delegate_builder<read16_delegate> >;
|
||||
extern template class devcb_read_line::creator_impl<devcb_read_line::delegate_builder<read32_delegate> >;
|
||||
extern template class devcb_read_line::creator_impl<devcb_read_line::delegate_builder<read64_delegate> >;
|
||||
extern template class devcb_read_line::creator_impl<devcb_read_line::delegate_builder<read8s_delegate> >;
|
||||
extern template class devcb_read_line::creator_impl<devcb_read_line::delegate_builder<read16s_delegate> >;
|
||||
extern template class devcb_read_line::creator_impl<devcb_read_line::delegate_builder<read32s_delegate> >;
|
||||
extern template class devcb_read_line::creator_impl<devcb_read_line::delegate_builder<read64s_delegate> >;
|
||||
extern template class devcb_read_line::creator_impl<devcb_read_line::delegate_builder<read8sm_delegate> >;
|
||||
extern template class devcb_read_line::creator_impl<devcb_read_line::delegate_builder<read16sm_delegate> >;
|
||||
extern template class devcb_read_line::creator_impl<devcb_read_line::delegate_builder<read32sm_delegate> >;
|
||||
extern template class devcb_read_line::creator_impl<devcb_read_line::delegate_builder<read64sm_delegate> >;
|
||||
extern template class devcb_read_line::creator_impl<devcb_read_line::delegate_builder<read8smo_delegate> >;
|
||||
extern template class devcb_read_line::creator_impl<devcb_read_line::delegate_builder<read16smo_delegate> >;
|
||||
extern template class devcb_read_line::creator_impl<devcb_read_line::delegate_builder<read32smo_delegate> >;
|
||||
extern template class devcb_read_line::creator_impl<devcb_read_line::delegate_builder<read64smo_delegate> >;
|
||||
extern template class devcb_read_line::creator_impl<devcb_read_line::delegate_builder<read_line_delegate> >;
|
||||
extern template class devcb_read_line::creator_impl<devcb_read_line::ioport_builder>;
|
||||
|
||||
@ -2600,36 +2771,108 @@ extern template class devcb_write8::delegate_builder<write8_delegate>;
|
||||
extern template class devcb_write8::delegate_builder<write16_delegate>;
|
||||
extern template class devcb_write8::delegate_builder<write32_delegate>;
|
||||
extern template class devcb_write8::delegate_builder<write64_delegate>;
|
||||
extern template class devcb_write8::delegate_builder<write8s_delegate>;
|
||||
extern template class devcb_write8::delegate_builder<write16s_delegate>;
|
||||
extern template class devcb_write8::delegate_builder<write32s_delegate>;
|
||||
extern template class devcb_write8::delegate_builder<write64s_delegate>;
|
||||
extern template class devcb_write8::delegate_builder<write8sm_delegate>;
|
||||
extern template class devcb_write8::delegate_builder<write16sm_delegate>;
|
||||
extern template class devcb_write8::delegate_builder<write32sm_delegate>;
|
||||
extern template class devcb_write8::delegate_builder<write64sm_delegate>;
|
||||
extern template class devcb_write8::delegate_builder<write8smo_delegate>;
|
||||
extern template class devcb_write8::delegate_builder<write16smo_delegate>;
|
||||
extern template class devcb_write8::delegate_builder<write32smo_delegate>;
|
||||
extern template class devcb_write8::delegate_builder<write64smo_delegate>;
|
||||
extern template class devcb_write8::delegate_builder<write_line_delegate>;
|
||||
|
||||
extern template class devcb_write16::delegate_builder<write8_delegate>;
|
||||
extern template class devcb_write16::delegate_builder<write16_delegate>;
|
||||
extern template class devcb_write16::delegate_builder<write32_delegate>;
|
||||
extern template class devcb_write16::delegate_builder<write64_delegate>;
|
||||
extern template class devcb_write16::delegate_builder<write8s_delegate>;
|
||||
extern template class devcb_write16::delegate_builder<write16s_delegate>;
|
||||
extern template class devcb_write16::delegate_builder<write32s_delegate>;
|
||||
extern template class devcb_write16::delegate_builder<write64s_delegate>;
|
||||
extern template class devcb_write16::delegate_builder<write8sm_delegate>;
|
||||
extern template class devcb_write16::delegate_builder<write16sm_delegate>;
|
||||
extern template class devcb_write16::delegate_builder<write32sm_delegate>;
|
||||
extern template class devcb_write16::delegate_builder<write64sm_delegate>;
|
||||
extern template class devcb_write16::delegate_builder<write8smo_delegate>;
|
||||
extern template class devcb_write16::delegate_builder<write16smo_delegate>;
|
||||
extern template class devcb_write16::delegate_builder<write32smo_delegate>;
|
||||
extern template class devcb_write16::delegate_builder<write64smo_delegate>;
|
||||
extern template class devcb_write16::delegate_builder<write_line_delegate>;
|
||||
|
||||
extern template class devcb_write32::delegate_builder<write8_delegate>;
|
||||
extern template class devcb_write32::delegate_builder<write16_delegate>;
|
||||
extern template class devcb_write32::delegate_builder<write32_delegate>;
|
||||
extern template class devcb_write32::delegate_builder<write64_delegate>;
|
||||
extern template class devcb_write32::delegate_builder<write8s_delegate>;
|
||||
extern template class devcb_write32::delegate_builder<write16s_delegate>;
|
||||
extern template class devcb_write32::delegate_builder<write32s_delegate>;
|
||||
extern template class devcb_write32::delegate_builder<write64s_delegate>;
|
||||
extern template class devcb_write32::delegate_builder<write8sm_delegate>;
|
||||
extern template class devcb_write32::delegate_builder<write16sm_delegate>;
|
||||
extern template class devcb_write32::delegate_builder<write32sm_delegate>;
|
||||
extern template class devcb_write32::delegate_builder<write64sm_delegate>;
|
||||
extern template class devcb_write32::delegate_builder<write8smo_delegate>;
|
||||
extern template class devcb_write32::delegate_builder<write16smo_delegate>;
|
||||
extern template class devcb_write32::delegate_builder<write32smo_delegate>;
|
||||
extern template class devcb_write32::delegate_builder<write64smo_delegate>;
|
||||
extern template class devcb_write32::delegate_builder<write_line_delegate>;
|
||||
|
||||
extern template class devcb_write64::delegate_builder<write8_delegate>;
|
||||
extern template class devcb_write64::delegate_builder<write16_delegate>;
|
||||
extern template class devcb_write64::delegate_builder<write32_delegate>;
|
||||
extern template class devcb_write64::delegate_builder<write64_delegate>;
|
||||
extern template class devcb_write64::delegate_builder<write8s_delegate>;
|
||||
extern template class devcb_write64::delegate_builder<write16s_delegate>;
|
||||
extern template class devcb_write64::delegate_builder<write32s_delegate>;
|
||||
extern template class devcb_write64::delegate_builder<write64s_delegate>;
|
||||
extern template class devcb_write64::delegate_builder<write8sm_delegate>;
|
||||
extern template class devcb_write64::delegate_builder<write16sm_delegate>;
|
||||
extern template class devcb_write64::delegate_builder<write32sm_delegate>;
|
||||
extern template class devcb_write64::delegate_builder<write64sm_delegate>;
|
||||
extern template class devcb_write64::delegate_builder<write8smo_delegate>;
|
||||
extern template class devcb_write64::delegate_builder<write16smo_delegate>;
|
||||
extern template class devcb_write64::delegate_builder<write32smo_delegate>;
|
||||
extern template class devcb_write64::delegate_builder<write64smo_delegate>;
|
||||
extern template class devcb_write64::delegate_builder<write_line_delegate>;
|
||||
|
||||
extern template class devcb_write_line::delegate_builder<write8_delegate>;
|
||||
extern template class devcb_write_line::delegate_builder<write16_delegate>;
|
||||
extern template class devcb_write_line::delegate_builder<write32_delegate>;
|
||||
extern template class devcb_write_line::delegate_builder<write64_delegate>;
|
||||
extern template class devcb_write_line::delegate_builder<write8s_delegate>;
|
||||
extern template class devcb_write_line::delegate_builder<write16s_delegate>;
|
||||
extern template class devcb_write_line::delegate_builder<write32s_delegate>;
|
||||
extern template class devcb_write_line::delegate_builder<write64s_delegate>;
|
||||
extern template class devcb_write_line::delegate_builder<write8sm_delegate>;
|
||||
extern template class devcb_write_line::delegate_builder<write16sm_delegate>;
|
||||
extern template class devcb_write_line::delegate_builder<write32sm_delegate>;
|
||||
extern template class devcb_write_line::delegate_builder<write64sm_delegate>;
|
||||
extern template class devcb_write_line::delegate_builder<write8smo_delegate>;
|
||||
extern template class devcb_write_line::delegate_builder<write16smo_delegate>;
|
||||
extern template class devcb_write_line::delegate_builder<write32smo_delegate>;
|
||||
extern template class devcb_write_line::delegate_builder<write64smo_delegate>;
|
||||
extern template class devcb_write_line::delegate_builder<write_line_delegate>;
|
||||
|
||||
extern template class devcb_write8::creator_impl<devcb_write8::delegate_builder<write8_delegate> >;
|
||||
extern template class devcb_write8::creator_impl<devcb_write8::delegate_builder<write16_delegate> >;
|
||||
extern template class devcb_write8::creator_impl<devcb_write8::delegate_builder<write32_delegate> >;
|
||||
extern template class devcb_write8::creator_impl<devcb_write8::delegate_builder<write64_delegate> >;
|
||||
extern template class devcb_write8::creator_impl<devcb_write8::delegate_builder<write8s_delegate> >;
|
||||
extern template class devcb_write8::creator_impl<devcb_write8::delegate_builder<write16s_delegate> >;
|
||||
extern template class devcb_write8::creator_impl<devcb_write8::delegate_builder<write32s_delegate> >;
|
||||
extern template class devcb_write8::creator_impl<devcb_write8::delegate_builder<write64s_delegate> >;
|
||||
extern template class devcb_write8::creator_impl<devcb_write8::delegate_builder<write8sm_delegate> >;
|
||||
extern template class devcb_write8::creator_impl<devcb_write8::delegate_builder<write16sm_delegate> >;
|
||||
extern template class devcb_write8::creator_impl<devcb_write8::delegate_builder<write32sm_delegate> >;
|
||||
extern template class devcb_write8::creator_impl<devcb_write8::delegate_builder<write64sm_delegate> >;
|
||||
extern template class devcb_write8::creator_impl<devcb_write8::delegate_builder<write8smo_delegate> >;
|
||||
extern template class devcb_write8::creator_impl<devcb_write8::delegate_builder<write16smo_delegate> >;
|
||||
extern template class devcb_write8::creator_impl<devcb_write8::delegate_builder<write32smo_delegate> >;
|
||||
extern template class devcb_write8::creator_impl<devcb_write8::delegate_builder<write64smo_delegate> >;
|
||||
extern template class devcb_write8::creator_impl<devcb_write8::delegate_builder<write_line_delegate> >;
|
||||
extern template class devcb_write8::creator_impl<devcb_write8::inputline_builder>;
|
||||
extern template class devcb_write8::creator_impl<devcb_write8::latched_inputline_builder>;
|
||||
@ -2642,6 +2885,18 @@ extern template class devcb_write16::creator_impl<devcb_write16::delegate_builde
|
||||
extern template class devcb_write16::creator_impl<devcb_write16::delegate_builder<write16_delegate> >;
|
||||
extern template class devcb_write16::creator_impl<devcb_write16::delegate_builder<write32_delegate> >;
|
||||
extern template class devcb_write16::creator_impl<devcb_write16::delegate_builder<write64_delegate> >;
|
||||
extern template class devcb_write16::creator_impl<devcb_write16::delegate_builder<write8s_delegate> >;
|
||||
extern template class devcb_write16::creator_impl<devcb_write16::delegate_builder<write16s_delegate> >;
|
||||
extern template class devcb_write16::creator_impl<devcb_write16::delegate_builder<write32s_delegate> >;
|
||||
extern template class devcb_write16::creator_impl<devcb_write16::delegate_builder<write64s_delegate> >;
|
||||
extern template class devcb_write16::creator_impl<devcb_write16::delegate_builder<write8sm_delegate> >;
|
||||
extern template class devcb_write16::creator_impl<devcb_write16::delegate_builder<write16sm_delegate> >;
|
||||
extern template class devcb_write16::creator_impl<devcb_write16::delegate_builder<write32sm_delegate> >;
|
||||
extern template class devcb_write16::creator_impl<devcb_write16::delegate_builder<write64sm_delegate> >;
|
||||
extern template class devcb_write16::creator_impl<devcb_write16::delegate_builder<write8smo_delegate> >;
|
||||
extern template class devcb_write16::creator_impl<devcb_write16::delegate_builder<write16smo_delegate> >;
|
||||
extern template class devcb_write16::creator_impl<devcb_write16::delegate_builder<write32smo_delegate> >;
|
||||
extern template class devcb_write16::creator_impl<devcb_write16::delegate_builder<write64smo_delegate> >;
|
||||
extern template class devcb_write16::creator_impl<devcb_write16::delegate_builder<write_line_delegate> >;
|
||||
extern template class devcb_write16::creator_impl<devcb_write16::inputline_builder>;
|
||||
extern template class devcb_write16::creator_impl<devcb_write16::latched_inputline_builder>;
|
||||
@ -2654,6 +2909,18 @@ extern template class devcb_write32::creator_impl<devcb_write32::delegate_builde
|
||||
extern template class devcb_write32::creator_impl<devcb_write32::delegate_builder<write16_delegate> >;
|
||||
extern template class devcb_write32::creator_impl<devcb_write32::delegate_builder<write32_delegate> >;
|
||||
extern template class devcb_write32::creator_impl<devcb_write32::delegate_builder<write64_delegate> >;
|
||||
extern template class devcb_write32::creator_impl<devcb_write32::delegate_builder<write8s_delegate> >;
|
||||
extern template class devcb_write32::creator_impl<devcb_write32::delegate_builder<write16s_delegate> >;
|
||||
extern template class devcb_write32::creator_impl<devcb_write32::delegate_builder<write32s_delegate> >;
|
||||
extern template class devcb_write32::creator_impl<devcb_write32::delegate_builder<write64s_delegate> >;
|
||||
extern template class devcb_write32::creator_impl<devcb_write32::delegate_builder<write8sm_delegate> >;
|
||||
extern template class devcb_write32::creator_impl<devcb_write32::delegate_builder<write16sm_delegate> >;
|
||||
extern template class devcb_write32::creator_impl<devcb_write32::delegate_builder<write32sm_delegate> >;
|
||||
extern template class devcb_write32::creator_impl<devcb_write32::delegate_builder<write64sm_delegate> >;
|
||||
extern template class devcb_write32::creator_impl<devcb_write32::delegate_builder<write8smo_delegate> >;
|
||||
extern template class devcb_write32::creator_impl<devcb_write32::delegate_builder<write16smo_delegate> >;
|
||||
extern template class devcb_write32::creator_impl<devcb_write32::delegate_builder<write32smo_delegate> >;
|
||||
extern template class devcb_write32::creator_impl<devcb_write32::delegate_builder<write64smo_delegate> >;
|
||||
extern template class devcb_write32::creator_impl<devcb_write32::delegate_builder<write_line_delegate> >;
|
||||
extern template class devcb_write32::creator_impl<devcb_write32::inputline_builder>;
|
||||
extern template class devcb_write32::creator_impl<devcb_write32::latched_inputline_builder>;
|
||||
@ -2666,6 +2933,18 @@ extern template class devcb_write64::creator_impl<devcb_write64::delegate_builde
|
||||
extern template class devcb_write64::creator_impl<devcb_write64::delegate_builder<write16_delegate> >;
|
||||
extern template class devcb_write64::creator_impl<devcb_write64::delegate_builder<write32_delegate> >;
|
||||
extern template class devcb_write64::creator_impl<devcb_write64::delegate_builder<write64_delegate> >;
|
||||
extern template class devcb_write64::creator_impl<devcb_write64::delegate_builder<write8s_delegate> >;
|
||||
extern template class devcb_write64::creator_impl<devcb_write64::delegate_builder<write16s_delegate> >;
|
||||
extern template class devcb_write64::creator_impl<devcb_write64::delegate_builder<write32s_delegate> >;
|
||||
extern template class devcb_write64::creator_impl<devcb_write64::delegate_builder<write64s_delegate> >;
|
||||
extern template class devcb_write64::creator_impl<devcb_write64::delegate_builder<write8sm_delegate> >;
|
||||
extern template class devcb_write64::creator_impl<devcb_write64::delegate_builder<write16sm_delegate> >;
|
||||
extern template class devcb_write64::creator_impl<devcb_write64::delegate_builder<write32sm_delegate> >;
|
||||
extern template class devcb_write64::creator_impl<devcb_write64::delegate_builder<write64sm_delegate> >;
|
||||
extern template class devcb_write64::creator_impl<devcb_write64::delegate_builder<write8smo_delegate> >;
|
||||
extern template class devcb_write64::creator_impl<devcb_write64::delegate_builder<write16smo_delegate> >;
|
||||
extern template class devcb_write64::creator_impl<devcb_write64::delegate_builder<write32smo_delegate> >;
|
||||
extern template class devcb_write64::creator_impl<devcb_write64::delegate_builder<write64smo_delegate> >;
|
||||
extern template class devcb_write64::creator_impl<devcb_write64::delegate_builder<write_line_delegate> >;
|
||||
extern template class devcb_write64::creator_impl<devcb_write64::inputline_builder>;
|
||||
extern template class devcb_write64::creator_impl<devcb_write64::latched_inputline_builder>;
|
||||
@ -2678,6 +2957,18 @@ extern template class devcb_write_line::creator_impl<devcb_write_line::delegate_
|
||||
extern template class devcb_write_line::creator_impl<devcb_write_line::delegate_builder<write16_delegate> >;
|
||||
extern template class devcb_write_line::creator_impl<devcb_write_line::delegate_builder<write32_delegate> >;
|
||||
extern template class devcb_write_line::creator_impl<devcb_write_line::delegate_builder<write64_delegate> >;
|
||||
extern template class devcb_write_line::creator_impl<devcb_write_line::delegate_builder<write8s_delegate> >;
|
||||
extern template class devcb_write_line::creator_impl<devcb_write_line::delegate_builder<write16s_delegate> >;
|
||||
extern template class devcb_write_line::creator_impl<devcb_write_line::delegate_builder<write32s_delegate> >;
|
||||
extern template class devcb_write_line::creator_impl<devcb_write_line::delegate_builder<write64s_delegate> >;
|
||||
extern template class devcb_write_line::creator_impl<devcb_write_line::delegate_builder<write8sm_delegate> >;
|
||||
extern template class devcb_write_line::creator_impl<devcb_write_line::delegate_builder<write16sm_delegate> >;
|
||||
extern template class devcb_write_line::creator_impl<devcb_write_line::delegate_builder<write32sm_delegate> >;
|
||||
extern template class devcb_write_line::creator_impl<devcb_write_line::delegate_builder<write64sm_delegate> >;
|
||||
extern template class devcb_write_line::creator_impl<devcb_write_line::delegate_builder<write8smo_delegate> >;
|
||||
extern template class devcb_write_line::creator_impl<devcb_write_line::delegate_builder<write16smo_delegate> >;
|
||||
extern template class devcb_write_line::creator_impl<devcb_write_line::delegate_builder<write32smo_delegate> >;
|
||||
extern template class devcb_write_line::creator_impl<devcb_write_line::delegate_builder<write64smo_delegate> >;
|
||||
extern template class devcb_write_line::creator_impl<devcb_write_line::delegate_builder<write_line_delegate> >;
|
||||
extern template class devcb_write_line::creator_impl<devcb_write_line::inputline_builder>;
|
||||
extern template class devcb_write_line::creator_impl<devcb_write_line::latched_inputline_builder>;
|
||||
|
||||
@ -258,6 +258,19 @@ public:
|
||||
void install_write_handler(offs_t addrstart, offs_t addrend, offs_t addrmask, offs_t addrmirror, offs_t addrselect, write64_delegate whandler, u64 unitmask = 0, int cswidth = 0) override;
|
||||
void install_readwrite_handler(offs_t addrstart, offs_t addrend, offs_t addrmask, offs_t addrmirror, offs_t addrselect, read64_delegate rhandler, write64_delegate whandler, u64 unitmask = 0, int cswidth = 0) override;
|
||||
|
||||
void install_read_handler(offs_t addrstart, offs_t addrend, offs_t addrmask, offs_t addrmirror, offs_t addrselect, read8m_delegate rhandler, u64 unitmask = 0, int cswidth = 0) override;
|
||||
void install_write_handler(offs_t addrstart, offs_t addrend, offs_t addrmask, offs_t addrmirror, offs_t addrselect, write8m_delegate whandler, u64 unitmask = 0, int cswidth = 0) override;
|
||||
void install_readwrite_handler(offs_t addrstart, offs_t addrend, offs_t addrmask, offs_t addrmirror, offs_t addrselect, read8m_delegate rhandler, write8m_delegate whandler, u64 unitmask = 0, int cswidth = 0) override;
|
||||
void install_read_handler(offs_t addrstart, offs_t addrend, offs_t addrmask, offs_t addrmirror, offs_t addrselect, read16m_delegate rhandler, u64 unitmask = 0, int cswidth = 0) override;
|
||||
void install_write_handler(offs_t addrstart, offs_t addrend, offs_t addrmask, offs_t addrmirror, offs_t addrselect, write16m_delegate whandler, u64 unitmask = 0, int cswidth = 0) override;
|
||||
void install_readwrite_handler(offs_t addrstart, offs_t addrend, offs_t addrmask, offs_t addrmirror, offs_t addrselect, read16m_delegate rhandler, write16m_delegate whandler, u64 unitmask = 0, int cswidth = 0) override;
|
||||
void install_read_handler(offs_t addrstart, offs_t addrend, offs_t addrmask, offs_t addrmirror, offs_t addrselect, read32m_delegate rhandler, u64 unitmask = 0, int cswidth = 0) override;
|
||||
void install_write_handler(offs_t addrstart, offs_t addrend, offs_t addrmask, offs_t addrmirror, offs_t addrselect, write32m_delegate whandler, u64 unitmask = 0, int cswidth = 0) override;
|
||||
void install_readwrite_handler(offs_t addrstart, offs_t addrend, offs_t addrmask, offs_t addrmirror, offs_t addrselect, read32m_delegate rhandler, write32m_delegate whandler, u64 unitmask = 0, int cswidth = 0) override;
|
||||
void install_read_handler(offs_t addrstart, offs_t addrend, offs_t addrmask, offs_t addrmirror, offs_t addrselect, read64m_delegate rhandler, u64 unitmask = 0, int cswidth = 0) override;
|
||||
void install_write_handler(offs_t addrstart, offs_t addrend, offs_t addrmask, offs_t addrmirror, offs_t addrselect, write64m_delegate whandler, u64 unitmask = 0, int cswidth = 0) override;
|
||||
void install_readwrite_handler(offs_t addrstart, offs_t addrend, offs_t addrmask, offs_t addrmirror, offs_t addrselect, read64m_delegate rhandler, write64m_delegate whandler, u64 unitmask = 0, int cswidth = 0) override;
|
||||
|
||||
void install_read_handler(offs_t addrstart, offs_t addrend, offs_t addrmask, offs_t addrmirror, offs_t addrselect, read8s_delegate rhandler, u64 unitmask = 0, int cswidth = 0) override;
|
||||
void install_write_handler(offs_t addrstart, offs_t addrend, offs_t addrmask, offs_t addrmirror, offs_t addrselect, write8s_delegate whandler, u64 unitmask = 0, int cswidth = 0) override;
|
||||
void install_readwrite_handler(offs_t addrstart, offs_t addrend, offs_t addrmask, offs_t addrmirror, offs_t addrselect, read8s_delegate rhandler, write8s_delegate whandler, u64 unitmask = 0, int cswidth = 0) override;
|
||||
@ -284,6 +297,19 @@ public:
|
||||
void install_write_handler(offs_t addrstart, offs_t addrend, offs_t addrmask, offs_t addrmirror, offs_t addrselect, write64sm_delegate whandler, u64 unitmask = 0, int cswidth = 0) override;
|
||||
void install_readwrite_handler(offs_t addrstart, offs_t addrend, offs_t addrmask, offs_t addrmirror, offs_t addrselect, read64sm_delegate rhandler, write64sm_delegate whandler, u64 unitmask = 0, int cswidth = 0) override;
|
||||
|
||||
void install_read_handler(offs_t addrstart, offs_t addrend, offs_t addrmask, offs_t addrmirror, offs_t addrselect, read8mo_delegate rhandler, u64 unitmask = 0, int cswidth = 0) override;
|
||||
void install_write_handler(offs_t addrstart, offs_t addrend, offs_t addrmask, offs_t addrmirror, offs_t addrselect, write8mo_delegate whandler, u64 unitmask = 0, int cswidth = 0) override;
|
||||
void install_readwrite_handler(offs_t addrstart, offs_t addrend, offs_t addrmask, offs_t addrmirror, offs_t addrselect, read8mo_delegate rhandler, write8mo_delegate whandler, u64 unitmask = 0, int cswidth = 0) override;
|
||||
void install_read_handler(offs_t addrstart, offs_t addrend, offs_t addrmask, offs_t addrmirror, offs_t addrselect, read16mo_delegate rhandler, u64 unitmask = 0, int cswidth = 0) override;
|
||||
void install_write_handler(offs_t addrstart, offs_t addrend, offs_t addrmask, offs_t addrmirror, offs_t addrselect, write16mo_delegate whandler, u64 unitmask = 0, int cswidth = 0) override;
|
||||
void install_readwrite_handler(offs_t addrstart, offs_t addrend, offs_t addrmask, offs_t addrmirror, offs_t addrselect, read16mo_delegate rhandler, write16mo_delegate whandler, u64 unitmask = 0, int cswidth = 0) override;
|
||||
void install_read_handler(offs_t addrstart, offs_t addrend, offs_t addrmask, offs_t addrmirror, offs_t addrselect, read32mo_delegate rhandler, u64 unitmask = 0, int cswidth = 0) override;
|
||||
void install_write_handler(offs_t addrstart, offs_t addrend, offs_t addrmask, offs_t addrmirror, offs_t addrselect, write32mo_delegate whandler, u64 unitmask = 0, int cswidth = 0) override;
|
||||
void install_readwrite_handler(offs_t addrstart, offs_t addrend, offs_t addrmask, offs_t addrmirror, offs_t addrselect, read32mo_delegate rhandler, write32mo_delegate whandler, u64 unitmask = 0, int cswidth = 0) override;
|
||||
void install_read_handler(offs_t addrstart, offs_t addrend, offs_t addrmask, offs_t addrmirror, offs_t addrselect, read64mo_delegate rhandler, u64 unitmask = 0, int cswidth = 0) override;
|
||||
void install_write_handler(offs_t addrstart, offs_t addrend, offs_t addrmask, offs_t addrmirror, offs_t addrselect, write64mo_delegate whandler, u64 unitmask = 0, int cswidth = 0) override;
|
||||
void install_readwrite_handler(offs_t addrstart, offs_t addrend, offs_t addrmask, offs_t addrmirror, offs_t addrselect, read64mo_delegate rhandler, write64mo_delegate whandler, u64 unitmask = 0, int cswidth = 0) override;
|
||||
|
||||
void install_read_handler(offs_t addrstart, offs_t addrend, offs_t addrmask, offs_t addrmirror, offs_t addrselect, read8smo_delegate rhandler, u64 unitmask = 0, int cswidth = 0) override;
|
||||
void install_write_handler(offs_t addrstart, offs_t addrend, offs_t addrmask, offs_t addrmirror, offs_t addrselect, write8smo_delegate whandler, u64 unitmask = 0, int cswidth = 0) override;
|
||||
void install_readwrite_handler(offs_t addrstart, offs_t addrend, offs_t addrmask, offs_t addrmirror, offs_t addrselect, read8smo_delegate rhandler, write8smo_delegate whandler, u64 unitmask = 0, int cswidth = 0) override;
|
||||
@ -1295,7 +1321,7 @@ void address_space::populate_map_entry(const address_map_entry &entry, read_or_w
|
||||
unmap_generic(entry.m_addrstart, entry.m_addrend, entry.m_addrmirror, readorwrite, false);
|
||||
break;
|
||||
|
||||
case AMH_DEVICE_DELEGATE_F:
|
||||
case AMH_DEVICE_DELEGATE:
|
||||
if (readorwrite == read_or_write::READ)
|
||||
switch (data.m_bits)
|
||||
{
|
||||
@ -1314,6 +1340,25 @@ void address_space::populate_map_entry(const address_map_entry &entry, read_or_w
|
||||
}
|
||||
break;
|
||||
|
||||
case AMH_DEVICE_DELEGATE_M:
|
||||
if (readorwrite == read_or_write::READ)
|
||||
switch (data.m_bits)
|
||||
{
|
||||
case 8: install_read_handler(entry.m_addrstart, entry.m_addrend, entry.m_addrmask, entry.m_addrmirror, entry.m_addrselect, read8m_delegate(entry.m_rproto8m, entry.m_devbase), entry.m_mask, entry.m_cswidth); break;
|
||||
case 16: install_read_handler(entry.m_addrstart, entry.m_addrend, entry.m_addrmask, entry.m_addrmirror, entry.m_addrselect, read16m_delegate(entry.m_rproto16m, entry.m_devbase), entry.m_mask, entry.m_cswidth); break;
|
||||
case 32: install_read_handler(entry.m_addrstart, entry.m_addrend, entry.m_addrmask, entry.m_addrmirror, entry.m_addrselect, read32m_delegate(entry.m_rproto32m, entry.m_devbase), entry.m_mask, entry.m_cswidth); break;
|
||||
case 64: install_read_handler(entry.m_addrstart, entry.m_addrend, entry.m_addrmask, entry.m_addrmirror, entry.m_addrselect, read64m_delegate(entry.m_rproto64m, entry.m_devbase), entry.m_mask, entry.m_cswidth); break;
|
||||
}
|
||||
else
|
||||
switch (data.m_bits)
|
||||
{
|
||||
case 8: install_write_handler(entry.m_addrstart, entry.m_addrend, entry.m_addrmask, entry.m_addrmirror, entry.m_addrselect, write8m_delegate(entry.m_wproto8m, entry.m_devbase), entry.m_mask, entry.m_cswidth); break;
|
||||
case 16: install_write_handler(entry.m_addrstart, entry.m_addrend, entry.m_addrmask, entry.m_addrmirror, entry.m_addrselect, write16m_delegate(entry.m_wproto16m, entry.m_devbase), entry.m_mask, entry.m_cswidth); break;
|
||||
case 32: install_write_handler(entry.m_addrstart, entry.m_addrend, entry.m_addrmask, entry.m_addrmirror, entry.m_addrselect, write32m_delegate(entry.m_wproto32m, entry.m_devbase), entry.m_mask, entry.m_cswidth); break;
|
||||
case 64: install_write_handler(entry.m_addrstart, entry.m_addrend, entry.m_addrmask, entry.m_addrmirror, entry.m_addrselect, write64m_delegate(entry.m_wproto64m, entry.m_devbase), entry.m_mask, entry.m_cswidth); break;
|
||||
}
|
||||
break;
|
||||
|
||||
case AMH_DEVICE_DELEGATE_S:
|
||||
if (readorwrite == read_or_write::READ)
|
||||
switch (data.m_bits)
|
||||
@ -1352,6 +1397,25 @@ void address_space::populate_map_entry(const address_map_entry &entry, read_or_w
|
||||
}
|
||||
break;
|
||||
|
||||
case AMH_DEVICE_DELEGATE_MO:
|
||||
if (readorwrite == read_or_write::READ)
|
||||
switch (data.m_bits)
|
||||
{
|
||||
case 8: install_read_handler(entry.m_addrstart, entry.m_addrend, entry.m_addrmask, entry.m_addrmirror, entry.m_addrselect, read8mo_delegate(entry.m_rproto8mo, entry.m_devbase), entry.m_mask, entry.m_cswidth); break;
|
||||
case 16: install_read_handler(entry.m_addrstart, entry.m_addrend, entry.m_addrmask, entry.m_addrmirror, entry.m_addrselect, read16mo_delegate(entry.m_rproto16mo, entry.m_devbase), entry.m_mask, entry.m_cswidth); break;
|
||||
case 32: install_read_handler(entry.m_addrstart, entry.m_addrend, entry.m_addrmask, entry.m_addrmirror, entry.m_addrselect, read32mo_delegate(entry.m_rproto32mo, entry.m_devbase), entry.m_mask, entry.m_cswidth); break;
|
||||
case 64: install_read_handler(entry.m_addrstart, entry.m_addrend, entry.m_addrmask, entry.m_addrmirror, entry.m_addrselect, read64mo_delegate(entry.m_rproto64mo, entry.m_devbase), entry.m_mask, entry.m_cswidth); break;
|
||||
}
|
||||
else
|
||||
switch (data.m_bits)
|
||||
{
|
||||
case 8: install_write_handler(entry.m_addrstart, entry.m_addrend, entry.m_addrmask, entry.m_addrmirror, entry.m_addrselect, write8mo_delegate(entry.m_wproto8mo, entry.m_devbase), entry.m_mask, entry.m_cswidth); break;
|
||||
case 16: install_write_handler(entry.m_addrstart, entry.m_addrend, entry.m_addrmask, entry.m_addrmirror, entry.m_addrselect, write16mo_delegate(entry.m_wproto16mo, entry.m_devbase), entry.m_mask, entry.m_cswidth); break;
|
||||
case 32: install_write_handler(entry.m_addrstart, entry.m_addrend, entry.m_addrmask, entry.m_addrmirror, entry.m_addrselect, write32mo_delegate(entry.m_wproto32mo, entry.m_devbase), entry.m_mask, entry.m_cswidth); break;
|
||||
case 64: install_write_handler(entry.m_addrstart, entry.m_addrend, entry.m_addrmask, entry.m_addrmirror, entry.m_addrselect, write64mo_delegate(entry.m_wproto64mo, entry.m_devbase), entry.m_mask, entry.m_cswidth); break;
|
||||
}
|
||||
break;
|
||||
|
||||
case AMH_DEVICE_DELEGATE_SMO:
|
||||
if (readorwrite == read_or_write::READ)
|
||||
switch (data.m_bits)
|
||||
@ -1991,6 +2055,21 @@ template<int Width, int AddrShift, endianness_t Endian> void address_space_speci
|
||||
install_readwrite_handler_helper<0>(addrstart, addrend, addrmask, addrmirror, addrselect, unitmask, cswidth, rhandler, whandler);
|
||||
}
|
||||
|
||||
template<int Width, int AddrShift, endianness_t Endian> void address_space_specific<Width, AddrShift, Endian>::install_read_handler(offs_t addrstart, offs_t addrend, offs_t addrmask, offs_t addrmirror, offs_t addrselect, read8m_delegate handler, u64 unitmask, int cswidth)
|
||||
{
|
||||
install_read_handler_helper<0>(addrstart, addrend, addrmask, addrmirror, addrselect, unitmask, cswidth, handler);
|
||||
}
|
||||
|
||||
template<int Width, int AddrShift, endianness_t Endian> void address_space_specific<Width, AddrShift, Endian>::install_write_handler(offs_t addrstart, offs_t addrend, offs_t addrmask, offs_t addrmirror, offs_t addrselect, write8m_delegate handler, u64 unitmask, int cswidth)
|
||||
{
|
||||
install_write_handler_helper<0>(addrstart, addrend, addrmask, addrmirror, addrselect, unitmask, cswidth, handler);
|
||||
}
|
||||
|
||||
template<int Width, int AddrShift, endianness_t Endian> void address_space_specific<Width, AddrShift, Endian>::install_readwrite_handler(offs_t addrstart, offs_t addrend, offs_t addrmask, offs_t addrmirror, offs_t addrselect, read8m_delegate rhandler, write8m_delegate whandler, u64 unitmask, int cswidth)
|
||||
{
|
||||
install_readwrite_handler_helper<0>(addrstart, addrend, addrmask, addrmirror, addrselect, unitmask, cswidth, rhandler, whandler);
|
||||
}
|
||||
|
||||
template<int Width, int AddrShift, endianness_t Endian> void address_space_specific<Width, AddrShift, Endian>::install_read_handler(offs_t addrstart, offs_t addrend, offs_t addrmask, offs_t addrmirror, offs_t addrselect, read8s_delegate handler, u64 unitmask, int cswidth)
|
||||
{
|
||||
install_read_handler_helper<0>(addrstart, addrend, addrmask, addrmirror, addrselect, unitmask, cswidth, handler);
|
||||
@ -2021,6 +2100,21 @@ template<int Width, int AddrShift, endianness_t Endian> void address_space_speci
|
||||
install_readwrite_handler_helper<0>(addrstart, addrend, addrmask, addrmirror, addrselect, unitmask, cswidth, rhandler, whandler);
|
||||
}
|
||||
|
||||
template<int Width, int AddrShift, endianness_t Endian> void address_space_specific<Width, AddrShift, Endian>::install_read_handler(offs_t addrstart, offs_t addrend, offs_t addrmask, offs_t addrmirror, offs_t addrselect, read8mo_delegate handler, u64 unitmask, int cswidth)
|
||||
{
|
||||
install_read_handler_helper<0>(addrstart, addrend, addrmask, addrmirror, addrselect, unitmask, cswidth, handler);
|
||||
}
|
||||
|
||||
template<int Width, int AddrShift, endianness_t Endian> void address_space_specific<Width, AddrShift, Endian>::install_write_handler(offs_t addrstart, offs_t addrend, offs_t addrmask, offs_t addrmirror, offs_t addrselect, write8mo_delegate handler, u64 unitmask, int cswidth)
|
||||
{
|
||||
install_write_handler_helper<0>(addrstart, addrend, addrmask, addrmirror, addrselect, unitmask, cswidth, handler);
|
||||
}
|
||||
|
||||
template<int Width, int AddrShift, endianness_t Endian> void address_space_specific<Width, AddrShift, Endian>::install_readwrite_handler(offs_t addrstart, offs_t addrend, offs_t addrmask, offs_t addrmirror, offs_t addrselect, read8mo_delegate rhandler, write8mo_delegate whandler, u64 unitmask, int cswidth)
|
||||
{
|
||||
install_readwrite_handler_helper<0>(addrstart, addrend, addrmask, addrmirror, addrselect, unitmask, cswidth, rhandler, whandler);
|
||||
}
|
||||
|
||||
template<int Width, int AddrShift, endianness_t Endian> void address_space_specific<Width, AddrShift, Endian>::install_read_handler(offs_t addrstart, offs_t addrend, offs_t addrmask, offs_t addrmirror, offs_t addrselect, read8smo_delegate handler, u64 unitmask, int cswidth)
|
||||
{
|
||||
install_read_handler_helper<0>(addrstart, addrend, addrmask, addrmirror, addrselect, unitmask, cswidth, handler);
|
||||
@ -2057,6 +2151,21 @@ template<int Width, int AddrShift, endianness_t Endian> void address_space_speci
|
||||
install_readwrite_handler_helper<1>(addrstart, addrend, addrmask, addrmirror, addrselect, unitmask, cswidth, rhandler, whandler);
|
||||
}
|
||||
|
||||
template<int Width, int AddrShift, endianness_t Endian> void address_space_specific<Width, AddrShift, Endian>::install_read_handler(offs_t addrstart, offs_t addrend, offs_t addrmask, offs_t addrmirror, offs_t addrselect, read16m_delegate handler, u64 unitmask, int cswidth)
|
||||
{
|
||||
install_read_handler_helper<1>(addrstart, addrend, addrmask, addrmirror, addrselect, unitmask, cswidth, handler);
|
||||
}
|
||||
|
||||
template<int Width, int AddrShift, endianness_t Endian> void address_space_specific<Width, AddrShift, Endian>::install_write_handler(offs_t addrstart, offs_t addrend, offs_t addrmask, offs_t addrmirror, offs_t addrselect, write16m_delegate handler, u64 unitmask, int cswidth)
|
||||
{
|
||||
install_write_handler_helper<1>(addrstart, addrend, addrmask, addrmirror, addrselect, unitmask, cswidth, handler);
|
||||
}
|
||||
|
||||
template<int Width, int AddrShift, endianness_t Endian> void address_space_specific<Width, AddrShift, Endian>::install_readwrite_handler(offs_t addrstart, offs_t addrend, offs_t addrmask, offs_t addrmirror, offs_t addrselect, read16m_delegate rhandler, write16m_delegate whandler, u64 unitmask, int cswidth)
|
||||
{
|
||||
install_readwrite_handler_helper<1>(addrstart, addrend, addrmask, addrmirror, addrselect, unitmask, cswidth, rhandler, whandler);
|
||||
}
|
||||
|
||||
template<int Width, int AddrShift, endianness_t Endian> void address_space_specific<Width, AddrShift, Endian>::install_read_handler(offs_t addrstart, offs_t addrend, offs_t addrmask, offs_t addrmirror, offs_t addrselect, read16s_delegate handler, u64 unitmask, int cswidth)
|
||||
{
|
||||
install_read_handler_helper<1>(addrstart, addrend, addrmask, addrmirror, addrselect, unitmask, cswidth, handler);
|
||||
@ -2102,6 +2211,21 @@ template<int Width, int AddrShift, endianness_t Endian> void address_space_speci
|
||||
install_readwrite_handler_helper<1>(addrstart, addrend, addrmask, addrmirror, addrselect, unitmask, cswidth, rhandler, whandler);
|
||||
}
|
||||
|
||||
template<int Width, int AddrShift, endianness_t Endian> void address_space_specific<Width, AddrShift, Endian>::install_read_handler(offs_t addrstart, offs_t addrend, offs_t addrmask, offs_t addrmirror, offs_t addrselect, read16mo_delegate handler, u64 unitmask, int cswidth)
|
||||
{
|
||||
install_read_handler_helper<1>(addrstart, addrend, addrmask, addrmirror, addrselect, unitmask, cswidth, handler);
|
||||
}
|
||||
|
||||
template<int Width, int AddrShift, endianness_t Endian> void address_space_specific<Width, AddrShift, Endian>::install_write_handler(offs_t addrstart, offs_t addrend, offs_t addrmask, offs_t addrmirror, offs_t addrselect, write16mo_delegate handler, u64 unitmask, int cswidth)
|
||||
{
|
||||
install_write_handler_helper<1>(addrstart, addrend, addrmask, addrmirror, addrselect, unitmask, cswidth, handler);
|
||||
}
|
||||
|
||||
template<int Width, int AddrShift, endianness_t Endian> void address_space_specific<Width, AddrShift, Endian>::install_readwrite_handler(offs_t addrstart, offs_t addrend, offs_t addrmask, offs_t addrmirror, offs_t addrselect, read16mo_delegate rhandler, write16mo_delegate whandler, u64 unitmask, int cswidth)
|
||||
{
|
||||
install_readwrite_handler_helper<1>(addrstart, addrend, addrmask, addrmirror, addrselect, unitmask, cswidth, rhandler, whandler);
|
||||
}
|
||||
|
||||
|
||||
//-------------------------------------------------
|
||||
// install_handler - install 32-bit read/write
|
||||
@ -2123,6 +2247,21 @@ template<int Width, int AddrShift, endianness_t Endian> void address_space_speci
|
||||
install_readwrite_handler_helper<2>(addrstart, addrend, addrmask, addrmirror, addrselect, unitmask, cswidth, rhandler, whandler);
|
||||
}
|
||||
|
||||
template<int Width, int AddrShift, endianness_t Endian> void address_space_specific<Width, AddrShift, Endian>::install_read_handler(offs_t addrstart, offs_t addrend, offs_t addrmask, offs_t addrmirror, offs_t addrselect, read32m_delegate handler, u64 unitmask, int cswidth)
|
||||
{
|
||||
install_read_handler_helper<2>(addrstart, addrend, addrmask, addrmirror, addrselect, unitmask, cswidth, handler);
|
||||
}
|
||||
|
||||
template<int Width, int AddrShift, endianness_t Endian> void address_space_specific<Width, AddrShift, Endian>::install_write_handler(offs_t addrstart, offs_t addrend, offs_t addrmask, offs_t addrmirror, offs_t addrselect, write32m_delegate handler, u64 unitmask, int cswidth)
|
||||
{
|
||||
install_write_handler_helper<2>(addrstart, addrend, addrmask, addrmirror, addrselect, unitmask, cswidth, handler);
|
||||
}
|
||||
|
||||
template<int Width, int AddrShift, endianness_t Endian> void address_space_specific<Width, AddrShift, Endian>::install_readwrite_handler(offs_t addrstart, offs_t addrend, offs_t addrmask, offs_t addrmirror, offs_t addrselect, read32m_delegate rhandler, write32m_delegate whandler, u64 unitmask, int cswidth)
|
||||
{
|
||||
install_readwrite_handler_helper<2>(addrstart, addrend, addrmask, addrmirror, addrselect, unitmask, cswidth, rhandler, whandler);
|
||||
}
|
||||
|
||||
template<int Width, int AddrShift, endianness_t Endian> void address_space_specific<Width, AddrShift, Endian>::install_read_handler(offs_t addrstart, offs_t addrend, offs_t addrmask, offs_t addrmirror, offs_t addrselect, read32s_delegate handler, u64 unitmask, int cswidth)
|
||||
{
|
||||
install_read_handler_helper<2>(addrstart, addrend, addrmask, addrmirror, addrselect, unitmask, cswidth, handler);
|
||||
@ -2153,6 +2292,21 @@ template<int Width, int AddrShift, endianness_t Endian> void address_space_speci
|
||||
install_readwrite_handler_helper<2>(addrstart, addrend, addrmask, addrmirror, addrselect, unitmask, cswidth, rhandler, whandler);
|
||||
}
|
||||
|
||||
template<int Width, int AddrShift, endianness_t Endian> void address_space_specific<Width, AddrShift, Endian>::install_read_handler(offs_t addrstart, offs_t addrend, offs_t addrmask, offs_t addrmirror, offs_t addrselect, read32mo_delegate handler, u64 unitmask, int cswidth)
|
||||
{
|
||||
install_read_handler_helper<2>(addrstart, addrend, addrmask, addrmirror, addrselect, unitmask, cswidth, handler);
|
||||
}
|
||||
|
||||
template<int Width, int AddrShift, endianness_t Endian> void address_space_specific<Width, AddrShift, Endian>::install_write_handler(offs_t addrstart, offs_t addrend, offs_t addrmask, offs_t addrmirror, offs_t addrselect, write32mo_delegate handler, u64 unitmask, int cswidth)
|
||||
{
|
||||
install_write_handler_helper<2>(addrstart, addrend, addrmask, addrmirror, addrselect, unitmask, cswidth, handler);
|
||||
}
|
||||
|
||||
template<int Width, int AddrShift, endianness_t Endian> void address_space_specific<Width, AddrShift, Endian>::install_readwrite_handler(offs_t addrstart, offs_t addrend, offs_t addrmask, offs_t addrmirror, offs_t addrselect, read32mo_delegate rhandler, write32mo_delegate whandler, u64 unitmask, int cswidth)
|
||||
{
|
||||
install_readwrite_handler_helper<2>(addrstart, addrend, addrmask, addrmirror, addrselect, unitmask, cswidth, rhandler, whandler);
|
||||
}
|
||||
|
||||
template<int Width, int AddrShift, endianness_t Endian> void address_space_specific<Width, AddrShift, Endian>::install_read_handler(offs_t addrstart, offs_t addrend, offs_t addrmask, offs_t addrmirror, offs_t addrselect, read32smo_delegate handler, u64 unitmask, int cswidth)
|
||||
{
|
||||
install_read_handler_helper<2>(addrstart, addrend, addrmask, addrmirror, addrselect, unitmask, cswidth, handler);
|
||||
@ -2189,6 +2343,21 @@ template<int Width, int AddrShift, endianness_t Endian> void address_space_speci
|
||||
install_readwrite_handler_helper<3>(addrstart, addrend, addrmask, addrmirror, addrselect, unitmask, cswidth, rhandler, whandler);
|
||||
}
|
||||
|
||||
template<int Width, int AddrShift, endianness_t Endian> void address_space_specific<Width, AddrShift, Endian>::install_read_handler(offs_t addrstart, offs_t addrend, offs_t addrmask, offs_t addrmirror, offs_t addrselect, read64m_delegate handler, u64 unitmask, int cswidth)
|
||||
{
|
||||
install_read_handler_helper<3>(addrstart, addrend, addrmask, addrmirror, addrselect, unitmask, cswidth, handler);
|
||||
}
|
||||
|
||||
template<int Width, int AddrShift, endianness_t Endian> void address_space_specific<Width, AddrShift, Endian>::install_write_handler(offs_t addrstart, offs_t addrend, offs_t addrmask, offs_t addrmirror, offs_t addrselect, write64m_delegate handler, u64 unitmask, int cswidth)
|
||||
{
|
||||
install_write_handler_helper<3>(addrstart, addrend, addrmask, addrmirror, addrselect, unitmask, cswidth, handler);
|
||||
}
|
||||
|
||||
template<int Width, int AddrShift, endianness_t Endian> void address_space_specific<Width, AddrShift, Endian>::install_readwrite_handler(offs_t addrstart, offs_t addrend, offs_t addrmask, offs_t addrmirror, offs_t addrselect, read64m_delegate rhandler, write64m_delegate whandler, u64 unitmask, int cswidth)
|
||||
{
|
||||
install_readwrite_handler_helper<3>(addrstart, addrend, addrmask, addrmirror, addrselect, unitmask, cswidth, rhandler, whandler);
|
||||
}
|
||||
|
||||
template<int Width, int AddrShift, endianness_t Endian> void address_space_specific<Width, AddrShift, Endian>::install_read_handler(offs_t addrstart, offs_t addrend, offs_t addrmask, offs_t addrmirror, offs_t addrselect, read64s_delegate handler, u64 unitmask, int cswidth)
|
||||
{
|
||||
install_read_handler_helper<3>(addrstart, addrend, addrmask, addrmirror, addrselect, unitmask, cswidth, handler);
|
||||
@ -2219,6 +2388,21 @@ template<int Width, int AddrShift, endianness_t Endian> void address_space_speci
|
||||
install_readwrite_handler_helper<3>(addrstart, addrend, addrmask, addrmirror, addrselect, unitmask, cswidth, rhandler, whandler);
|
||||
}
|
||||
|
||||
template<int Width, int AddrShift, endianness_t Endian> void address_space_specific<Width, AddrShift, Endian>::install_read_handler(offs_t addrstart, offs_t addrend, offs_t addrmask, offs_t addrmirror, offs_t addrselect, read64mo_delegate handler, u64 unitmask, int cswidth)
|
||||
{
|
||||
install_read_handler_helper<3>(addrstart, addrend, addrmask, addrmirror, addrselect, unitmask, cswidth, handler);
|
||||
}
|
||||
|
||||
template<int Width, int AddrShift, endianness_t Endian> void address_space_specific<Width, AddrShift, Endian>::install_write_handler(offs_t addrstart, offs_t addrend, offs_t addrmask, offs_t addrmirror, offs_t addrselect, write64mo_delegate handler, u64 unitmask, int cswidth)
|
||||
{
|
||||
install_write_handler_helper<3>(addrstart, addrend, addrmask, addrmirror, addrselect, unitmask, cswidth, handler);
|
||||
}
|
||||
|
||||
template<int Width, int AddrShift, endianness_t Endian> void address_space_specific<Width, AddrShift, Endian>::install_readwrite_handler(offs_t addrstart, offs_t addrend, offs_t addrmask, offs_t addrmirror, offs_t addrselect, read64mo_delegate rhandler, write64mo_delegate whandler, u64 unitmask, int cswidth)
|
||||
{
|
||||
install_readwrite_handler_helper<3>(addrstart, addrend, addrmask, addrmirror, addrselect, unitmask, cswidth, rhandler, whandler);
|
||||
}
|
||||
|
||||
template<int Width, int AddrShift, endianness_t Endian> void address_space_specific<Width, AddrShift, Endian>::install_read_handler(offs_t addrstart, offs_t addrend, offs_t addrmask, offs_t addrmirror, offs_t addrselect, read64smo_delegate handler, u64 unitmask, int cswidth)
|
||||
{
|
||||
install_read_handler_helper<3>(addrstart, addrend, addrmask, addrmirror, addrselect, unitmask, cswidth, handler);
|
||||
|
||||
190
src/emu/emumem.h
190
src/emu/emumem.h
@ -94,6 +94,11 @@ using read16_delegate = device_delegate<u16 (address_space &, offs_t, u16)>;
|
||||
using read32_delegate = device_delegate<u32 (address_space &, offs_t, u32)>;
|
||||
using read64_delegate = device_delegate<u64 (address_space &, offs_t, u64)>;
|
||||
|
||||
using read8m_delegate = device_delegate<u8 (address_space &, offs_t)>;
|
||||
using read16m_delegate = device_delegate<u16 (address_space &, offs_t)>;
|
||||
using read32m_delegate = device_delegate<u32 (address_space &, offs_t)>;
|
||||
using read64m_delegate = device_delegate<u64 (address_space &, offs_t)>;
|
||||
|
||||
using read8s_delegate = device_delegate<u8 (offs_t, u8 )>;
|
||||
using read16s_delegate = device_delegate<u16 (offs_t, u16)>;
|
||||
using read32s_delegate = device_delegate<u32 (offs_t, u32)>;
|
||||
@ -104,6 +109,11 @@ using read16sm_delegate = device_delegate<u16 (offs_t)>;
|
||||
using read32sm_delegate = device_delegate<u32 (offs_t)>;
|
||||
using read64sm_delegate = device_delegate<u64 (offs_t)>;
|
||||
|
||||
using read8mo_delegate = device_delegate<u8 (address_space &)>;
|
||||
using read16mo_delegate = device_delegate<u16 (address_space &)>;
|
||||
using read32mo_delegate = device_delegate<u32 (address_space &)>;
|
||||
using read64mo_delegate = device_delegate<u64 (address_space &)>;
|
||||
|
||||
using read8smo_delegate = device_delegate<u8 ()>;
|
||||
using read16smo_delegate = device_delegate<u16 ()>;
|
||||
using read32smo_delegate = device_delegate<u32 ()>;
|
||||
@ -118,6 +128,11 @@ using write16_delegate = device_delegate<void (address_space &, offs_t, u16, u16
|
||||
using write32_delegate = device_delegate<void (address_space &, offs_t, u32, u32)>;
|
||||
using write64_delegate = device_delegate<void (address_space &, offs_t, u64, u64)>;
|
||||
|
||||
using write8m_delegate = device_delegate<void (address_space &, offs_t, u8 )>;
|
||||
using write16m_delegate = device_delegate<void (address_space &, offs_t, u16)>;
|
||||
using write32m_delegate = device_delegate<void (address_space &, offs_t, u32)>;
|
||||
using write64m_delegate = device_delegate<void (address_space &, offs_t, u64)>;
|
||||
|
||||
using write8s_delegate = device_delegate<void (offs_t, u8, u8 )>;
|
||||
using write16s_delegate = device_delegate<void (offs_t, u16, u16)>;
|
||||
using write32s_delegate = device_delegate<void (offs_t, u32, u32)>;
|
||||
@ -128,6 +143,11 @@ using write16sm_delegate = device_delegate<void (offs_t, u16)>;
|
||||
using write32sm_delegate = device_delegate<void (offs_t, u32)>;
|
||||
using write64sm_delegate = device_delegate<void (offs_t, u64)>;
|
||||
|
||||
using write8mo_delegate = device_delegate<void (address_space &, u8 )>;
|
||||
using write16mo_delegate = device_delegate<void (address_space &, u16)>;
|
||||
using write32mo_delegate = device_delegate<void (address_space &, u32)>;
|
||||
using write64mo_delegate = device_delegate<void (address_space &, u64)>;
|
||||
|
||||
using write8smo_delegate = device_delegate<void (u8 )>;
|
||||
using write16smo_delegate = device_delegate<void (u16)>;
|
||||
using write32smo_delegate = device_delegate<void (u32)>;
|
||||
@ -176,6 +196,33 @@ inline write64_delegate make_delegate(T &&func, const char *name, const char *ta
|
||||
{ return write64_delegate(func, name, tag, obj); }
|
||||
|
||||
|
||||
template <typename T>
|
||||
inline read8m_delegate make_delegate(T &&func, const char *name, const char *tag, rw_device_class_t<read8m_delegate, std::remove_reference_t<T> > *obj)
|
||||
{ return read8m_delegate(func, name, tag, obj); }
|
||||
template <typename T>
|
||||
inline read16m_delegate make_delegate(T &&func, const char *name, const char *tag, rw_device_class_t<read16m_delegate, std::remove_reference_t<T> > *obj)
|
||||
{ return read16m_delegate(func, name, tag, obj); }
|
||||
template <typename T>
|
||||
inline read32m_delegate make_delegate(T &&func, const char *name, const char *tag, rw_device_class_t<read32m_delegate, std::remove_reference_t<T> > *obj)
|
||||
{ return read32m_delegate(func, name, tag, obj); }
|
||||
template <typename T>
|
||||
inline read64m_delegate make_delegate(T &&func, const char *name, const char *tag, rw_device_class_t<read64m_delegate, std::remove_reference_t<T> > *obj)
|
||||
{ return read64m_delegate(func, name, tag, obj); }
|
||||
|
||||
template <typename T>
|
||||
inline write8m_delegate make_delegate(T &&func, const char *name, const char *tag, rw_device_class_t<write8m_delegate, std::remove_reference_t<T> > *obj)
|
||||
{ return write8m_delegate(func, name, tag, obj); }
|
||||
template <typename T>
|
||||
inline write16m_delegate make_delegate(T &&func, const char *name, const char *tag, rw_device_class_t<write16m_delegate, std::remove_reference_t<T> > *obj)
|
||||
{ return write16m_delegate(func, name, tag, obj); }
|
||||
template <typename T>
|
||||
inline write32m_delegate make_delegate(T &&func, const char *name, const char *tag, rw_device_class_t<write32m_delegate, std::remove_reference_t<T> > *obj)
|
||||
{ return write32m_delegate(func, name, tag, obj); }
|
||||
template <typename T>
|
||||
inline write64m_delegate make_delegate(T &&func, const char *name, const char *tag, rw_device_class_t<write64m_delegate, std::remove_reference_t<T> > *obj)
|
||||
{ return write64m_delegate(func, name, tag, obj); }
|
||||
|
||||
|
||||
template <typename T>
|
||||
inline read8s_delegate make_delegate(T &&func, const char *name, const char *tag, rw_device_class_t<read8s_delegate, std::remove_reference_t<T> > *obj)
|
||||
{ return read8s_delegate(func, name, tag, obj); }
|
||||
@ -230,6 +277,33 @@ inline write64sm_delegate make_delegate(T &&func, const char *name, const char *
|
||||
{ return write64sm_delegate(func, name, tag, obj); }
|
||||
|
||||
|
||||
template <typename T>
|
||||
inline read8mo_delegate make_delegate(T &&func, const char *name, const char *tag, rw_device_class_t<read8mo_delegate, std::remove_reference_t<T> > *obj)
|
||||
{ return read8mo_delegate(func, name, tag, obj); }
|
||||
template <typename T>
|
||||
inline read16mo_delegate make_delegate(T &&func, const char *name, const char *tag, rw_device_class_t<read16mo_delegate, std::remove_reference_t<T> > *obj)
|
||||
{ return read16mo_delegate(func, name, tag, obj); }
|
||||
template <typename T>
|
||||
inline read32mo_delegate make_delegate(T &&func, const char *name, const char *tag, rw_device_class_t<read32mo_delegate, std::remove_reference_t<T> > *obj)
|
||||
{ return read32mo_delegate(func, name, tag, obj); }
|
||||
template <typename T>
|
||||
inline read64mo_delegate make_delegate(T &&func, const char *name, const char *tag, rw_device_class_t<read64mo_delegate, std::remove_reference_t<T> > *obj)
|
||||
{ return read64mo_delegate(func, name, tag, obj); }
|
||||
|
||||
template <typename T>
|
||||
inline write8mo_delegate make_delegate(T &&func, const char *name, const char *tag, rw_device_class_t<write8mo_delegate, std::remove_reference_t<T> > *obj)
|
||||
{ return write8mo_delegate(func, name, tag, obj); }
|
||||
template <typename T>
|
||||
inline write16mo_delegate make_delegate(T &&func, const char *name, const char *tag, rw_device_class_t<write16mo_delegate, std::remove_reference_t<T> > *obj)
|
||||
{ return write16mo_delegate(func, name, tag, obj); }
|
||||
template <typename T>
|
||||
inline write32mo_delegate make_delegate(T &&func, const char *name, const char *tag, rw_device_class_t<write32mo_delegate, std::remove_reference_t<T> > *obj)
|
||||
{ return write32mo_delegate(func, name, tag, obj); }
|
||||
template <typename T>
|
||||
inline write64mo_delegate make_delegate(T &&func, const char *name, const char *tag, rw_device_class_t<write64mo_delegate, std::remove_reference_t<T> > *obj)
|
||||
{ return write64mo_delegate(func, name, tag, obj); }
|
||||
|
||||
|
||||
template <typename T>
|
||||
inline read8smo_delegate make_delegate(T &&func, const char *name, const char *tag, rw_device_class_t<read8smo_delegate, std::remove_reference_t<T> > *obj)
|
||||
{ return read8smo_delegate(func, name, tag, obj); }
|
||||
@ -262,6 +336,10 @@ template <typename L>
|
||||
inline std::enable_if_t<std::is_constructible<read8_delegate, L, const char *>::value, read8_delegate> make_lr8_delegate(L l, const char *name)
|
||||
{ return read8_delegate(l, name); }
|
||||
|
||||
template <typename L>
|
||||
inline std::enable_if_t<std::is_constructible<read8m_delegate, L, const char *>::value, read8m_delegate> make_lr8_delegate(L l, const char *name)
|
||||
{ return read8m_delegate(l, name); }
|
||||
|
||||
template <typename L>
|
||||
inline std::enable_if_t<std::is_constructible<read8s_delegate, L, const char *>::value, read8s_delegate> make_lr8_delegate(L l, const char *name)
|
||||
{ return read8s_delegate(l, name); }
|
||||
@ -270,6 +348,10 @@ template <typename L>
|
||||
inline std::enable_if_t<std::is_constructible<read8sm_delegate, L, const char *>::value, read8sm_delegate> make_lr8_delegate(L l, const char *name)
|
||||
{ return read8sm_delegate(l, name); }
|
||||
|
||||
template <typename L>
|
||||
inline std::enable_if_t<std::is_constructible<read8mo_delegate, L, const char *>::value, read8mo_delegate> make_lr8_delegate(L l, const char *name)
|
||||
{ return read8mo_delegate(l, name); }
|
||||
|
||||
template <typename L>
|
||||
inline std::enable_if_t<std::is_constructible<read8smo_delegate, L, const char *>::value, read8smo_delegate> make_lr8_delegate(L l, const char *name)
|
||||
{ return read8smo_delegate(l, name); }
|
||||
@ -278,6 +360,10 @@ template <typename L>
|
||||
inline std::enable_if_t<std::is_constructible<read16_delegate, L, const char *>::value, read16_delegate> make_lr16_delegate(L l, const char *name)
|
||||
{ return read16_delegate(l, name); }
|
||||
|
||||
template <typename L>
|
||||
inline std::enable_if_t<std::is_constructible<read16m_delegate, L, const char *>::value, read16m_delegate> make_lr16_delegate(L l, const char *name)
|
||||
{ return read16m_delegate(l, name); }
|
||||
|
||||
template <typename L>
|
||||
inline std::enable_if_t<std::is_constructible<read16s_delegate, L, const char *>::value, read16s_delegate> make_lr16_delegate(L l, const char *name)
|
||||
{ return read16s_delegate(l, name); }
|
||||
@ -286,6 +372,10 @@ template <typename L>
|
||||
inline std::enable_if_t<std::is_constructible<read16sm_delegate, L, const char *>::value, read16sm_delegate> make_lr16_delegate(L l, const char *name)
|
||||
{ return read16sm_delegate(l, name); }
|
||||
|
||||
template <typename L>
|
||||
inline std::enable_if_t<std::is_constructible<read16mo_delegate, L, const char *>::value, read16mo_delegate> make_lr16_delegate(L l, const char *name)
|
||||
{ return read16mo_delegate(l, name); }
|
||||
|
||||
template <typename L>
|
||||
inline std::enable_if_t<std::is_constructible<read16smo_delegate, L, const char *>::value, read16smo_delegate> make_lr16_delegate(L l, const char *name)
|
||||
{ return read16smo_delegate(l, name); }
|
||||
@ -294,6 +384,10 @@ template <typename L>
|
||||
inline std::enable_if_t<std::is_constructible<read32_delegate, L, const char *>::value, read32_delegate> make_lr32_delegate(L l, const char *name)
|
||||
{ return read32_delegate(l, name); }
|
||||
|
||||
template <typename L>
|
||||
inline std::enable_if_t<std::is_constructible<read32m_delegate, L, const char *>::value, read32m_delegate> make_lr32_delegate(L l, const char *name)
|
||||
{ return read32m_delegate(l, name); }
|
||||
|
||||
template <typename L>
|
||||
inline std::enable_if_t<std::is_constructible<read32s_delegate, L, const char *>::value, read32s_delegate> make_lr32_delegate(L l, const char *name)
|
||||
{ return read32s_delegate(l, name); }
|
||||
@ -302,6 +396,10 @@ template <typename L>
|
||||
inline std::enable_if_t<std::is_constructible<read32sm_delegate, L, const char *>::value, read32sm_delegate> make_lr32_delegate(L l, const char *name)
|
||||
{ return read32sm_delegate(l, name); }
|
||||
|
||||
template <typename L>
|
||||
inline std::enable_if_t<std::is_constructible<read32mo_delegate, L, const char *>::value, read32mo_delegate> make_lr32_delegate(L l, const char *name)
|
||||
{ return read32mo_delegate(l, name); }
|
||||
|
||||
template <typename L>
|
||||
inline std::enable_if_t<std::is_constructible<read32smo_delegate, L, const char *>::value, read32smo_delegate> make_lr32_delegate(L l, const char *name)
|
||||
{ return read32smo_delegate(l, name); }
|
||||
@ -310,6 +408,10 @@ template <typename L>
|
||||
inline std::enable_if_t<std::is_constructible<read64_delegate, L, const char *>::value, read64_delegate> make_lr64_delegate(L l, const char *name)
|
||||
{ return read64_delegate(l, name); }
|
||||
|
||||
template <typename L>
|
||||
inline std::enable_if_t<std::is_constructible<read64m_delegate, L, const char *>::value, read64m_delegate> make_lr64_delegate(L l, const char *name)
|
||||
{ return read64m_delegate(l, name); }
|
||||
|
||||
template <typename L>
|
||||
inline std::enable_if_t<std::is_constructible<read64s_delegate, L, const char *>::value, read64s_delegate> make_lr64_delegate(L l, const char *name)
|
||||
{ return read64s_delegate(l, name); }
|
||||
@ -318,6 +420,10 @@ template <typename L>
|
||||
inline std::enable_if_t<std::is_constructible<read64sm_delegate, L, const char *>::value, read64sm_delegate> make_lr64_delegate(L l, const char *name)
|
||||
{ return read64sm_delegate(l, name); }
|
||||
|
||||
template <typename L>
|
||||
inline std::enable_if_t<std::is_constructible<read64mo_delegate, L, const char *>::value, read64mo_delegate> make_lr64_delegate(L l, const char *name)
|
||||
{ return read64mo_delegate(l, name); }
|
||||
|
||||
template <typename L>
|
||||
inline std::enable_if_t<std::is_constructible<read64smo_delegate, L, const char *>::value, read64smo_delegate> make_lr64_delegate(L l, const char *name)
|
||||
{ return read64smo_delegate(l, name); }
|
||||
@ -327,6 +433,10 @@ template <typename L>
|
||||
inline std::enable_if_t<std::is_constructible<write8_delegate, L, const char *>::value, write8_delegate> make_lw8_delegate(L l, const char *name)
|
||||
{ return write8_delegate(l, name); }
|
||||
|
||||
template <typename L>
|
||||
inline std::enable_if_t<std::is_constructible<write8m_delegate, L, const char *>::value, write8m_delegate> make_lw8_delegate(L l, const char *name)
|
||||
{ return write8m_delegate(l, name); }
|
||||
|
||||
template <typename L>
|
||||
inline std::enable_if_t<std::is_constructible<write8s_delegate, L, const char *>::value, write8s_delegate> make_lw8_delegate(L l, const char *name)
|
||||
{ return write8s_delegate(l, name); }
|
||||
@ -335,6 +445,10 @@ template <typename L>
|
||||
inline std::enable_if_t<std::is_constructible<write8sm_delegate, L, const char *>::value, write8sm_delegate> make_lw8_delegate(L l, const char *name)
|
||||
{ return write8sm_delegate(l, name); }
|
||||
|
||||
template <typename L>
|
||||
inline std::enable_if_t<std::is_constructible<write8mo_delegate, L, const char *>::value, write8mo_delegate> make_lw8_delegate(L l, const char *name)
|
||||
{ return write8mo_delegate(l, name); }
|
||||
|
||||
template <typename L>
|
||||
inline std::enable_if_t<std::is_constructible<write8smo_delegate, L, const char *>::value, write8smo_delegate> make_lw8_delegate(L l, const char *name)
|
||||
{ return write8smo_delegate(l, name); }
|
||||
@ -343,6 +457,10 @@ template <typename L>
|
||||
inline std::enable_if_t<std::is_constructible<write16_delegate, L, const char *>::value, write16_delegate> make_lw16_delegate(L l, const char *name)
|
||||
{ return write16_delegate(l, name); }
|
||||
|
||||
template <typename L>
|
||||
inline std::enable_if_t<std::is_constructible<write16m_delegate, L, const char *>::value, write16m_delegate> make_lw16_delegate(L l, const char *name)
|
||||
{ return write16m_delegate(l, name); }
|
||||
|
||||
template <typename L>
|
||||
inline std::enable_if_t<std::is_constructible<write16s_delegate, L, const char *>::value, write16s_delegate> make_lw16_delegate(L l, const char *name)
|
||||
{ return write16s_delegate(l, name); }
|
||||
@ -351,6 +469,10 @@ template <typename L>
|
||||
inline std::enable_if_t<std::is_constructible<write16sm_delegate, L, const char *>::value, write16sm_delegate> make_lw16_delegate(L l, const char *name)
|
||||
{ return write16sm_delegate(l, name); }
|
||||
|
||||
template <typename L>
|
||||
inline std::enable_if_t<std::is_constructible<write16mo_delegate, L, const char *>::value, write16mo_delegate> make_lw16_delegate(L l, const char *name)
|
||||
{ return write16mo_delegate(l, name); }
|
||||
|
||||
template <typename L>
|
||||
inline std::enable_if_t<std::is_constructible<write16smo_delegate, L, const char *>::value, write16smo_delegate> make_lw16_delegate(L l, const char *name)
|
||||
{ return write16smo_delegate(l, name); }
|
||||
@ -359,6 +481,10 @@ template <typename L>
|
||||
inline std::enable_if_t<std::is_constructible<write32_delegate, L, const char *>::value, write32_delegate> make_lw32_delegate(L l, const char *name)
|
||||
{ return write32_delegate(l, name); }
|
||||
|
||||
template <typename L>
|
||||
inline std::enable_if_t<std::is_constructible<write32m_delegate, L, const char *>::value, write32m_delegate> make_lw32_delegate(L l, const char *name)
|
||||
{ return write32m_delegate(l, name); }
|
||||
|
||||
template <typename L>
|
||||
inline std::enable_if_t<std::is_constructible<write32s_delegate, L, const char *>::value, write32s_delegate> make_lw32_delegate(L l, const char *name)
|
||||
{ return write32s_delegate(l, name); }
|
||||
@ -367,6 +493,10 @@ template <typename L>
|
||||
inline std::enable_if_t<std::is_constructible<write32sm_delegate, L, const char *>::value, write32sm_delegate> make_lw32_delegate(L l, const char *name)
|
||||
{ return write32sm_delegate(l, name); }
|
||||
|
||||
template <typename L>
|
||||
inline std::enable_if_t<std::is_constructible<write32mo_delegate, L, const char *>::value, write32mo_delegate> make_lw32_delegate(L l, const char *name)
|
||||
{ return write32mo_delegate(l, name); }
|
||||
|
||||
template <typename L>
|
||||
inline std::enable_if_t<std::is_constructible<write32smo_delegate, L, const char *>::value, write32smo_delegate> make_lw32_delegate(L l, const char *name)
|
||||
{ return write32smo_delegate(l, name); }
|
||||
@ -375,6 +505,10 @@ template <typename L>
|
||||
inline std::enable_if_t<std::is_constructible<write64_delegate, L, const char *>::value, write64_delegate> make_lw64_delegate(L l, const char *name)
|
||||
{ return write64_delegate(l, name); }
|
||||
|
||||
template <typename L>
|
||||
inline std::enable_if_t<std::is_constructible<write64m_delegate, L, const char *>::value, write64m_delegate> make_lw64_delegate(L l, const char *name)
|
||||
{ return write64m_delegate(l, name); }
|
||||
|
||||
template <typename L>
|
||||
inline std::enable_if_t<std::is_constructible<write64s_delegate, L, const char *>::value, write64s_delegate> make_lw64_delegate(L l, const char *name)
|
||||
{ return write64s_delegate(l, name); }
|
||||
@ -383,6 +517,10 @@ template <typename L>
|
||||
inline std::enable_if_t<std::is_constructible<write64sm_delegate, L, const char *>::value, write64sm_delegate> make_lw64_delegate(L l, const char *name)
|
||||
{ return write64sm_delegate(l, name); }
|
||||
|
||||
template <typename L>
|
||||
inline std::enable_if_t<std::is_constructible<write64mo_delegate, L, const char *>::value, write64mo_delegate> make_lw64_delegate(L l, const char *name)
|
||||
{ return write64mo_delegate(l, name); }
|
||||
|
||||
template <typename L>
|
||||
inline std::enable_if_t<std::is_constructible<write64smo_delegate, L, const char *>::value, write64smo_delegate> make_lw64_delegate(L l, const char *name)
|
||||
{ return write64smo_delegate(l, name); }
|
||||
@ -1240,6 +1378,19 @@ public:
|
||||
void install_write_handler(offs_t addrstart, offs_t addrend, write64_delegate whandler, u64 unitmask = 0, int cswidth = 0) { install_write_handler(addrstart, addrend, 0, 0, 0, whandler, unitmask, cswidth); }
|
||||
void install_readwrite_handler(offs_t addrstart, offs_t addrend, read64_delegate rhandler, write64_delegate whandler, u64 unitmask = 0, int cswidth = 0) { install_readwrite_handler(addrstart, addrend, 0, 0, 0, rhandler, whandler, unitmask, cswidth); }
|
||||
|
||||
void install_read_handler(offs_t addrstart, offs_t addrend, read8m_delegate rhandler, u64 unitmask = 0, int cswidth = 0) { install_read_handler(addrstart, addrend, 0, 0, 0, rhandler, unitmask, cswidth); }
|
||||
void install_write_handler(offs_t addrstart, offs_t addrend, write8m_delegate whandler, u64 unitmask = 0, int cswidth = 0) { install_write_handler(addrstart, addrend, 0, 0, 0, whandler, unitmask, cswidth); }
|
||||
void install_readwrite_handler(offs_t addrstart, offs_t addrend, read8m_delegate rhandler, write8m_delegate whandler, u64 unitmask = 0, int cswidth = 0) { return install_readwrite_handler(addrstart, addrend, 0, 0, 0, rhandler, whandler, unitmask, cswidth); }
|
||||
void install_read_handler(offs_t addrstart, offs_t addrend, read16m_delegate rhandler, u64 unitmask = 0, int cswidth = 0) { install_read_handler(addrstart, addrend, 0, 0, 0, rhandler, unitmask, cswidth); }
|
||||
void install_write_handler(offs_t addrstart, offs_t addrend, write16m_delegate whandler, u64 unitmask = 0, int cswidth = 0) { install_write_handler(addrstart, addrend, 0, 0, 0, whandler, unitmask, cswidth); }
|
||||
void install_readwrite_handler(offs_t addrstart, offs_t addrend, read16m_delegate rhandler, write16m_delegate whandler, u64 unitmask = 0, int cswidth = 0) { return install_readwrite_handler(addrstart, addrend, 0, 0, 0, rhandler, whandler, unitmask, cswidth); }
|
||||
void install_read_handler(offs_t addrstart, offs_t addrend, read32m_delegate rhandler, u64 unitmask = 0, int cswidth = 0) { install_read_handler(addrstart, addrend, 0, 0, 0, rhandler, unitmask, cswidth); }
|
||||
void install_write_handler(offs_t addrstart, offs_t addrend, write32m_delegate whandler, u64 unitmask = 0, int cswidth = 0) { install_write_handler(addrstart, addrend, 0, 0, 0, whandler, unitmask, cswidth); }
|
||||
void install_readwrite_handler(offs_t addrstart, offs_t addrend, read32m_delegate rhandler, write32m_delegate whandler, u64 unitmask = 0, int cswidth = 0) { return install_readwrite_handler(addrstart, addrend, 0, 0, 0, rhandler, whandler, unitmask, cswidth); }
|
||||
void install_read_handler(offs_t addrstart, offs_t addrend, read64m_delegate rhandler, u64 unitmask = 0, int cswidth = 0) { install_read_handler(addrstart, addrend, 0, 0, 0, rhandler, unitmask, cswidth); }
|
||||
void install_write_handler(offs_t addrstart, offs_t addrend, write64m_delegate whandler, u64 unitmask = 0, int cswidth = 0) { install_write_handler(addrstart, addrend, 0, 0, 0, whandler, unitmask, cswidth); }
|
||||
void install_readwrite_handler(offs_t addrstart, offs_t addrend, read64m_delegate rhandler, write64m_delegate whandler, u64 unitmask = 0, int cswidth = 0) { install_readwrite_handler(addrstart, addrend, 0, 0, 0, rhandler, whandler, unitmask, cswidth); }
|
||||
|
||||
void install_read_handler(offs_t addrstart, offs_t addrend, read8s_delegate rhandler, u64 unitmask = 0, int cswidth = 0) { install_read_handler(addrstart, addrend, 0, 0, 0, rhandler, unitmask, cswidth); }
|
||||
void install_write_handler(offs_t addrstart, offs_t addrend, write8s_delegate whandler, u64 unitmask = 0, int cswidth = 0) { install_write_handler(addrstart, addrend, 0, 0, 0, whandler, unitmask, cswidth); }
|
||||
void install_readwrite_handler(offs_t addrstart, offs_t addrend, read8s_delegate rhandler, write8s_delegate whandler, u64 unitmask = 0, int cswidth = 0) { return install_readwrite_handler(addrstart, addrend, 0, 0, 0, rhandler, whandler, unitmask, cswidth); }
|
||||
@ -1266,6 +1417,19 @@ public:
|
||||
void install_write_handler(offs_t addrstart, offs_t addrend, write64sm_delegate whandler, u64 unitmask = 0, int cswidth = 0) { install_write_handler(addrstart, addrend, 0, 0, 0, whandler, unitmask, cswidth); }
|
||||
void install_readwrite_handler(offs_t addrstart, offs_t addrend, read64sm_delegate rhandler, write64sm_delegate whandler, u64 unitmask = 0, int cswidth = 0) { install_readwrite_handler(addrstart, addrend, 0, 0, 0, rhandler, whandler, unitmask, cswidth); }
|
||||
|
||||
void install_read_handler(offs_t addrstart, offs_t addrend, read8mo_delegate rhandler, u64 unitmask = 0, int cswidth = 0) { install_read_handler(addrstart, addrend, 0, 0, 0, rhandler, unitmask, cswidth); }
|
||||
void install_write_handler(offs_t addrstart, offs_t addrend, write8mo_delegate whandler, u64 unitmask = 0, int cswidth = 0) { install_write_handler(addrstart, addrend, 0, 0, 0, whandler, unitmask, cswidth); }
|
||||
void install_readwrite_handler(offs_t addrstart, offs_t addrend, read8mo_delegate rhandler, write8mo_delegate whandler, u64 unitmask = 0, int cswidth = 0) { return install_readwrite_handler(addrstart, addrend, 0, 0, 0, rhandler, whandler, unitmask, cswidth); }
|
||||
void install_read_handler(offs_t addrstart, offs_t addrend, read16mo_delegate rhandler, u64 unitmask = 0, int cswidth = 0) { install_read_handler(addrstart, addrend, 0, 0, 0, rhandler, unitmask, cswidth); }
|
||||
void install_write_handler(offs_t addrstart, offs_t addrend, write16mo_delegate whandler, u64 unitmask = 0, int cswidth = 0) { install_write_handler(addrstart, addrend, 0, 0, 0, whandler, unitmask, cswidth); }
|
||||
void install_readwrite_handler(offs_t addrstart, offs_t addrend, read16mo_delegate rhandler, write16mo_delegate whandler, u64 unitmask = 0, int cswidth = 0) { return install_readwrite_handler(addrstart, addrend, 0, 0, 0, rhandler, whandler, unitmask, cswidth); }
|
||||
void install_read_handler(offs_t addrstart, offs_t addrend, read32mo_delegate rhandler, u64 unitmask = 0, int cswidth = 0) { install_read_handler(addrstart, addrend, 0, 0, 0, rhandler, unitmask, cswidth); }
|
||||
void install_write_handler(offs_t addrstart, offs_t addrend, write32mo_delegate whandler, u64 unitmask = 0, int cswidth = 0) { install_write_handler(addrstart, addrend, 0, 0, 0, whandler, unitmask, cswidth); }
|
||||
void install_readwrite_handler(offs_t addrstart, offs_t addrend, read32mo_delegate rhandler, write32mo_delegate whandler, u64 unitmask = 0, int cswidth = 0) { return install_readwrite_handler(addrstart, addrend, 0, 0, 0, rhandler, whandler, unitmask, cswidth); }
|
||||
void install_read_handler(offs_t addrstart, offs_t addrend, read64mo_delegate rhandler, u64 unitmask = 0, int cswidth = 0) { install_read_handler(addrstart, addrend, 0, 0, 0, rhandler, unitmask, cswidth); }
|
||||
void install_write_handler(offs_t addrstart, offs_t addrend, write64mo_delegate whandler, u64 unitmask = 0, int cswidth = 0) { install_write_handler(addrstart, addrend, 0, 0, 0, whandler, unitmask, cswidth); }
|
||||
void install_readwrite_handler(offs_t addrstart, offs_t addrend, read64mo_delegate rhandler, write64mo_delegate whandler, u64 unitmask = 0, int cswidth = 0) { install_readwrite_handler(addrstart, addrend, 0, 0, 0, rhandler, whandler, unitmask, cswidth); }
|
||||
|
||||
void install_read_handler(offs_t addrstart, offs_t addrend, read8smo_delegate rhandler, u64 unitmask = 0, int cswidth = 0) { install_read_handler(addrstart, addrend, 0, 0, 0, rhandler, unitmask, cswidth); }
|
||||
void install_write_handler(offs_t addrstart, offs_t addrend, write8smo_delegate whandler, u64 unitmask = 0, int cswidth = 0) { install_write_handler(addrstart, addrend, 0, 0, 0, whandler, unitmask, cswidth); }
|
||||
void install_readwrite_handler(offs_t addrstart, offs_t addrend, read8smo_delegate rhandler, write8smo_delegate whandler, u64 unitmask = 0, int cswidth = 0) { return install_readwrite_handler(addrstart, addrend, 0, 0, 0, rhandler, whandler, unitmask, cswidth); }
|
||||
@ -1293,6 +1457,19 @@ public:
|
||||
virtual void install_write_handler(offs_t addrstart, offs_t addrend, offs_t addrmask, offs_t addrmirror, offs_t addrselect, write64_delegate whandler, u64 unitmask = 0, int cswidth = 0) = 0;
|
||||
virtual void install_readwrite_handler(offs_t addrstart, offs_t addrend, offs_t addrmask, offs_t addrmirror, offs_t addrselect, read64_delegate rhandler, write64_delegate whandler, u64 unitmask = 0, int cswidth = 0) = 0;
|
||||
|
||||
virtual void install_read_handler(offs_t addrstart, offs_t addrend, offs_t addrmask, offs_t addrmirror, offs_t addrselect, read8m_delegate rhandler, u64 unitmask = 0, int cswidth = 0) = 0;
|
||||
virtual void install_write_handler(offs_t addrstart, offs_t addrend, offs_t addrmask, offs_t addrmirror, offs_t addrselect, write8m_delegate whandler, u64 unitmask = 0, int cswidth = 0) = 0;
|
||||
virtual void install_readwrite_handler(offs_t addrstart, offs_t addrend, offs_t addrmask, offs_t addrmirror, offs_t addrselect, read8m_delegate rhandler, write8m_delegate whandler, u64 unitmask = 0, int cswidth = 0) = 0;
|
||||
virtual void install_read_handler(offs_t addrstart, offs_t addrend, offs_t addrmask, offs_t addrmirror, offs_t addrselect, read16m_delegate rhandler, u64 unitmask = 0, int cswidth = 0) = 0;
|
||||
virtual void install_write_handler(offs_t addrstart, offs_t addrend, offs_t addrmask, offs_t addrmirror, offs_t addrselect, write16m_delegate whandler, u64 unitmask = 0, int cswidth = 0) = 0;
|
||||
virtual void install_readwrite_handler(offs_t addrstart, offs_t addrend, offs_t addrmask, offs_t addrmirror, offs_t addrselect, read16m_delegate rhandler, write16m_delegate whandler, u64 unitmask = 0, int cswidth = 0) = 0;
|
||||
virtual void install_read_handler(offs_t addrstart, offs_t addrend, offs_t addrmask, offs_t addrmirror, offs_t addrselect, read32m_delegate rhandler, u64 unitmask = 0, int cswidth = 0) = 0;
|
||||
virtual void install_write_handler(offs_t addrstart, offs_t addrend, offs_t addrmask, offs_t addrmirror, offs_t addrselect, write32m_delegate whandler, u64 unitmask = 0, int cswidth = 0) = 0;
|
||||
virtual void install_readwrite_handler(offs_t addrstart, offs_t addrend, offs_t addrmask, offs_t addrmirror, offs_t addrselect, read32m_delegate rhandler, write32m_delegate whandler, u64 unitmask = 0, int cswidth = 0) = 0;
|
||||
virtual void install_read_handler(offs_t addrstart, offs_t addrend, offs_t addrmask, offs_t addrmirror, offs_t addrselect, read64m_delegate rhandler, u64 unitmask = 0, int cswidth = 0) = 0;
|
||||
virtual void install_write_handler(offs_t addrstart, offs_t addrend, offs_t addrmask, offs_t addrmirror, offs_t addrselect, write64m_delegate whandler, u64 unitmask = 0, int cswidth = 0) = 0;
|
||||
virtual void install_readwrite_handler(offs_t addrstart, offs_t addrend, offs_t addrmask, offs_t addrmirror, offs_t addrselect, read64m_delegate rhandler, write64m_delegate whandler, u64 unitmask = 0, int cswidth = 0) = 0;
|
||||
|
||||
virtual void install_read_handler(offs_t addrstart, offs_t addrend, offs_t addrmask, offs_t addrmirror, offs_t addrselect, read8s_delegate rhandler, u64 unitmask = 0, int cswidth = 0) = 0;
|
||||
virtual void install_write_handler(offs_t addrstart, offs_t addrend, offs_t addrmask, offs_t addrmirror, offs_t addrselect, write8s_delegate whandler, u64 unitmask = 0, int cswidth = 0) = 0;
|
||||
virtual void install_readwrite_handler(offs_t addrstart, offs_t addrend, offs_t addrmask, offs_t addrmirror, offs_t addrselect, read8s_delegate rhandler, write8s_delegate whandler, u64 unitmask = 0, int cswidth = 0) = 0;
|
||||
@ -1319,6 +1496,19 @@ public:
|
||||
virtual void install_write_handler(offs_t addrstart, offs_t addrend, offs_t addrmask, offs_t addrmirror, offs_t addrselect, write64sm_delegate whandler, u64 unitmask = 0, int cswidth = 0) = 0;
|
||||
virtual void install_readwrite_handler(offs_t addrstart, offs_t addrend, offs_t addrmask, offs_t addrmirror, offs_t addrselect, read64sm_delegate rhandler, write64sm_delegate whandler, u64 unitmask = 0, int cswidth = 0) = 0;
|
||||
|
||||
virtual void install_read_handler(offs_t addrstart, offs_t addrend, offs_t addrmask, offs_t addrmirror, offs_t addrselect, read8mo_delegate rhandler, u64 unitmask = 0, int cswidth = 0) = 0;
|
||||
virtual void install_write_handler(offs_t addrstart, offs_t addrend, offs_t addrmask, offs_t addrmirror, offs_t addrselect, write8mo_delegate whandler, u64 unitmask = 0, int cswidth = 0) = 0;
|
||||
virtual void install_readwrite_handler(offs_t addrstart, offs_t addrend, offs_t addrmask, offs_t addrmirror, offs_t addrselect, read8mo_delegate rhandler, write8mo_delegate whandler, u64 unitmask = 0, int cswidth = 0) = 0;
|
||||
virtual void install_read_handler(offs_t addrstart, offs_t addrend, offs_t addrmask, offs_t addrmirror, offs_t addrselect, read16mo_delegate rhandler, u64 unitmask = 0, int cswidth = 0) = 0;
|
||||
virtual void install_write_handler(offs_t addrstart, offs_t addrend, offs_t addrmask, offs_t addrmirror, offs_t addrselect, write16mo_delegate whandler, u64 unitmask = 0, int cswidth = 0) = 0;
|
||||
virtual void install_readwrite_handler(offs_t addrstart, offs_t addrend, offs_t addrmask, offs_t addrmirror, offs_t addrselect, read16mo_delegate rhandler, write16mo_delegate whandler, u64 unitmask = 0, int cswidth = 0) = 0;
|
||||
virtual void install_read_handler(offs_t addrstart, offs_t addrend, offs_t addrmask, offs_t addrmirror, offs_t addrselect, read32mo_delegate rhandler, u64 unitmask = 0, int cswidth = 0) = 0;
|
||||
virtual void install_write_handler(offs_t addrstart, offs_t addrend, offs_t addrmask, offs_t addrmirror, offs_t addrselect, write32mo_delegate whandler, u64 unitmask = 0, int cswidth = 0) = 0;
|
||||
virtual void install_readwrite_handler(offs_t addrstart, offs_t addrend, offs_t addrmask, offs_t addrmirror, offs_t addrselect, read32mo_delegate rhandler, write32mo_delegate whandler, u64 unitmask = 0, int cswidth = 0) = 0;
|
||||
virtual void install_read_handler(offs_t addrstart, offs_t addrend, offs_t addrmask, offs_t addrmirror, offs_t addrselect, read64mo_delegate rhandler, u64 unitmask = 0, int cswidth = 0) = 0;
|
||||
virtual void install_write_handler(offs_t addrstart, offs_t addrend, offs_t addrmask, offs_t addrmirror, offs_t addrselect, write64mo_delegate whandler, u64 unitmask = 0, int cswidth = 0) = 0;
|
||||
virtual void install_readwrite_handler(offs_t addrstart, offs_t addrend, offs_t addrmask, offs_t addrmirror, offs_t addrselect, read64mo_delegate rhandler, write64mo_delegate whandler, u64 unitmask = 0, int cswidth = 0) = 0;
|
||||
|
||||
virtual void install_read_handler(offs_t addrstart, offs_t addrend, offs_t addrmask, offs_t addrmirror, offs_t addrselect, read8smo_delegate rhandler, u64 unitmask = 0, int cswidth = 0) = 0;
|
||||
virtual void install_write_handler(offs_t addrstart, offs_t addrend, offs_t addrmask, offs_t addrmirror, offs_t addrselect, write8smo_delegate whandler, u64 unitmask = 0, int cswidth = 0) = 0;
|
||||
virtual void install_readwrite_handler(offs_t addrstart, offs_t addrend, offs_t addrmask, offs_t addrmirror, offs_t addrselect, read8smo_delegate rhandler, write8smo_delegate whandler, u64 unitmask = 0, int cswidth = 0) = 0;
|
||||
|
||||
@ -15,6 +15,16 @@ template<int Width, int AddrShift, int Endian, typename READ> template<typename
|
||||
return m_delegate(*inh::m_space, ((offset - inh::m_address_base) & inh::m_address_mask) >> (Width + AddrShift), mem_mask);
|
||||
}
|
||||
|
||||
template<int Width, int AddrShift, int Endian, typename READ> template<typename R>
|
||||
std::enable_if_t<std::is_same<R, read8m_delegate>::value ||
|
||||
std::is_same<R, read16m_delegate>::value ||
|
||||
std::is_same<R, read32m_delegate>::value ||
|
||||
std::is_same<R, read64m_delegate>::value,
|
||||
typename emu::detail::handler_entry_size<Width>::uX> handler_entry_read_delegate<Width, AddrShift, Endian, READ>::read_impl(offs_t offset, uX mem_mask)
|
||||
{
|
||||
return m_delegate(*inh::m_space, ((offset - inh::m_address_base) & inh::m_address_mask) >> (Width + AddrShift));
|
||||
}
|
||||
|
||||
template<int Width, int AddrShift, int Endian, typename READ> template<typename R>
|
||||
std::enable_if_t<std::is_same<R, read8s_delegate>::value ||
|
||||
std::is_same<R, read16s_delegate>::value ||
|
||||
@ -35,6 +45,16 @@ template<int Width, int AddrShift, int Endian, typename READ> template<typename
|
||||
return m_delegate(((offset - inh::m_address_base) & inh::m_address_mask) >> (Width + AddrShift));
|
||||
}
|
||||
|
||||
template<int Width, int AddrShift, int Endian, typename READ> template<typename R>
|
||||
std::enable_if_t<std::is_same<R, read8mo_delegate>::value ||
|
||||
std::is_same<R, read16mo_delegate>::value ||
|
||||
std::is_same<R, read32mo_delegate>::value ||
|
||||
std::is_same<R, read64mo_delegate>::value,
|
||||
typename emu::detail::handler_entry_size<Width>::uX> handler_entry_read_delegate<Width, AddrShift, Endian, READ>::read_impl(offs_t offset, uX mem_mask)
|
||||
{
|
||||
return m_delegate(*inh::m_space);
|
||||
}
|
||||
|
||||
template<int Width, int AddrShift, int Endian, typename READ> template<typename R>
|
||||
std::enable_if_t<std::is_same<R, read8smo_delegate>::value ||
|
||||
std::is_same<R, read16smo_delegate>::value ||
|
||||
@ -65,6 +85,16 @@ template<int Width, int AddrShift, int Endian, typename WRITE> template<typename
|
||||
m_delegate(*inh::m_space, ((offset - inh::m_address_base) & inh::m_address_mask) >> (Width + AddrShift), data, mem_mask);
|
||||
}
|
||||
|
||||
template<int Width, int AddrShift, int Endian, typename WRITE> template<typename W>
|
||||
std::enable_if_t<std::is_same<W, write8m_delegate>::value ||
|
||||
std::is_same<W, write16m_delegate>::value ||
|
||||
std::is_same<W, write32m_delegate>::value ||
|
||||
std::is_same<W, write64m_delegate>::value,
|
||||
void> handler_entry_write_delegate<Width, AddrShift, Endian, WRITE>::write_impl(offs_t offset, uX data, uX mem_mask)
|
||||
{
|
||||
m_delegate(*inh::m_space, ((offset - inh::m_address_base) & inh::m_address_mask) >> (Width + AddrShift), data);
|
||||
}
|
||||
|
||||
template<int Width, int AddrShift, int Endian, typename WRITE> template<typename W>
|
||||
std::enable_if_t<std::is_same<W, write8s_delegate>::value ||
|
||||
std::is_same<W, write16s_delegate>::value ||
|
||||
@ -85,6 +115,16 @@ template<int Width, int AddrShift, int Endian, typename WRITE> template<typename
|
||||
m_delegate(((offset - inh::m_address_base) & inh::m_address_mask) >> (Width + AddrShift), data);
|
||||
}
|
||||
|
||||
template<int Width, int AddrShift, int Endian, typename WRITE> template<typename W>
|
||||
std::enable_if_t<std::is_same<W, write8mo_delegate>::value ||
|
||||
std::is_same<W, write16mo_delegate>::value ||
|
||||
std::is_same<W, write32mo_delegate>::value ||
|
||||
std::is_same<W, write64mo_delegate>::value,
|
||||
void> handler_entry_write_delegate<Width, AddrShift, Endian, WRITE>::write_impl(offs_t offset, uX data, uX mem_mask)
|
||||
{
|
||||
m_delegate(*inh::m_space, data);
|
||||
}
|
||||
|
||||
template<int Width, int AddrShift, int Endian, typename WRITE> template<typename W>
|
||||
std::enable_if_t<std::is_same<W, write8smo_delegate>::value ||
|
||||
std::is_same<W, write16smo_delegate>::value ||
|
||||
@ -153,6 +193,29 @@ template class handler_entry_read_delegate<3, -2, ENDIANNESS_BIG, read64_dele
|
||||
template class handler_entry_read_delegate<3, -3, ENDIANNESS_LITTLE, read64_delegate>;
|
||||
template class handler_entry_read_delegate<3, -3, ENDIANNESS_BIG, read64_delegate>;
|
||||
|
||||
template class handler_entry_read_delegate<0, 0, ENDIANNESS_LITTLE, read8m_delegate>;
|
||||
template class handler_entry_read_delegate<0, 0, ENDIANNESS_BIG, read8m_delegate>;
|
||||
template class handler_entry_read_delegate<1, 3, ENDIANNESS_LITTLE, read16m_delegate>;
|
||||
template class handler_entry_read_delegate<1, 3, ENDIANNESS_BIG, read16m_delegate>;
|
||||
template class handler_entry_read_delegate<1, 0, ENDIANNESS_LITTLE, read16m_delegate>;
|
||||
template class handler_entry_read_delegate<1, 0, ENDIANNESS_BIG, read16m_delegate>;
|
||||
template class handler_entry_read_delegate<1, -1, ENDIANNESS_LITTLE, read16m_delegate>;
|
||||
template class handler_entry_read_delegate<1, -1, ENDIANNESS_BIG, read16m_delegate>;
|
||||
template class handler_entry_read_delegate<2, 0, ENDIANNESS_LITTLE, read32m_delegate>;
|
||||
template class handler_entry_read_delegate<2, 0, ENDIANNESS_BIG, read32m_delegate>;
|
||||
template class handler_entry_read_delegate<2, -1, ENDIANNESS_LITTLE, read32m_delegate>;
|
||||
template class handler_entry_read_delegate<2, -1, ENDIANNESS_BIG, read32m_delegate>;
|
||||
template class handler_entry_read_delegate<2, -2, ENDIANNESS_LITTLE, read32m_delegate>;
|
||||
template class handler_entry_read_delegate<2, -2, ENDIANNESS_BIG, read32m_delegate>;
|
||||
template class handler_entry_read_delegate<3, 0, ENDIANNESS_LITTLE, read64m_delegate>;
|
||||
template class handler_entry_read_delegate<3, 0, ENDIANNESS_BIG, read64m_delegate>;
|
||||
template class handler_entry_read_delegate<3, -1, ENDIANNESS_LITTLE, read64m_delegate>;
|
||||
template class handler_entry_read_delegate<3, -1, ENDIANNESS_BIG, read64m_delegate>;
|
||||
template class handler_entry_read_delegate<3, -2, ENDIANNESS_LITTLE, read64m_delegate>;
|
||||
template class handler_entry_read_delegate<3, -2, ENDIANNESS_BIG, read64m_delegate>;
|
||||
template class handler_entry_read_delegate<3, -3, ENDIANNESS_LITTLE, read64m_delegate>;
|
||||
template class handler_entry_read_delegate<3, -3, ENDIANNESS_BIG, read64m_delegate>;
|
||||
|
||||
template class handler_entry_read_delegate<0, 0, ENDIANNESS_LITTLE, read8s_delegate>;
|
||||
template class handler_entry_read_delegate<0, 0, ENDIANNESS_BIG, read8s_delegate>;
|
||||
template class handler_entry_read_delegate<1, 3, ENDIANNESS_LITTLE, read16s_delegate>;
|
||||
@ -199,6 +262,29 @@ template class handler_entry_read_delegate<3, -2, ENDIANNESS_BIG, read64sm_de
|
||||
template class handler_entry_read_delegate<3, -3, ENDIANNESS_LITTLE, read64sm_delegate>;
|
||||
template class handler_entry_read_delegate<3, -3, ENDIANNESS_BIG, read64sm_delegate>;
|
||||
|
||||
template class handler_entry_read_delegate<0, 0, ENDIANNESS_LITTLE, read8mo_delegate>;
|
||||
template class handler_entry_read_delegate<0, 0, ENDIANNESS_BIG, read8mo_delegate>;
|
||||
template class handler_entry_read_delegate<1, 3, ENDIANNESS_LITTLE, read16mo_delegate>;
|
||||
template class handler_entry_read_delegate<1, 3, ENDIANNESS_BIG, read16mo_delegate>;
|
||||
template class handler_entry_read_delegate<1, 0, ENDIANNESS_LITTLE, read16mo_delegate>;
|
||||
template class handler_entry_read_delegate<1, 0, ENDIANNESS_BIG, read16mo_delegate>;
|
||||
template class handler_entry_read_delegate<1, -1, ENDIANNESS_LITTLE, read16mo_delegate>;
|
||||
template class handler_entry_read_delegate<1, -1, ENDIANNESS_BIG, read16mo_delegate>;
|
||||
template class handler_entry_read_delegate<2, 0, ENDIANNESS_LITTLE, read32mo_delegate>;
|
||||
template class handler_entry_read_delegate<2, 0, ENDIANNESS_BIG, read32mo_delegate>;
|
||||
template class handler_entry_read_delegate<2, -1, ENDIANNESS_LITTLE, read32mo_delegate>;
|
||||
template class handler_entry_read_delegate<2, -1, ENDIANNESS_BIG, read32mo_delegate>;
|
||||
template class handler_entry_read_delegate<2, -2, ENDIANNESS_LITTLE, read32mo_delegate>;
|
||||
template class handler_entry_read_delegate<2, -2, ENDIANNESS_BIG, read32mo_delegate>;
|
||||
template class handler_entry_read_delegate<3, 0, ENDIANNESS_LITTLE, read64mo_delegate>;
|
||||
template class handler_entry_read_delegate<3, 0, ENDIANNESS_BIG, read64mo_delegate>;
|
||||
template class handler_entry_read_delegate<3, -1, ENDIANNESS_LITTLE, read64mo_delegate>;
|
||||
template class handler_entry_read_delegate<3, -1, ENDIANNESS_BIG, read64mo_delegate>;
|
||||
template class handler_entry_read_delegate<3, -2, ENDIANNESS_LITTLE, read64mo_delegate>;
|
||||
template class handler_entry_read_delegate<3, -2, ENDIANNESS_BIG, read64mo_delegate>;
|
||||
template class handler_entry_read_delegate<3, -3, ENDIANNESS_LITTLE, read64mo_delegate>;
|
||||
template class handler_entry_read_delegate<3, -3, ENDIANNESS_BIG, read64mo_delegate>;
|
||||
|
||||
template class handler_entry_read_delegate<0, 0, ENDIANNESS_LITTLE, read8smo_delegate>;
|
||||
template class handler_entry_read_delegate<0, 0, ENDIANNESS_BIG, read8smo_delegate>;
|
||||
template class handler_entry_read_delegate<1, 3, ENDIANNESS_LITTLE, read16smo_delegate>;
|
||||
@ -245,6 +331,29 @@ template class handler_entry_write_delegate<3, -2, ENDIANNESS_BIG, write64_de
|
||||
template class handler_entry_write_delegate<3, -3, ENDIANNESS_LITTLE, write64_delegate>;
|
||||
template class handler_entry_write_delegate<3, -3, ENDIANNESS_BIG, write64_delegate>;
|
||||
|
||||
template class handler_entry_write_delegate<0, 0, ENDIANNESS_LITTLE, write8m_delegate>;
|
||||
template class handler_entry_write_delegate<0, 0, ENDIANNESS_BIG, write8m_delegate>;
|
||||
template class handler_entry_write_delegate<1, 3, ENDIANNESS_LITTLE, write16m_delegate>;
|
||||
template class handler_entry_write_delegate<1, 3, ENDIANNESS_BIG, write16m_delegate>;
|
||||
template class handler_entry_write_delegate<1, 0, ENDIANNESS_LITTLE, write16m_delegate>;
|
||||
template class handler_entry_write_delegate<1, 0, ENDIANNESS_BIG, write16m_delegate>;
|
||||
template class handler_entry_write_delegate<1, -1, ENDIANNESS_LITTLE, write16m_delegate>;
|
||||
template class handler_entry_write_delegate<1, -1, ENDIANNESS_BIG, write16m_delegate>;
|
||||
template class handler_entry_write_delegate<2, 0, ENDIANNESS_LITTLE, write32m_delegate>;
|
||||
template class handler_entry_write_delegate<2, 0, ENDIANNESS_BIG, write32m_delegate>;
|
||||
template class handler_entry_write_delegate<2, -1, ENDIANNESS_LITTLE, write32m_delegate>;
|
||||
template class handler_entry_write_delegate<2, -1, ENDIANNESS_BIG, write32m_delegate>;
|
||||
template class handler_entry_write_delegate<2, -2, ENDIANNESS_LITTLE, write32m_delegate>;
|
||||
template class handler_entry_write_delegate<2, -2, ENDIANNESS_BIG, write32m_delegate>;
|
||||
template class handler_entry_write_delegate<3, 0, ENDIANNESS_LITTLE, write64m_delegate>;
|
||||
template class handler_entry_write_delegate<3, 0, ENDIANNESS_BIG, write64m_delegate>;
|
||||
template class handler_entry_write_delegate<3, -1, ENDIANNESS_LITTLE, write64m_delegate>;
|
||||
template class handler_entry_write_delegate<3, -1, ENDIANNESS_BIG, write64m_delegate>;
|
||||
template class handler_entry_write_delegate<3, -2, ENDIANNESS_LITTLE, write64m_delegate>;
|
||||
template class handler_entry_write_delegate<3, -2, ENDIANNESS_BIG, write64m_delegate>;
|
||||
template class handler_entry_write_delegate<3, -3, ENDIANNESS_LITTLE, write64m_delegate>;
|
||||
template class handler_entry_write_delegate<3, -3, ENDIANNESS_BIG, write64m_delegate>;
|
||||
|
||||
template class handler_entry_write_delegate<0, 0, ENDIANNESS_LITTLE, write8s_delegate>;
|
||||
template class handler_entry_write_delegate<0, 0, ENDIANNESS_BIG, write8s_delegate>;
|
||||
template class handler_entry_write_delegate<1, 3, ENDIANNESS_LITTLE, write16s_delegate>;
|
||||
@ -291,6 +400,29 @@ template class handler_entry_write_delegate<3, -2, ENDIANNESS_BIG, write64sm_
|
||||
template class handler_entry_write_delegate<3, -3, ENDIANNESS_LITTLE, write64sm_delegate>;
|
||||
template class handler_entry_write_delegate<3, -3, ENDIANNESS_BIG, write64sm_delegate>;
|
||||
|
||||
template class handler_entry_write_delegate<0, 0, ENDIANNESS_LITTLE, write8mo_delegate>;
|
||||
template class handler_entry_write_delegate<0, 0, ENDIANNESS_BIG, write8mo_delegate>;
|
||||
template class handler_entry_write_delegate<1, 3, ENDIANNESS_LITTLE, write16mo_delegate>;
|
||||
template class handler_entry_write_delegate<1, 3, ENDIANNESS_BIG, write16mo_delegate>;
|
||||
template class handler_entry_write_delegate<1, 0, ENDIANNESS_LITTLE, write16mo_delegate>;
|
||||
template class handler_entry_write_delegate<1, 0, ENDIANNESS_BIG, write16mo_delegate>;
|
||||
template class handler_entry_write_delegate<1, -1, ENDIANNESS_LITTLE, write16mo_delegate>;
|
||||
template class handler_entry_write_delegate<1, -1, ENDIANNESS_BIG, write16mo_delegate>;
|
||||
template class handler_entry_write_delegate<2, 0, ENDIANNESS_LITTLE, write32mo_delegate>;
|
||||
template class handler_entry_write_delegate<2, 0, ENDIANNESS_BIG, write32mo_delegate>;
|
||||
template class handler_entry_write_delegate<2, -1, ENDIANNESS_LITTLE, write32mo_delegate>;
|
||||
template class handler_entry_write_delegate<2, -1, ENDIANNESS_BIG, write32mo_delegate>;
|
||||
template class handler_entry_write_delegate<2, -2, ENDIANNESS_LITTLE, write32mo_delegate>;
|
||||
template class handler_entry_write_delegate<2, -2, ENDIANNESS_BIG, write32mo_delegate>;
|
||||
template class handler_entry_write_delegate<3, 0, ENDIANNESS_LITTLE, write64mo_delegate>;
|
||||
template class handler_entry_write_delegate<3, 0, ENDIANNESS_BIG, write64mo_delegate>;
|
||||
template class handler_entry_write_delegate<3, -1, ENDIANNESS_LITTLE, write64mo_delegate>;
|
||||
template class handler_entry_write_delegate<3, -1, ENDIANNESS_BIG, write64mo_delegate>;
|
||||
template class handler_entry_write_delegate<3, -2, ENDIANNESS_LITTLE, write64mo_delegate>;
|
||||
template class handler_entry_write_delegate<3, -2, ENDIANNESS_BIG, write64mo_delegate>;
|
||||
template class handler_entry_write_delegate<3, -3, ENDIANNESS_LITTLE, write64mo_delegate>;
|
||||
template class handler_entry_write_delegate<3, -3, ENDIANNESS_BIG, write64mo_delegate>;
|
||||
|
||||
template class handler_entry_write_delegate<0, 0, ENDIANNESS_LITTLE, write8smo_delegate>;
|
||||
template class handler_entry_write_delegate<0, 0, ENDIANNESS_BIG, write8smo_delegate>;
|
||||
template class handler_entry_write_delegate<1, 3, ENDIANNESS_LITTLE, write16smo_delegate>;
|
||||
|
||||
@ -28,6 +28,13 @@ private:
|
||||
std::is_same<R, read64_delegate>::value,
|
||||
uX> read_impl(offs_t offset, uX mem_mask);
|
||||
|
||||
template<typename R>
|
||||
std::enable_if_t<std::is_same<R, read8m_delegate>::value ||
|
||||
std::is_same<R, read16m_delegate>::value ||
|
||||
std::is_same<R, read32m_delegate>::value ||
|
||||
std::is_same<R, read64m_delegate>::value,
|
||||
uX> read_impl(offs_t offset, uX mem_mask);
|
||||
|
||||
template<typename R>
|
||||
std::enable_if_t<std::is_same<R, read8s_delegate>::value ||
|
||||
std::is_same<R, read16s_delegate>::value ||
|
||||
@ -42,6 +49,13 @@ private:
|
||||
std::is_same<R, read64sm_delegate>::value,
|
||||
uX> read_impl(offs_t offset, uX mem_mask);
|
||||
|
||||
template<typename R>
|
||||
std::enable_if_t<std::is_same<R, read8mo_delegate>::value ||
|
||||
std::is_same<R, read16mo_delegate>::value ||
|
||||
std::is_same<R, read32mo_delegate>::value ||
|
||||
std::is_same<R, read64mo_delegate>::value,
|
||||
uX> read_impl(offs_t offset, uX mem_mask);
|
||||
|
||||
template<typename R>
|
||||
std::enable_if_t<std::is_same<R, read8smo_delegate>::value ||
|
||||
std::is_same<R, read16smo_delegate>::value ||
|
||||
@ -73,6 +87,13 @@ private:
|
||||
std::is_same<W, write64_delegate>::value,
|
||||
void> write_impl(offs_t offset, uX data, uX mem_mask);
|
||||
|
||||
template<typename W>
|
||||
std::enable_if_t<std::is_same<W, write8m_delegate>::value ||
|
||||
std::is_same<W, write16m_delegate>::value ||
|
||||
std::is_same<W, write32m_delegate>::value ||
|
||||
std::is_same<W, write64m_delegate>::value,
|
||||
void> write_impl(offs_t offset, uX data, uX mem_mask);
|
||||
|
||||
template<typename W>
|
||||
std::enable_if_t<std::is_same<W, write8s_delegate>::value ||
|
||||
std::is_same<W, write16s_delegate>::value ||
|
||||
@ -87,6 +108,13 @@ private:
|
||||
std::is_same<W, write64sm_delegate>::value,
|
||||
void> write_impl(offs_t offset, uX data, uX mem_mask);
|
||||
|
||||
template<typename W>
|
||||
std::enable_if_t<std::is_same<W, write8mo_delegate>::value ||
|
||||
std::is_same<W, write16mo_delegate>::value ||
|
||||
std::is_same<W, write32mo_delegate>::value ||
|
||||
std::is_same<W, write64mo_delegate>::value,
|
||||
void> write_impl(offs_t offset, uX data, uX mem_mask);
|
||||
|
||||
template<typename W>
|
||||
std::enable_if_t<std::is_same<W, write8smo_delegate>::value ||
|
||||
std::is_same<W, write16smo_delegate>::value ||
|
||||
|
||||
@ -201,9 +201,11 @@ namespace sol
|
||||
case AMH_UNMAP:
|
||||
typestr = "unmap";
|
||||
break;
|
||||
case AMH_DEVICE_DELEGATE_F:
|
||||
case AMH_DEVICE_DELEGATE:
|
||||
case AMH_DEVICE_DELEGATE_M:
|
||||
case AMH_DEVICE_DELEGATE_S:
|
||||
case AMH_DEVICE_DELEGATE_SM:
|
||||
case AMH_DEVICE_DELEGATE_MO:
|
||||
case AMH_DEVICE_DELEGATE_SMO:
|
||||
typestr = "delegate";
|
||||
break;
|
||||
|
||||
Loading…
Reference in New Issue
Block a user