summaryrefslogtreecommitdiffstatshomepage
path: root/src/emu/addrmap.h
diff options
context:
space:
mode:
Diffstat (limited to 'src/emu/addrmap.h')
-rw-r--r--src/emu/addrmap.h94
1 files changed, 72 insertions, 22 deletions
diff --git a/src/emu/addrmap.h b/src/emu/addrmap.h
index 90dd8898533..56d50ef4f7e 100644
--- a/src/emu/addrmap.h
+++ b/src/emu/addrmap.h
@@ -32,7 +32,10 @@ enum map_handler_type
AMH_ROM,
AMH_NOP,
AMH_UNMAP,
- AMH_DEVICE_DELEGATE,
+ AMH_DEVICE_DELEGATE_F,
+ AMH_DEVICE_DELEGATE_S,
+ AMH_DEVICE_DELEGATE_SM,
+ AMH_DEVICE_DELEGATE_SMO,
AMH_PORT,
AMH_BANK,
AMH_DEVICE_SUBMAP
@@ -180,7 +183,7 @@ public:
template <typename T, typename RetR, typename... ParamsR, typename U, typename RetW, typename... ParamsW>
address_map_entry &rw(RetR (T::*read)(ParamsR...), const char *read_name, RetW (U::*write)(ParamsW...), const char *write_name)
- { return rw(emu::detail::make_delegate(read, read_name, m_devbase.tag(), make_pointer<T>(m_devbase)), emu::detail::make_delegate(write, write_name, m_devbase.tag(), make_pointer<U>(m_devbase))); }
+ { return r(emu::detail::make_delegate(read, read_name, m_devbase.tag(), make_pointer<T>(m_devbase))).w(emu::detail::make_delegate(write, write_name, m_devbase.tag(), make_pointer<U>(m_devbase))); }
template <typename T, typename Ret, typename... Params>
address_map_entry &m(Ret (T::*map)(Params...), const char *map_name)
@@ -198,7 +201,7 @@ public:
template <typename T, typename RetR, typename... ParamsR, typename U, typename RetW, typename... ParamsW>
address_map_entry &rw(const char *tag, RetR (T::*read)(ParamsR...), const char *read_name, RetW (U::*write)(ParamsW...), const char *write_name)
- { return rw(emu::detail::make_delegate(read, read_name, tag, nullptr), emu::detail::make_delegate(write, write_name, tag, nullptr)); }
+ { return r(emu::detail::make_delegate(read, read_name, tag, nullptr)).w(emu::detail::make_delegate(write, write_name, tag, nullptr)); }
template <typename T, typename Ret, typename... Params>
address_map_entry &m(const char *tag, Ret (T::*map)(Params...), const char *map_name)
@@ -216,7 +219,7 @@ public:
template <typename T, typename U, typename RetR, typename... ParamsR, typename V, typename RetW, typename... ParamsW>
address_map_entry &rw(T &obj, RetR (U::*read)(ParamsR...), const char *read_name, RetW (V::*write)(ParamsW...), const char *write_name)
- { return rw(emu::detail::make_delegate(read, read_name, get_tag(obj), make_pointer<U>(obj)), emu::detail::make_delegate(write, write_name, get_tag(obj), make_pointer<V>(obj))); }
+ { return r(emu::detail::make_delegate(read, read_name, get_tag(obj), make_pointer<U>(obj))).w(emu::detail::make_delegate(write, write_name, get_tag(obj), make_pointer<V>(obj))); }
template <typename T, typename U, typename Ret, typename... Params>
address_map_entry &m(T &obj, Ret (U::*map)(Params...), const char *map_name)
@@ -242,11 +245,11 @@ public:
template <typename T, bool Reqd, typename U, typename RetR, typename... ParamsR, typename V, typename RetW, typename... ParamsW>
address_map_entry &rw(device_finder<T, Reqd> &finder, RetR (U::*read)(ParamsR...), const char *read_name, RetW (V::*write)(ParamsW...), const char *write_name)
- { const std::pair<device_t &, const char *> target(finder.finder_target()); device_t &device(*target.first.subdevice(target.second)); return rw(emu::detail::make_delegate(read, read_name, device.tag(), make_pointer<U>(device)), emu::detail::make_delegate(write, write_name, device.tag(), make_pointer<V>(device))); }
+ { const std::pair<device_t &, const char *> target(finder.finder_target()); device_t &device(*target.first.subdevice(target.second)); return r(emu::detail::make_delegate(read, read_name, device.tag(), make_pointer<U>(device))).w(emu::detail::make_delegate(write, write_name, device.tag(), make_pointer<V>(device))); }
template <typename T, bool Reqd, typename U, typename RetR, typename... ParamsR, typename V, typename RetW, typename... ParamsW>
address_map_entry &rw(const device_finder<T, Reqd> &finder, RetR (U::*read)(ParamsR...), const char *read_name, RetW (V::*write)(ParamsW...), const char *write_name)
- { const std::pair<device_t &, const char *> target(finder.finder_target()); device_t &device(*target.first.subdevice(target.second)); return rw(emu::detail::make_delegate(read, read_name, device.tag(), make_pointer<U>(device)), emu::detail::make_delegate(write, write_name, device.tag(), make_pointer<V>(device))); }
+ { const std::pair<device_t &, const char *> target(finder.finder_target()); device_t &device(*target.first.subdevice(target.second)); return r(emu::detail::make_delegate(read, read_name, device.tag(), make_pointer<U>(device))).w(emu::detail::make_delegate(write, write_name, device.tag(), make_pointer<V>(device))); }
template <typename T, bool Reqd, typename U, typename Ret, typename... Params>
address_map_entry &m(device_finder<T, Reqd> &finder, Ret (U::*map)(Params...), const char *map_name)
@@ -259,51 +262,51 @@ public:
// lambda -> delegate converter
template<typename _lr> address_map_entry &lr8(const char *name, _lr &&read) {
- return r(read8_delegate(read, name));
+ return r(emu::detail::make_lr8_delegate(read, name));
}
template<typename _lr> address_map_entry &lr16(const char *name, _lr &&read) {
- return r(read16_delegate(read, name));
+ return r(emu::detail::make_lr16_delegate(read, name));
}
template<typename _lr> address_map_entry &lr32(const char *name, _lr &&read) {
- return r(read32_delegate(read, name));
+ return r(emu::detail::make_lr32_delegate(read, name));
}
template<typename _lr> address_map_entry &lr64(const char *name, _lr &&read) {
- return r(read64_delegate(read, name));
+ return r(emu::detail::make_lr64_delegate(read, name));
}
template<typename _lw> address_map_entry &lw8(const char *name, _lw &&write) {
- return w(write8_delegate(write, name));
+ return w(emu::detail::make_lw8_delegate(write, name));
}
template<typename _lw> address_map_entry &lw16(const char *name, _lw &&write) {
- return w(write16_delegate(write, name));
+ return w(emu::detail::make_lw16_delegate(write, name));
}
template<typename _lw> address_map_entry &lw32(const char *name, _lw &&write) {
- return w(write32_delegate(write, name));
+ return w(emu::detail::make_lw32_delegate(write, name));
}
template<typename _lw> address_map_entry &lw64(const char *name, _lw &&write) {
- return w(write64_delegate(write, name));
+ return w(emu::detail::make_lw64_delegate(write, name));
}
template<typename _lr, typename _lw> address_map_entry &lrw8(const char *name, _lr &&read, _lw &&write) {
- return rw(read8_delegate(read, name), write8_delegate(write, name));
+ return r(emu::detail::make_lr8_delegate(read, name)).w(emu::detail::make_lw8_delegate(write, name));
}
template<typename _lr, typename _lw> address_map_entry &lrw16(const char *name, _lr &&read, _lw &&write) {
- return rw(read16_delegate(read, name), write16_delegate(write, name));
+ return r(emu::detail::make_lr16_delegate(read, name)).w(emu::detail::make_lw16_delegate(write, name));
}
template<typename _lr, typename _lw> address_map_entry &lrw32(const char *name, _lr &&read, _lw &&write) {
- return rw(read32_delegate(read, name), write32_delegate(write, name));
+ return r(emu::detail::make_lr32_delegate(read, name)).w(emu::detail::make_lw32_delegate(write, name));
}
template<typename _lr, typename _lw> address_map_entry &lrw64(const char *name, _lr &&read, _lw &&write) {
- return rw(read64_delegate(read, name), write64_delegate(write, name));
+ return r(emu::detail::make_lr64_delegate(read, name)).w(emu::detail::make_lw64_delegate(write, name));
}
// public state
@@ -335,6 +338,33 @@ public:
write32_delegate m_wproto32; // 32-bit write proto-delegate
write64_delegate m_wproto64; // 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
+ read64s_delegate m_rproto64s; // 64-bit read proto-delegate
+ write8s_delegate m_wproto8s; // 8-bit write proto-delegate
+ write16s_delegate m_wproto16s; // 16-bit write proto-delegate
+ write32s_delegate m_wproto32s; // 32-bit write proto-delegate
+ write64s_delegate m_wproto64s; // 64-bit write proto-delegate
+
+ read8sm_delegate m_rproto8sm; // 8-bit read proto-delegate
+ read16sm_delegate m_rproto16sm; // 16-bit read proto-delegate
+ read32sm_delegate m_rproto32sm; // 32-bit read proto-delegate
+ read64sm_delegate m_rproto64sm; // 64-bit read proto-delegate
+ write8sm_delegate m_wproto8sm; // 8-bit write proto-delegate
+ write16sm_delegate m_wproto16sm; // 16-bit write proto-delegate
+ write32sm_delegate m_wproto32sm; // 32-bit write proto-delegate
+ write64sm_delegate m_wproto64sm; // 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
+ read64smo_delegate m_rproto64smo; // 64-bit read proto-delegate
+ write8smo_delegate m_wproto8smo; // 8-bit write proto-delegate
+ write16smo_delegate m_wproto16smo; // 16-bit write proto-delegate
+ write32smo_delegate m_wproto32smo; // 32-bit write proto-delegate
+ write64smo_delegate m_wproto64smo; // 64-bit write proto-delegate
+
device_t *m_submap_device;
address_map_constructor m_submap_delegate;
@@ -344,22 +374,42 @@ public:
// handler setters for 8-bit delegates
address_map_entry &r(read8_delegate func);
address_map_entry &w(write8_delegate func);
- address_map_entry &rw(read8_delegate rfunc, write8_delegate wfunc);
+ 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(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 &rw(read16_delegate rfunc, write16_delegate wfunc);
+ 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(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 &rw(read32_delegate rfunc, write32_delegate wfunc);
+ 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(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 &rw(read64_delegate rfunc, write64_delegate wfunc);
+ 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(read64smo_delegate func);
+ address_map_entry &w(write64smo_delegate func);
private:
// helper functions