diff options
Diffstat (limited to 'src/emu/addrmap.h')
-rw-r--r-- | src/emu/addrmap.h | 273 |
1 files changed, 195 insertions, 78 deletions
diff --git a/src/emu/addrmap.h b/src/emu/addrmap.h index 5a256c735fe..25ff7d8cec5 100644 --- a/src/emu/addrmap.h +++ b/src/emu/addrmap.h @@ -40,7 +40,8 @@ enum map_handler_type AMH_DEVICE_DELEGATE_SMO, AMH_PORT, AMH_BANK, - AMH_DEVICE_SUBMAP + AMH_DEVICE_SUBMAP, + AMH_VIEW }; @@ -70,19 +71,23 @@ class address_map_entry { friend class address_map; - 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> - 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, bool Reqd> + static device_t &find_device(const device_finder<T, Reqd> &finder) { + const std::pair<device_t &, const char *> target(finder.finder_target()); + device_t *device(target.first.subdevice(target.second)); + if (!device) + throw emu_fatalerror("Device %s not found in %s\n", target.second, target.first.tag()); + return *device; + } 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); } + static T *make_pointer(U &obj) + { + if constexpr (std::is_convertible_v<std::add_pointer_t<U>, std::add_pointer_t<T> >) + return &downcast<T &>(obj); + else + 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(); } @@ -116,6 +121,11 @@ public: assert(&target.first == &m_devbase); return share(target.second); } + template<typename _ptrt> address_map_entry &share(const memory_share_creator<_ptrt> &finder) { + const std::pair<device_t &, const char *> target(finder.finder_target()); + assert(&target.first == &m_devbase); + return share(target.second); + } address_map_entry &rom() { m_read.m_type = AMH_ROM; return *this; } address_map_entry &ram() { m_read.m_type = AMH_RAM; m_write.m_type = AMH_RAM; return *this; } @@ -139,16 +149,59 @@ public: // chip select width setting address_map_entry &cswidth(int _cswidth) { m_cswidth = _cswidth; return *this; } + // flags setting + address_map_entry &flags(u16 _flags) { m_flags = _flags; return *this; } + // I/O port configuration address_map_entry &portr(const char *tag) { m_read.m_type = AMH_PORT; m_read.m_tag = tag; return *this; } address_map_entry &portw(const char *tag) { m_write.m_type = AMH_PORT; m_write.m_tag = tag; return *this; } address_map_entry &portrw(const char *tag) { portr(tag); portw(tag); return *this; } + template<bool req> address_map_entry &portr(ioport_finder<req> &finder) { + const std::pair<device_t &, const char *> target(finder.finder_target()); + assert(&target.first == &m_devbase); + m_read.m_type = AMH_PORT; + m_read.m_tag = target.second; + return *this; + } + + template<bool req> address_map_entry &portw(ioport_finder<req> &finder) { + const std::pair<device_t &, const char *> target(finder.finder_target()); + assert(&target.first == &m_devbase); + m_write.m_type = AMH_PORT; + m_write.m_tag = target.second; + return *this; + } + + template<bool req> address_map_entry &portrw(ioport_finder<req> &finder) { + const std::pair<device_t &, const char *> target(finder.finder_target()); + assert(&target.first == &m_devbase); + m_write.m_type = m_read.m_type = AMH_PORT; + m_write.m_tag = m_read.m_tag = target.second; + return *this; + } + // memory bank configuration address_map_entry &bankr(const char *tag) { m_read.m_type = AMH_BANK; m_read.m_tag = tag; return *this; } address_map_entry &bankw(const char *tag) { m_write.m_type = AMH_BANK; m_write.m_tag = tag; return *this; } address_map_entry &bankrw(const char *tag) { bankr(tag); bankw(tag); return *this; } + address_map_entry &bankr(const memory_bank_creator &finder) { + const std::pair<device_t &, const char *> target(finder.finder_target()); + assert(&target.first == &m_devbase); + return bankr(target.second); + } + address_map_entry &bankw(const memory_bank_creator &finder) { + const std::pair<device_t &, const char *> target(finder.finder_target()); + assert(&target.first == &m_devbase); + return bankw(target.second); + } + address_map_entry &bankrw(const memory_bank_creator &finder) { + const std::pair<device_t &, const char *> target(finder.finder_target()); + assert(&target.first == &m_devbase); + return bankrw(target.second); + } + template<bool _reqd> address_map_entry &bankr(const memory_bank_finder<_reqd> &finder) { const std::pair<device_t &, const char *> target(finder.finder_target()); assert(&target.first == &m_devbase); @@ -173,143 +226,199 @@ public: address_map_entry &m(const char *tag, address_map_constructor func); address_map_entry &m(device_t *device, address_map_constructor func); + // view initialization + void view(memory_view &mv); + + + // wait-states, implicit base -> delegate converter + template <typename T> + address_map_entry &before_time(u64 (T::*ws)(offs_t, u64), const char *name) + { m_before_time = ws_time_delegate(*make_pointer<T>(m_devbase), ws, name); return *this; } + + template <typename T> + address_map_entry &before_delay(u32 (T::*ws)(offs_t), const char *name) + { m_before_delay = ws_delay_delegate(*make_pointer<T>(m_devbase), ws, name); return *this; } + + template <typename T> + address_map_entry &after_delay(u32 (T::*ws)(offs_t), const char *name) + { m_after_delay = ws_delay_delegate(*make_pointer<T>(m_devbase), ws, name); return *this; } + + // wait-states, device tag -> delegate converter + template <typename T> + address_map_entry &before_time(const char *tag, u64 (T::*ws)(offs_t, u64), const char *name) + { m_before_time = ws_time_delegate(m_devbase, tag, ws, name); return *this; } + + template <typename T> + address_map_entry &before_delay(const char *tag, u32 (T::*ws)(offs_t), const char *name) + { m_before_delay = ws_delay_delegate(m_devbase, tag, ws, name); return *this; } + + template <typename T> + address_map_entry &after_delay(const char *tag, u32 (T::*ws)(offs_t), const char *name) + { m_after_delay = ws_delay_delegate(m_devbase, tag, ws, name); return *this; } + + // wait-states, device reference -> delegate converter + template <typename T, typename U> + address_map_entry &before_time(T &obj, u64 (U::*ws)(offs_t, u64), const char *name) + { m_before_time = ws_time_delegate(obj, ws, name); return *this; } + + template <typename T, typename U> + address_map_entry &before_delay(T &obj, u32 (U::*ws)(offs_t), const char *name) + { m_before_delay = ws_delay_delegate(obj, ws, name); return *this; } + + template <typename T, typename U> + address_map_entry &after_delay(T &obj, u32 (U::*ws)(offs_t), const char *name) + { m_after_delay = ws_delay_delegate(obj, ws, name); return *this; } + + // wait-states, lambda -> delegate converter + template <typename T> + address_map_entry &before_time(T &&ws, const char *name) + { m_before_time = ws_time_delegate(m_devbase, std::forward<T>(ws), name); return *this; } + + template <typename T> + address_map_entry &before_delay(T &&ws, const char *name) + { m_before_delay = ws_delay_delegate(m_devbase, std::forward<T>(ws), name); return *this; } + + template <typename T> + address_map_entry &after_delay(T &&ws, const char *name) + { m_after_delay = ws_delay_delegate(m_devbase, std::forward<T>(ws), name); return *this; } + // 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(emu::detail::make_delegate(read, read_name, m_devbase.tag(), make_pointer<T>(m_devbase))); } + { return r(emu::rw_delegate(*make_pointer<T>(m_devbase), read, read_name)); } template <typename T, typename Ret, typename... Params> address_map_entry &w(Ret (T::*write)(Params...), const char *write_name) - { return w(emu::detail::make_delegate(write, write_name, m_devbase.tag(), make_pointer<T>(m_devbase))); } + { return w(emu::rw_delegate(*make_pointer<T>(m_devbase), write, write_name)); } 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 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))); } + { return r(emu::rw_delegate(*make_pointer<T>(m_devbase), read, read_name)).w(emu::rw_delegate(*make_pointer<U>(m_devbase), write, write_name)); } 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))); } + { return m(&m_devbase, address_map_constructor(map, map_name, make_pointer<T>(m_devbase))); } // 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(emu::detail::make_delegate(read, read_name, tag, nullptr)); } + { return r(emu::rw_delegate(m_devbase, tag, read, read_name)); } template <typename T, typename Ret, typename... Params> address_map_entry &w(const char *tag, Ret (T::*write)(Params...), const char *write_name) - { return w(emu::detail::make_delegate(write, write_name, tag, nullptr)); } + { return w(emu::rw_delegate(m_devbase, tag, write, write_name)); } 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 r(emu::detail::make_delegate(read, read_name, tag, nullptr)).w(emu::detail::make_delegate(write, write_name, tag, nullptr)); } + { return r(emu::rw_delegate(m_devbase, tag, read, read_name)).w(emu::rw_delegate(m_devbase, tag, write, write_name)); } 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))); } + { return m(tag, address_map_constructor(map, map_name, static_cast<T *>(nullptr))); } // 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(emu::detail::make_delegate(read, read_name, get_tag(obj), make_pointer<U>(obj))); } + { return r(emu::rw_delegate(*make_pointer<U>(obj), read, read_name)); } 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(emu::detail::make_delegate(write, write_name, get_tag(obj), make_pointer<U>(obj))); } + { return w(emu::rw_delegate(*make_pointer<U>(obj), write, write_name)); } 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 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))); } + { return r(emu::rw_delegate(*make_pointer<U>(obj), read, read_name)).w(emu::rw_delegate(make_pointer<V>(obj), write, write_name)); } 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))); } + { return m(make_pointer<device_t>(obj), address_map_constructor(map, map_name, make_pointer<U>(obj))); } // 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(emu::detail::make_delegate(read, read_name, device.tag(), make_pointer<U>(device))); } + address_map_entry &r(device_finder<T, Reqd> &finder, Ret (U::*read)(Params...), const char *read_name) { + return r(emu::rw_delegate(finder, read, read_name)); + } 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(emu::detail::make_delegate(read, read_name, device.tag(), make_pointer<U>(device))); } + address_map_entry &r(const device_finder<T, Reqd> &finder, Ret (U::*read)(Params...), const char *read_name) { + return r(emu::rw_delegate(finder, read, read_name)); + } 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(emu::detail::make_delegate(write, write_name, device.tag(), make_pointer<U>(device))); } + address_map_entry &w(device_finder<T, Reqd> &finder, Ret (U::*write)(Params...), const char *write_name) { + return w(emu::rw_delegate(finder, write, write_name)); + } 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(emu::detail::make_delegate(write, write_name, device.tag(), make_pointer<U>(device))); } + address_map_entry &w(const device_finder<T, Reqd> &finder, Ret (U::*write)(Params...), const char *write_name) { + return w(emu::rw_delegate(finder, write, write_name)); + } 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 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))); } + 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) { + return r(emu::rw_delegate(finder, read, read_name)) + .w(emu::rw_delegate(finder, write, write_name)); + } 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 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))); } + 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) { + return r(emu::rw_delegate(finder, read, read_name)) + .w(emu::rw_delegate(finder, write, write_name)); + } 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))); } + address_map_entry &m(device_finder<T, Reqd> &finder, Ret (U::*map)(Params...), const char *map_name) { + device_t &device(find_device(finder)); + return m(&device, address_map_constructor(map, map_name, make_pointer<U>(device))); + } 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))); } + address_map_entry &m(const device_finder<T, Reqd> &finder, Ret (U::*map)(Params...), const char *map_name) { + device_t &device(find_device(finder)); + return m(&device, address_map_constructor(map, map_name, make_pointer<U>(device))); + } // lambda -> delegate converter - template<typename _lr> address_map_entry &lr8(const char *name, _lr &&read) { - return r(emu::detail::make_lr8_delegate(read, name)); - } + template <typename T> address_map_entry &lr8(T &&read, const char *name) + { return r(emu::detail::make_lr8_delegate(m_devbase, std::forward<T>(read), name)); } - template<typename _lr> address_map_entry &lr16(const char *name, _lr &&read) { - return r(emu::detail::make_lr16_delegate(read, name)); - } + template <typename T> address_map_entry &lr16(T &&read, const char *name) + { return r(emu::detail::make_lr16_delegate(m_devbase, std::forward<T>(read), name)); } - template<typename _lr> address_map_entry &lr32(const char *name, _lr &&read) { - return r(emu::detail::make_lr32_delegate(read, name)); - } + template <typename T> address_map_entry &lr32(T &&read, const char *name) + { return r(emu::detail::make_lr32_delegate(m_devbase, std::forward<T>(read), name)); } - template<typename _lr> address_map_entry &lr64(const char *name, _lr &&read) { - return r(emu::detail::make_lr64_delegate(read, name)); - } + template <typename T> address_map_entry &lr64(T &&read, const char *name) + { return r(emu::detail::make_lr64_delegate(m_devbase, std::forward<T>(read), name)); } - template<typename _lw> address_map_entry &lw8(const char *name, _lw &&write) { - return w(emu::detail::make_lw8_delegate(write, name)); - } + template <typename T> address_map_entry &lw8(T &&write, const char *name) + { return w(emu::detail::make_lw8_delegate(m_devbase, std::forward<T>(write), name)); } - template<typename _lw> address_map_entry &lw16(const char *name, _lw &&write) { - return w(emu::detail::make_lw16_delegate(write, name)); - } + template <typename T> address_map_entry &lw16(T &&write, const char *name) + { return w(emu::detail::make_lw16_delegate(m_devbase, std::forward<T>(write), name)); } - template<typename _lw> address_map_entry &lw32(const char *name, _lw &&write) { - return w(emu::detail::make_lw32_delegate(write, name)); - } + template <typename T> address_map_entry &lw32(T &&write, const char *name) + { return w(emu::detail::make_lw32_delegate(m_devbase, std::forward<T>(write), name)); } - template<typename _lw> address_map_entry &lw64(const char *name, _lw &&write) { - return w(emu::detail::make_lw64_delegate(write, name)); - } + template <typename T> address_map_entry &lw64(T &&write, const char *name) + { return w(emu::detail::make_lw64_delegate(m_devbase, std::forward<T>(write), name)); } - template<typename _lr, typename _lw> address_map_entry &lrw8(const char *name, _lr &&read, _lw &&write) { - return r(emu::detail::make_lr8_delegate(read, name)).w(emu::detail::make_lw8_delegate(write, name)); - } + template <typename T, typename U> address_map_entry &lrw8(T &&read, const char *read_name, U &&write, const char *write_name) + { return r(emu::detail::make_lr8_delegate(m_devbase, std::forward<T>(read), read_name)).w(emu::detail::make_lw8_delegate(m_devbase, std::forward<U>(write), write_name)); } - template<typename _lr, typename _lw> address_map_entry &lrw16(const char *name, _lr &&read, _lw &&write) { - return r(emu::detail::make_lr16_delegate(read, name)).w(emu::detail::make_lw16_delegate(write, name)); - } + template <typename T, typename U> address_map_entry &lrw16(T &&read, const char *read_name, U &&write, const char *write_name) + { return r(emu::detail::make_lr16_delegate(m_devbase, std::forward<T>(read), read_name)).w(emu::detail::make_lw16_delegate(m_devbase, std::forward<U>(write), write_name)); } - template<typename _lr, typename _lw> address_map_entry &lrw32(const char *name, _lr &&read, _lw &&write) { - return r(emu::detail::make_lr32_delegate(read, name)).w(emu::detail::make_lw32_delegate(write, name)); - } + template <typename T, typename U> address_map_entry &lrw32(T &&read, const char *read_name, U &&write, const char *write_name) + { return r(emu::detail::make_lr32_delegate(m_devbase, std::forward<T>(read), read_name)).w(emu::detail::make_lw32_delegate(m_devbase, std::forward<U>(write), write_name)); } - template<typename _lr, typename _lw> address_map_entry &lrw64(const char *name, _lr &&read, _lw &&write) { - return r(emu::detail::make_lr64_delegate(read, name)).w(emu::detail::make_lw64_delegate(write, name)); - } + template <typename T, typename U> address_map_entry &lrw64(T &&read, const char *read_name, U &&write, const char *write_name) + { return r(emu::detail::make_lr64_delegate(m_devbase, std::forward<T>(read), read_name)).w(emu::detail::make_lw64_delegate(m_devbase, std::forward<U>(write), write_name)); } // public state address_map_entry * m_next; // pointer to the next entry @@ -324,11 +433,15 @@ public: offs_t m_addrselect; // select bits u64 m_mask; // mask for which lanes apply int m_cswidth; // chip select width override + u16 m_flags; // user flags map_handler_data m_read; // data for read handler map_handler_data m_write; // data for write handler const char * m_share; // tag of a shared memory block const char * m_region; // tag of region containing the memory backing this entry offs_t m_rgnoffs; // offset within the region + ws_time_delegate m_before_time; // before-time wait-state + ws_delay_delegate m_before_delay; // before-delay wait-state + ws_delay_delegate m_after_delay; // after-delay wait-state // handlers read8_delegate m_rproto8; // 8-bit read proto-delegate @@ -387,6 +500,7 @@ public: device_t *m_submap_device; address_map_constructor m_submap_delegate; + memory_view *m_view; // information used during processing void * m_memory; // pointer to memory backing this entry @@ -460,15 +574,15 @@ class address_map public: // construction/destruction address_map(device_t &device, int spacenum); + address_map(memory_view &view); address_map(device_t &device, address_map_entry *entry); - address_map(const address_space &space, offs_t start, offs_t end, u64 unitmask, int cswidth, device_t &device, address_map_constructor submap_delegate); + address_map(const address_space &space, offs_t start, offs_t end, u64 unitmask, int cswidth, u16 flags, device_t &device, address_map_constructor submap_delegate); ~address_map(); // setters void global_mask(offs_t mask); void unmap_value_low() { m_unmapval = 0; } void unmap_value_high() { m_unmapval = ~0; } - void unmap_value(u8 value) { m_unmapval = value; } // add a new entry of the given type address_map_entry &operator()(offs_t start, offs_t end); @@ -476,12 +590,15 @@ public: // public data int m_spacenum; // space number of the map device_t * m_device; // associated device + memory_view * m_view; // view, when in one + const address_space_config * m_config; // space configuration u8 m_unmapval; // unmapped memory value offs_t m_globalmask; // global mask simple_list<address_map_entry> m_entrylist; // list of entries void import_submaps(running_machine &machine, device_t &owner, int data_width, endianness_t endian, int addr_shift); void map_validity_check(validity_checker &valid, int spacenum) const; + const address_space_config &get_config() const; }; #endif // MAME_EMU_ADDRMAP_H |