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.h273
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