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.h303
1 files changed, 148 insertions, 155 deletions
diff --git a/src/emu/addrmap.h b/src/emu/addrmap.h
index 9673aa929ec..302b21827cf 100644
--- a/src/emu/addrmap.h
+++ b/src/emu/addrmap.h
@@ -17,6 +17,7 @@
#ifndef MAME_EMU_ADDRMAP_H
#define MAME_EMU_ADDRMAP_H
+#include <type_traits>
//**************************************************************************
@@ -64,6 +65,74 @@ class address_map_entry
{
friend class address_map;
+ template <typename T, typename Ret, typename... Params>
+ struct is_read8_method { static constexpr bool value = std::is_constructible<read8_delegate, Ret (T::*)(Params...), const char *, const char *, T *>::value; };
+ template <typename T, typename Ret, typename... Params>
+ struct is_read16_method { static constexpr bool value = std::is_constructible<read16_delegate, Ret (T::*)(Params...), const char *, const char *, T *>::value; };
+ template <typename T, typename Ret, typename... Params>
+ struct is_read32_method { static constexpr bool value = std::is_constructible<read32_delegate, Ret (T::*)(Params...), const char *, const char *, T *>::value; };
+ template <typename T, typename Ret, typename... Params>
+ struct is_read64_method { static constexpr bool value = std::is_constructible<read64_delegate, Ret (T::*)(Params...), const char *, const char *, T *>::value; };
+
+ template <typename T, typename Ret, typename... Params>
+ struct is_write8_method { static constexpr bool value = std::is_constructible<write8_delegate, Ret (T::*)(Params...), const char *, const char *, T *>::value; };
+ template <typename T, typename Ret, typename... Params>
+ struct is_write16_method { static constexpr bool value = std::is_constructible<write16_delegate, Ret (T::*)(Params...), const char *, const char *, T *>::value; };
+ template <typename T, typename Ret, typename... Params>
+ struct is_write32_method { static constexpr bool value = std::is_constructible<write32_delegate, Ret (T::*)(Params...), const char *, const char *, T *>::value; };
+ template <typename T, typename Ret, typename... Params>
+ struct is_write64_method { static constexpr bool value = std::is_constructible<write64_delegate, Ret (T::*)(Params...), const char *, const char *, T *>::value; };
+
+ template <typename T, typename Ret, typename... Params>
+ struct is_addrmap_method { static constexpr bool value = std::is_constructible<address_map_constructor, Ret (T::*)(Params...), const char *, T*>::value; };
+
+ template <typename T, typename Ret, typename... Params>
+ struct is_setoffset_method { static constexpr bool value = std::is_constructible<setoffset_delegate, Ret (T::*)(Params...), const char *, const char *, T *>::value; };
+
+ template <typename T, typename Ret, typename... Params>
+ static std::enable_if_t<is_read8_method<T, Ret, Params...>::value, read8_delegate> make_delegate(Ret (T::*func)(Params...), const char *name, const char *tag, T *obj)
+ { return read8_delegate(func, name, tag, obj); }
+ template <typename T, typename Ret, typename... Params>
+ static std::enable_if_t<is_read16_method<T, Ret, Params...>::value, read16_delegate> make_delegate(Ret (T::*func)(Params...), const char *name, const char *tag, T *obj)
+ { return read16_delegate(func, name, tag, obj); }
+ template <typename T, typename Ret, typename... Params>
+ static std::enable_if_t<is_read32_method<T, Ret, Params...>::value, read32_delegate> make_delegate(Ret (T::*func)(Params...), const char *name, const char *tag, T *obj)
+ { return read32_delegate(func, name, tag, obj); }
+ template <typename T, typename Ret, typename... Params>
+ static std::enable_if_t<is_read64_method<T, Ret, Params...>::value, read64_delegate> make_delegate(Ret (T::*func)(Params...), const char *name, const char *tag, T *obj)
+ { return read64_delegate(func, name, tag, obj); }
+
+ template <typename T, typename Ret, typename... Params>
+ static std::enable_if_t<is_write8_method<T, Ret, Params...>::value, write8_delegate> make_delegate(Ret (T::*func)(Params...), const char *name, const char *tag, T *obj)
+ { return write8_delegate(func, name, tag, obj); }
+ template <typename T, typename Ret, typename... Params>
+ static std::enable_if_t<is_write16_method<T, Ret, Params...>::value, write16_delegate> make_delegate(Ret (T::*func)(Params...), const char *name, const char *tag, T *obj)
+ { return write16_delegate(func, name, tag, obj); }
+ template <typename T, typename Ret, typename... Params>
+ static std::enable_if_t<is_write32_method<T, Ret, Params...>::value, write32_delegate> make_delegate(Ret (T::*func)(Params...), const char *name, const char *tag, T *obj)
+ { return write32_delegate(func, name, tag, obj); }
+ template <typename T, typename Ret, typename... Params>
+ static std::enable_if_t<is_write64_method<T, Ret, Params...>::value, write64_delegate> make_delegate(Ret (T::*func)(Params...), const char *name, const char *tag, T *obj)
+ { return write64_delegate(func, name, tag, obj); }
+
+ template <typename T, typename Ret, typename... Params>
+ static std::enable_if_t<is_addrmap_method<T, Ret, Params...>::value, address_map_constructor> make_delegate(Ret (T::*func)(Params...), const char *name, T *obj)
+ { return address_map_constructor(func, name, obj); }
+
+ template <typename T, typename Ret, typename... Params>
+ static std::enable_if_t<is_setoffset_method<T, Ret, Params...>::value, setoffset_delegate> make_delegate(Ret (T::*func)(Params...), const char *name, const char *tag, T *obj)
+ { return setoffset_delegate(func, name, tag, obj); }
+
+ template <typename T, typename U>
+ static std::enable_if_t<std::is_convertible<std::add_pointer_t<U>, std::add_pointer_t<T> >::value, T *> make_pointer(U &obj)
+ { return &downcast<T &>(obj); }
+ template <typename T, typename U>
+ static std::enable_if_t<!std::is_convertible<std::add_pointer_t<U>, std::add_pointer_t<T> >::value, T *> make_pointer(U &obj)
+ { return &dynamic_cast<T &>(obj); }
+
+ template <typename T> static std::enable_if_t<emu::detail::is_device_implementation<T>::value, const char *> get_tag(T &obj) { return obj.tag(); }
+ template <typename T> static std::enable_if_t<emu::detail::is_device_interface<T>::value, const char *> get_tag(T &obj) { return obj.device().tag(); }
+
public:
// construction/destruction
address_map_entry(device_t &device, address_map &map, offs_t start, offs_t end);
@@ -154,188 +223,112 @@ public:
address_map_entry &m(device_t *device, address_map_constructor func);
- // device tag -> delegate converter
- template<typename _devr> address_map_entry &r(const char *tag, u8 (_devr::*read)(address_space &, offs_t, u8), const char *read_name) {
- return r(read8_delegate(read, read_name, tag, (_devr *)nullptr));
- }
-
- template<typename _devr> address_map_entry &r(const char *tag, u16 (_devr::*read)(address_space &, offs_t, u16), const char *read_name) {
- return r(read16_delegate(read, read_name, tag, (_devr *)nullptr));
- }
-
- template<typename _devr> address_map_entry &r(const char *tag, u32 (_devr::*read)(address_space &, offs_t, u32), const char *read_name) {
- return r(read32_delegate(read, read_name, tag, (_devr *)nullptr));
- }
-
- template<typename _devr> address_map_entry &r(const char *tag, u64 (_devr::*read)(address_space &, offs_t, u64), const char *read_name) {
- return r(read64_delegate(read, read_name, tag, (_devr *)nullptr));
- }
-
- template<typename _devw> address_map_entry &w(const char *tag, void (_devw::*write)(address_space &, offs_t, u8, u8), const char *write_name) {
- return w(write8_delegate(write, write_name, tag, (_devw *)nullptr));
- }
-
- template<typename _devw> address_map_entry &w(const char *tag, void (_devw::*write)(address_space &, offs_t, u16, u16), const char *write_name) {
- return w(write16_delegate(write, write_name, tag, (_devw *)nullptr));
- }
-
- template<typename _devw> address_map_entry &w(const char *tag, void (_devw::*write)(address_space &, offs_t, u32, u32), const char *write_name) {
- return w(write32_delegate(write, write_name, tag, (_devw *)nullptr));
- }
-
- template<typename _devw> address_map_entry &w(const char *tag, void (_devw::*write)(address_space &, offs_t, u64, u64), const char *write_name) {
- return w(write64_delegate(write, write_name, tag, (_devw *)nullptr));
- }
-
- template<typename _devr, typename _devw> address_map_entry &rw(const char *tag, u8 (_devr::*read)(address_space &, offs_t, u8), const char *read_name, void (_devw::*write)(address_space &, offs_t, u8, u8), const char *write_name) {
- return rw(read8_delegate(read, read_name, tag, (_devr *)nullptr),
- write8_delegate(write, write_name, tag, (_devw *)nullptr));
- }
-
- template<typename _devr, typename _devw> address_map_entry &rw(const char *tag, u16 (_devr::*read)(address_space &, offs_t, u16), const char *read_name, void (_devw::*write)(address_space &, offs_t, u16, u16), const char *write_name) {
- return rw(read16_delegate(read, read_name, tag, (_devr *)nullptr),
- write16_delegate(write, write_name, tag, (_devw *)nullptr));
- }
-
- template<typename _devr, typename _devw> address_map_entry &rw(const char *tag, u32 (_devr::*read)(address_space &, offs_t, u32), const char *read_name, void (_devw::*write)(address_space &, offs_t, u32, u32), const char *write_name) {
- return rw(read32_delegate(read, read_name, tag, (_devr *)nullptr),
- write32_delegate(write, write_name, tag, (_devw *)nullptr));
- }
-
- template<typename _devr, typename _devw> address_map_entry &rw(const char *tag, u64 (_devr::*read)(address_space &, offs_t, u64), const char *read_name, void (_devw::*write)(address_space &, offs_t, u64, u64), const char *write_name) {
- return rw(read64_delegate(read, read_name, tag, (_devr *)nullptr),
- write64_delegate(write, write_name, tag, (_devw *)nullptr));
- }
-
- template<typename _dev> address_map_entry &m(const char *tag, void (_dev::*map)(address_map &), const char *map_name) {
- return m(tag, address_map_constructor(map, map_name, (_dev *)nullptr));
- }
-
- template<typename _dev> address_map_entry &setoffset(const char *tag, void (_dev::*so)(address_space &, offs_t), const char *so_name) {
- return setoffset(setoffset_delegate(so, so_name, tag, (_dev *)nullptr));
- }
-
-
- // device pointer/finder -> delegate converter
- template<typename _devc, typename _devr> std::enable_if_t<std::is_base_of<_devr, _devc>::value, address_map_entry &> r(_devc *device, u8 (_devr::*read)(address_space &, offs_t, u8), const char *read_name) {
- return r(read8_delegate(read, read_name, device->tag(), device));
- }
+ // implicit base -> delegate converter
+ template <typename T, typename Ret, typename... Params>
+ address_map_entry &r(Ret (T::*read)(Params...), const char *read_name)
+ { return r(make_delegate(read, read_name, m_devbase.tag(), make_pointer<T>(m_devbase))); }
- template<typename _devc, bool _reqd, typename _devr> std::enable_if_t<std::is_base_of<_devr, _devc>::value, address_map_entry &> r(device_finder<_devc, _reqd> device, u8 (_devr::*read)(address_space &, offs_t, u8), const char *read_name) {
- return r(read8_delegate(read, read_name, device->tag(), device.target()));
- }
+ template <typename T, typename Ret, typename... Params>
+ address_map_entry &w(Ret (T::*write)(Params...), const char *write_name)
+ { return w(make_delegate(write, write_name, m_devbase.tag(), make_pointer<T>(m_devbase))); }
- template<typename _devc, typename _devr> std::enable_if_t<std::is_base_of<_devr, _devc>::value, address_map_entry &> r(_devc *device, u16 (_devr::*read)(address_space &, offs_t, u16), const char *read_name) {
- return r(read16_delegate(read, read_name, device->tag(), device));
- }
+ 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(make_delegate(read, read_name, m_devbase.tag(), make_pointer<T>(m_devbase)), make_delegate(write, write_name, m_devbase.tag(), make_pointer<U>(m_devbase))); }
- template<typename _devc, bool _reqd, typename _devr> std::enable_if_t<std::is_base_of<_devr, _devc>::value, address_map_entry &> r(device_finder<_devc, _reqd> device, u16 (_devr::*read)(address_space &, offs_t, u16), const char *read_name) {
- return r(read16_delegate(read, read_name, device->tag(), device.target()));
- }
+ template <typename T, typename Ret, typename... Params>
+ address_map_entry &m(Ret (T::*map)(Params...), const char *map_name)
+ { return m(&m_devbase, make_delegate(map, map_name, make_pointer<T>(m_devbase))); }
- template<typename _devc, typename _devr> std::enable_if_t<std::is_base_of<_devr, _devc>::value, address_map_entry &> r(_devc *device, u32 (_devr::*read)(address_space &, offs_t, u32), const char *read_name) {
- return r(read32_delegate(read, read_name, device->tag(), device));
- }
+ template <typename T, typename Ret, typename... Params>
+ address_map_entry &setoffset(Ret (T::*so)(Params...), const char *so_name)
+ { return setoffset(make_delegate(so, so_name, m_devbase.tag(), make_pointer<T>(m_devbase))); }
- template<typename _devc, bool _reqd, typename _devr> std::enable_if_t<std::is_base_of<_devr, _devc>::value, address_map_entry &> r(device_finder<_devc, _reqd> device, u32 (_devr::*read)(address_space &, offs_t, u32), const char *read_name) {
- return r(read32_delegate(read, read_name, device->tag(), device.target()));
- }
- template<typename _devc, typename _devr> std::enable_if_t<std::is_base_of<_devr, _devc>::value, address_map_entry &> r(_devc *device, u64 (_devr::*read)(address_space &, offs_t, u64), const char *read_name) {
- return r(read64_delegate(read, read_name, device->tag(), device));
- }
+ // device tag -> delegate converter
+ template <typename T, typename Ret, typename... Params>
+ address_map_entry &r(const char *tag, Ret (T::*read)(Params...), const char *read_name)
+ { return r(make_delegate(read, read_name, tag, static_cast<T *>(nullptr))); }
- template<typename _devc, bool _reqd, typename _devr> std::enable_if_t<std::is_base_of<_devr, _devc>::value, address_map_entry &> r(device_finder<_devc, _reqd> device, u64 (_devr::*read)(address_space &, offs_t, u64), const char *read_name) {
- return r(read64_delegate(read, read_name, device->tag(), device.target()));
- }
+ template <typename T, typename Ret, typename... Params>
+ address_map_entry &w(const char *tag, Ret (T::*write)(Params...), const char *write_name)
+ { return w(make_delegate(write, write_name, tag, static_cast<T *>(nullptr))); }
- template<typename _devc, typename _devw> std::enable_if_t<std::is_base_of<_devw, _devc>::value, address_map_entry &> w(_devc *device, void (_devw::*write)(address_space &, offs_t, u8, u8), const char *write_name) {
- return w(write8_delegate(write, write_name, device->tag(), device));
- }
+ 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(make_delegate(read, read_name, tag, static_cast<T *>(nullptr)), make_delegate(write, write_name, tag, static_cast<U *>(nullptr))); }
- template<typename _devc, bool _reqd, typename _devw> std::enable_if_t<std::is_base_of<_devw, _devc>::value, address_map_entry &> w(device_finder<_devc, _reqd> device, void (_devw::*write)(address_space &, offs_t, u8, u8), const char *write_name) {
- return w(write8_delegate(write, write_name, device->tag(), device.target()));
- }
+ template <typename T, typename Ret, typename... Params>
+ address_map_entry &m(const char *tag, Ret (T::*map)(Params...), const char *map_name)
+ { return m(tag, make_delegate(map, map_name, static_cast<T *>(nullptr))); }
- template<typename _devc, typename _devw> std::enable_if_t<std::is_base_of<_devw, _devc>::value, address_map_entry &> w(_devc *device, void (_devw::*write)(address_space &, offs_t, u16, u16), const char *write_name) {
- return w(write16_delegate(write, write_name, device->tag(), device));
- }
+ template <typename T, typename Ret, typename... Params>
+ address_map_entry &setoffset(const char *tag, Ret (T::*so)(Params...), const char *so_name)
+ { return setoffset(make_delegate(so, so_name, tag, static_cast<T *>(nullptr))); }
- template<typename _devc, bool _reqd, typename _devw> std::enable_if_t<std::is_base_of<_devw, _devc>::value, address_map_entry &> w(device_finder<_devc, _reqd> device, void (_devw::*write)(address_space &, offs_t, u16, u16), const char *write_name) {
- return w(write16_delegate(write, write_name, device->tag(), device.target()));
- }
- template<typename _devc, typename _devw> std::enable_if_t<std::is_base_of<_devw, _devc>::value, address_map_entry &> w(_devc *device, void (_devw::*write)(address_space &, offs_t, u32, u32), const char *write_name) {
- return w(write32_delegate(write, write_name, device->tag(), device));
- }
+ // device reference -> delegate converter
+ template <typename T, typename U, typename Ret, typename... Params>
+ address_map_entry &r(T &obj, Ret (U::*read)(Params...), const char *read_name)
+ { return r(make_delegate(read, read_name, get_tag(obj), make_pointer<U>(obj))); }
- template<typename _devc, bool _reqd, typename _devw> std::enable_if_t<std::is_base_of<_devw, _devc>::value, address_map_entry &> w(device_finder<_devc, _reqd> device, void (_devw::*write)(address_space &, offs_t, u32, u32), const char *write_name) {
- return w(write32_delegate(write, write_name, device->tag(), device.target()));
- }
+ template <typename T, typename U, typename Ret, typename... Params>
+ address_map_entry &w(T &obj, Ret (U::*write)(Params...), const char *write_name)
+ { return w(make_delegate(write, write_name, get_tag(obj), make_pointer<U>(obj))); }
- template<typename _devc, typename _devw> std::enable_if_t<std::is_base_of<_devw, _devc>::value, address_map_entry &> w(_devc *device, void (_devw::*write)(address_space &, offs_t, u64, u64), const char *write_name) {
- return w(write64_delegate(write, write_name, device->tag(), device));
- }
+ 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(make_delegate(read, read_name, get_tag(obj), make_pointer<U>(obj)), make_delegate(write, write_name, get_tag(obj), make_pointer<V>(obj))); }
- template<typename _devc, bool _reqd, typename _devw> std::enable_if_t<std::is_base_of<_devw, _devc>::value, address_map_entry &> w(device_finder<_devc, _reqd> device, void (_devw::*write)(address_space &, offs_t, u64, u64), const char *write_name) {
- return w(write64_delegate(write, write_name, device->tag(), device.target()));
- }
+ template <typename T, typename U, typename Ret, typename... Params>
+ address_map_entry &m(T &obj, Ret (U::*map)(Params...), const char *map_name)
+ { return m(make_pointer<device_t>(obj), make_delegate(map, map_name, make_pointer<U>(obj))); }
- template<typename _devc, typename _devr, typename _devw> std::enable_if_t<std::is_base_of<_devr, _devc>::value, std::enable_if_t<std::is_base_of<_devw, _devc>::value, address_map_entry &>> rw(_devc *device, u8 (_devr::*read)(address_space &, offs_t, u8), const char *read_name, void (_devw::*write)(address_space &, offs_t, u8, u8), const char *write_name) {
- return rw(read8_delegate(read, read_name, device->tag(), device),
- write8_delegate(write, write_name, device->tag(), device));
- }
+ template <typename T, typename U, typename Ret, typename... Params>
+ address_map_entry &setoffset(T &obj, Ret (U::*so)(Params...), const char *so_name)
+ { return w(make_delegate(so, so_name, get_tag(obj), make_pointer<U>(obj))); }
- template<typename _devc, bool _reqd, typename _devr, typename _devw> std::enable_if_t<std::is_base_of<_devr, _devc>::value, std::enable_if_t<std::is_base_of<_devw, _devc>::value, address_map_entry &>> rw(device_finder<_devc, _reqd> device, u8 (_devr::*read)(address_space &, offs_t, u8), const char *read_name, void (_devw::*write)(address_space &, offs_t, u8, u8), const char *write_name) {
- return rw(read8_delegate(read, read_name, device->tag(), device.target()),
- write8_delegate(write, write_name, device->tag(), device.target()));
- }
- template<typename _devc, typename _devr, typename _devw> std::enable_if_t<std::is_base_of<_devr, _devc>::value, std::enable_if_t<std::is_base_of<_devw, _devc>::value, address_map_entry &>> rw(_devc *device, u16 (_devr::*read)(address_space &, offs_t, u16), const char *read_name, void (_devw::*write)(address_space &, offs_t, u16, u16), const char *write_name) {
- return rw(read16_delegate(read, read_name, device->tag(), device),
- write16_delegate(write, write_name, device->tag(), device));
- }
+ // device finder -> delegate converter
+ template <typename T, bool Reqd, typename U, typename Ret, typename... Params>
+ address_map_entry &r(device_finder<T, Reqd> &finder, Ret (U::*read)(Params...), const char *read_name)
+ { const std::pair<device_t &, const char *> target(finder.finder_target()); device_t &device(*target.first.subdevice(target.second)); return r(make_delegate(read, read_name, device.tag(), make_pointer<U>(device))); }
- template<typename _devc, bool _reqd, typename _devr, typename _devw> std::enable_if_t<std::is_base_of<_devr, _devc>::value, std::enable_if_t<std::is_base_of<_devw, _devc>::value, address_map_entry &>> rw(device_finder<_devc, _reqd> device, u16 (_devr::*read)(address_space &, offs_t, u16), const char *read_name, void (_devw::*write)(address_space &, offs_t, u16, u16), const char *write_name) {
- return rw(read16_delegate(read, read_name, device->tag(), device.target()),
- write16_delegate(write, write_name, device->tag(), device.target()));
- }
+ template <typename T, bool Reqd, typename U, typename Ret, typename... Params>
+ address_map_entry &r(const device_finder<T, Reqd> &finder, Ret (U::*read)(Params...), const char *read_name)
+ { const std::pair<device_t &, const char *> target(finder.finder_target()); device_t &device(*target.first.subdevice(target.second)); return r(make_delegate(read, read_name, device.tag(), make_pointer<U>(device))); }
- template<typename _devc, typename _devr, typename _devw> std::enable_if_t<std::is_base_of<_devr, _devc>::value, std::enable_if_t<std::is_base_of<_devw, _devc>::value, address_map_entry &>> rw(_devc *device, u32 (_devr::*read)(address_space &, offs_t, u32), const char *read_name, void (_devw::*write)(address_space &, offs_t, u32, u32), const char *write_name) {
- return rw(read32_delegate(read, read_name, device->tag(), device),
- write32_delegate(write, write_name, device->tag(), device));
- }
+ template <typename T, bool Reqd, typename U, typename Ret, typename... Params>
+ address_map_entry &w(device_finder<T, Reqd> &finder, Ret (U::*write)(Params...), const char *write_name)
+ { const std::pair<device_t &, const char *> target(finder.finder_target()); device_t &device(*target.first.subdevice(target.second)); return w(make_delegate(write, write_name, device.tag(), make_pointer<U>(device))); }
- template<typename _devc, bool _reqd, typename _devr, typename _devw> std::enable_if_t<std::is_base_of<_devr, _devc>::value, std::enable_if_t<std::is_base_of<_devw, _devc>::value, address_map_entry &>> rw(device_finder<_devc, _reqd> device, u32 (_devr::*read)(address_space &, offs_t, u32), const char *read_name, void (_devw::*write)(address_space &, offs_t, u32, u32), const char *write_name) {
- return rw(read32_delegate(read, read_name, device->tag(), device.target()),
- write32_delegate(write, write_name, device->tag(), device.target()));
- }
+ template <typename T, bool Reqd, typename U, typename Ret, typename... Params>
+ address_map_entry &w(const device_finder<T, Reqd> &finder, Ret (U::*write)(Params...), const char *write_name)
+ { const std::pair<device_t &, const char *> target(finder.finder_target()); device_t &device(*target.first.subdevice(target.second)); return w(make_delegate(write, write_name, device.tag(), make_pointer<U>(device))); }
- template<typename _devc, typename _devr, typename _devw> std::enable_if_t<std::is_base_of<_devr, _devc>::value, std::enable_if_t<std::is_base_of<_devw, _devc>::value, address_map_entry &>> rw(_devc *device, u64 (_devr::*read)(address_space &, offs_t, u64), const char *read_name, void (_devw::*write)(address_space &, offs_t, u64, u64), const char *write_name) {
- return rw(read64_delegate(read, read_name, device->tag(), device),
- write64_delegate(write, write_name, device->tag(), device));
- }
+ 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(make_delegate(read, read_name, device.tag(), make_pointer<U>(device)), make_delegate(write, write_name, device.tag(), make_pointer<V>(device))); }
- template<typename _devc, bool _reqd, typename _devr, typename _devw> std::enable_if_t<std::is_base_of<_devr, _devc>::value, std::enable_if_t<std::is_base_of<_devw, _devc>::value, address_map_entry &>> rw(device_finder<_devc, _reqd> device, u64 (_devr::*read)(address_space &, offs_t, u64), const char *read_name, void (_devw::*write)(address_space &, offs_t, u64, u64), const char *write_name) {
- return rw(read64_delegate(read, read_name, device->tag(), device.target()),
- write64_delegate(write, write_name, device->tag(), device.target()));
- }
+ 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(make_delegate(read, read_name, device.tag(), make_pointer<U>(device)), make_delegate(write, write_name, device.tag(), make_pointer<V>(device))); }
- template<typename _devc, typename _devm> std::enable_if_t<std::is_base_of<_devm, _devc>::value, address_map_entry &> m(_devc *device, void (_devm::*map)(address_map &), const char *map_name) {
- return m(device, address_map_constructor(map, map_name, 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)
+ { const std::pair<device_t &, const char *> target(finder.finder_target()); device_t &device(*target.first.subdevice(target.second)); return m(&device, make_delegate(map, map_name, make_pointer<U>(device))); }
- template<typename _devc, bool _reqd, typename _devm> std::enable_if_t<std::is_base_of<_devm, _devc>::value, address_map_entry &> m(device_finder<_devc, _reqd> device, void (_devm::*map)(address_map &), const char *map_name) {
- return m(device.target(), address_map_constructor(map, map_name, device.target()));
- }
+ template <typename T, bool Reqd, typename U, typename Ret, typename... Params>
+ address_map_entry &m(const device_finder<T, Reqd> &finder, Ret (U::*map)(Params...), const char *map_name)
+ { const std::pair<device_t &, const char *> target(finder.finder_target()); device_t &device(*target.first.subdevice(target.second)); return m(make_delegate(map, map_name, make_pointer<U>(device))); }
- template<typename _devc, typename _devs> std::enable_if_t<std::is_base_of<_devs, _devc>::value, address_map_entry &> &setoffset(_devc *device, void (_devs::*so)(address_space &, offs_t), const char *so_name) {
- return setoffset(setoffset_delegate(so, so_name, device->tag(), device));
- }
+ template <typename T, bool Reqd, typename U, typename Ret, typename... Params>
+ address_map_entry &setoffset(device_finder<T, Reqd> &finder, Ret (U::*so)(Params...), const char *so_name)
+ { const std::pair<device_t &, const char *> target(finder.finder_target()); device_t &device(*target.first.subdevice(target.second)); return setoffset(make_delegate(so, so_name, device.tag(), make_pointer<U>(device))); }
- template<typename _devc, bool _reqd, typename _devs> std::enable_if_t<std::is_base_of<_devs, _devc>::value, address_map_entry &> &setoffset(device_finder<_devc, _reqd> device, void (_devs::*so)(address_space &, offs_t), const char *so_name) {
- return setoffset(setoffset_delegate(so, so_name, device->tag(), device.target()));
- }
+ template <typename T, bool Reqd, typename U, typename Ret, typename... Params>
+ address_map_entry &setoffset(const device_finder<T, Reqd> &finder, Ret (U::*so)(Params...), const char *so_name)
+ { const std::pair<device_t &, const char *> target(finder.finder_target()); device_t &device(*target.first.subdevice(target.second)); return setoffset(make_delegate(so, so_name, device.tag(), make_pointer<U>(device))); }
// lambda -> delegate converter