Sprinter/mame
2
0
Fork 0
mirror of https://github.com/holub/mame synced 2025-06-04 20:06:28 +03:00
Code Issues Actions 5 Packages Projects Releases Wiki Activity

netlist: Use unique_ptr where possible. (nw)

Browse Source 
Also improve code readability.
This commit is contained in:
couriersud 2019-10-15 11:30:05 +02:00
parent d9905f3d03
commit 6daeb4b4d1
16 changed files with 1460 additions and 1337 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

22
src/devices/machine/netlist.cpp
View File

@ -499,9 +499,9 @@ public:
for (int i = 0; i < MAX_INPUT_CHANNELS; i++)
{
m_channels[i].m_param_name = netlist::pool().make_poolptr<netlist::param_str_t>(*this, plib::pfmt("CHAN{1}")(i), "");
m_channels[i].m_param_mult = netlist::pool().make_poolptr<netlist::param_double_t>(*this, plib::pfmt("MULT{1}")(i), 1.0);
m_channels[i].m_param_offset = netlist::pool().make_poolptr<netlist::param_double_t>(*this, plib::pfmt("OFFSET{1}")(i), 0.0);
m_channels[i].m_param_name = netlist::pool().make_unique<netlist::param_str_t>(*this, plib::pfmt("CHAN{1}")(i), "");
m_channels[i].m_param_mult = netlist::pool().make_unique<netlist::param_double_t>(*this, plib::pfmt("MULT{1}")(i), 1.0);
m_channels[i].m_param_offset = netlist::pool().make_unique<netlist::param_double_t>(*this, plib::pfmt("OFFSET{1}")(i), 0.0);
}
}
@ -548,11 +548,11 @@ public:
struct channel
{
netlist::pool_owned_ptr<netlist::param_str_t> m_param_name;
netlist::unique_pool_ptr<netlist::param_str_t> m_param_name;
netlist::param_double_t *m_param;
stream_sample_t *m_buffer;
netlist::pool_owned_ptr<netlist::param_double_t> m_param_mult;
netlist::pool_owned_ptr<netlist::param_double_t> m_param_offset;
netlist::unique_pool_ptr<netlist::param_double_t> m_param_mult;
netlist::unique_pool_ptr<netlist::param_double_t> m_param_offset;
};
channel m_channels[MAX_INPUT_CHANNELS];
netlist::netlist_time m_inc;
@ -732,10 +732,10 @@ void netlist_mame_analog_output_device::custom_netlist_additions(netlist::netlis
if (owner()->has_running_machine())
m_delegate.bind_relative_to(owner()->machine().root_device());
auto dev = netlist::pool().make_poolptr<NETLIB_NAME(analog_callback)>(nlstate, dfqn);
auto dev = netlist::pool().make_unique<NETLIB_NAME(analog_callback)>(nlstate, dfqn);
//static_cast<NETLIB_NAME(analog_callback) *>(dev.get())->register_callback(std::move(m_delegate));
dev->register_callback(std::move(m_delegate));
nlstate.add_dev(dfqn, std::move(dev));
nlstate.register_device(dfqn, std::move(dev));
nlstate.setup().register_link(dname + ".IN", pin);
}
@ -772,9 +772,9 @@ void netlist_mame_logic_output_device::custom_netlist_additions(netlist::netlist
if (owner()->has_running_machine())
m_delegate.bind_relative_to(owner()->machine().root_device());
auto dev = netlist::pool().make_poolptr<NETLIB_NAME(logic_callback)>(nlstate, dfqn);
auto dev = netlist::pool().make_unique<NETLIB_NAME(logic_callback)>(nlstate, dfqn);
dev->register_callback(std::move(m_delegate));
nlstate.add_dev(dfqn, std::move(dev));
nlstate.register_device(dfqn, std::move(dev));
nlstate.setup().register_link(dname + ".IN", pin);
}
@ -1127,7 +1127,7 @@ void netlist_mame_device::device_start()
{
LOGDEVCALLS("device_start entry\n");
m_netlist = netlist::pool().make_poolptr<netlist_mame_t>(*this, "netlist");
m_netlist = netlist::pool().make_unique<netlist_mame_t>(*this, "netlist");
if (!machine().options().verbose())
{
m_netlist->nlstate().log().verbose.set_enabled(false);

2
src/devices/machine/netlist.h
View File

@ -111,7 +111,7 @@ private:
netlist::netlist_time m_rem;
netlist::netlist_time m_old;
netlist::pool_owned_ptr<netlist_mame_t> m_netlist;
netlist::unique_pool_ptr<netlist_mame_t> m_netlist;
func_type m_setup_func;
};

2
src/lib/netlist/devices/nld_system.cpp
View File

@ -111,7 +111,7 @@ namespace netlist
NETLIB_DEVICE_IMPL(clock, "CLOCK", "FREQ")
NETLIB_DEVICE_IMPL(varclock, "VARCLOCK", "FUNC")
NETLIB_DEVICE_IMPL(extclock, "EXTCLOCK", "FREQ,PATTERN")
NETLIB_DEVICE_IMPL(res_sw, "RES_SWITCH", "+IN,+P1,+P2")
NETLIB_DEVICE_IMPL(res_sw, "RES_SWITCH", "+I,+1,+2")
NETLIB_DEVICE_IMPL(mainclock, "MAINCLOCK", "FREQ")
NETLIB_DEVICE_IMPL(gnd, "GND", "")
NETLIB_DEVICE_IMPL(netlistparams, "PARAMETER", "")

4
src/lib/netlist/devices/nlid_truthtable.cpp
View File

@ -223,7 +223,7 @@ namespace netlist
: netlist_base_factory_truthtable_t(name, classname, def_param, sourcefile)
{ }
pool_owned_ptr<device_t> Create(netlist_state_t &anetlist, const pstring &name) override
unique_pool_ptr<device_t> Create(netlist_state_t &anetlist, const pstring &name) override
{
using tt_type = nld_truthtable_t<m_NI, m_NO>;
truthtable_parser desc_s(m_NO, m_NI, &m_ttbl.m_initialized,
@ -239,7 +239,7 @@ namespace netlist
if (m_family_desc == nullptr)
throw nl_exception("family description not found for {1}", m_family_name);
return pool().make_poolptr<tt_type>(anetlist, name, m_family_desc, m_ttbl, m_desc);
return pool().make_unique<tt_type>(anetlist, name, m_family_desc, m_ttbl, m_desc);
}
private:
typename nld_truthtable_t<m_NI, m_NO>::truthtable_t m_ttbl;

55
src/lib/netlist/nl_base.cpp
View File

@ -49,17 +49,17 @@ public:
m_R_low = 1.0;
m_R_high = 130.0;
}
pool_owned_ptr<devices::nld_base_d_to_a_proxy> create_d_a_proxy(netlist_state_t &anetlist, const pstring &name, logic_output_t *proxied) const override;
pool_owned_ptr<devices::nld_base_a_to_d_proxy> create_a_d_proxy(netlist_state_t &anetlist, const pstring &name, logic_input_t *proxied) const override;
unique_pool_ptr<devices::nld_base_d_to_a_proxy> create_d_a_proxy(netlist_state_t &anetlist, const pstring &name, logic_output_t *proxied) const override;
unique_pool_ptr<devices::nld_base_a_to_d_proxy> create_a_d_proxy(netlist_state_t &anetlist, const pstring &name, logic_input_t *proxied) const override;
};
pool_owned_ptr<devices::nld_base_d_to_a_proxy> logic_family_ttl_t::create_d_a_proxy(netlist_state_t &anetlist, const pstring &name, logic_output_t *proxied) const
unique_pool_ptr<devices::nld_base_d_to_a_proxy> logic_family_ttl_t::create_d_a_proxy(netlist_state_t &anetlist, const pstring &name, logic_output_t *proxied) const
{
return pool().make_poolptr<devices::nld_d_to_a_proxy>(anetlist, name, proxied);
return pool().make_unique<devices::nld_d_to_a_proxy>(anetlist, name, proxied);
}
pool_owned_ptr<devices::nld_base_a_to_d_proxy> logic_family_ttl_t::create_a_d_proxy(netlist_state_t &anetlist, const pstring &name, logic_input_t *proxied) const
unique_pool_ptr<devices::nld_base_a_to_d_proxy> logic_family_ttl_t::create_a_d_proxy(netlist_state_t &anetlist, const pstring &name, logic_input_t *proxied) const
{
return pool().make_poolptr<devices::nld_a_to_d_proxy>(anetlist, name, proxied);
return pool().make_unique<devices::nld_a_to_d_proxy>(anetlist, name, proxied);
}
class logic_family_cd4xxx_t : public logic_family_desc_t
@ -76,18 +76,18 @@ public:
m_R_low = 10.0;
m_R_high = 10.0;
}
pool_owned_ptr<devices::nld_base_d_to_a_proxy> create_d_a_proxy(netlist_state_t &anetlist, const pstring &name, logic_output_t *proxied) const override;
pool_owned_ptr<devices::nld_base_a_to_d_proxy> create_a_d_proxy(netlist_state_t &anetlist, const pstring &name, logic_input_t *proxied) const override;
unique_pool_ptr<devices::nld_base_d_to_a_proxy> create_d_a_proxy(netlist_state_t &anetlist, const pstring &name, logic_output_t *proxied) const override;
unique_pool_ptr<devices::nld_base_a_to_d_proxy> create_a_d_proxy(netlist_state_t &anetlist, const pstring &name, logic_input_t *proxied) const override;
};
pool_owned_ptr<devices::nld_base_d_to_a_proxy> logic_family_cd4xxx_t::create_d_a_proxy(netlist_state_t &anetlist, const pstring &name, logic_output_t *proxied) const
unique_pool_ptr<devices::nld_base_d_to_a_proxy> logic_family_cd4xxx_t::create_d_a_proxy(netlist_state_t &anetlist, const pstring &name, logic_output_t *proxied) const
{
return pool().make_poolptr<devices::nld_d_to_a_proxy>(anetlist, name, proxied);
return pool().make_unique<devices::nld_d_to_a_proxy>(anetlist, name, proxied);
}
pool_owned_ptr<devices::nld_base_a_to_d_proxy> logic_family_cd4xxx_t::create_a_d_proxy(netlist_state_t &anetlist, const pstring &name, logic_input_t *proxied) const
unique_pool_ptr<devices::nld_base_a_to_d_proxy> logic_family_cd4xxx_t::create_a_d_proxy(netlist_state_t &anetlist, const pstring &name, logic_input_t *proxied) const
{
return pool().make_poolptr<devices::nld_a_to_d_proxy>(anetlist, name, proxied);
return pool().make_unique<devices::nld_a_to_d_proxy>(anetlist, name, proxied);
}
const logic_family_desc_t *family_TTL()
@ -409,7 +409,8 @@ void netlist_t::process_queue_stats(const netlist_time delta) NL_NOEXCEPT
while (e.m_object != nullptr)
{
e.m_object->template update_devs<KEEP_STATS>();
if (KEEP_STATS) m_perf_out_processed.inc();
if (KEEP_STATS)
m_perf_out_processed.inc();
e = m_queue.pop();
m_time = e.m_exec_time;
}
@ -435,7 +436,8 @@ void netlist_t::process_queue_stats(const netlist_time delta) NL_NOEXCEPT
if (e.m_object != nullptr)
{
e.m_object->template update_devs<KEEP_STATS>();
if (KEEP_STATS) m_perf_out_processed.inc();
if (KEEP_STATS)
m_perf_out_processed.inc();
}
else
break;
@ -568,7 +570,7 @@ core_device_t::core_device_t(core_device_t &owner, const pstring &name)
set_logic_family(owner.logic_family());
if (logic_family() == nullptr)
set_logic_family(family_TTL());
state().add_dev(this->name(), pool_owned_ptr<core_device_t>(this, false));
state().register_device(this->name(), owned_pool_ptr<core_device_t>(this, false));
if (exec().stats_enabled())
m_stats = pool().make_unique<stats_t>();
}
@ -725,6 +727,7 @@ void detail::net_t::process(const T mask, netlist_sig_t sig)
template <bool KEEP_STATS>
void detail::net_t::update_devs() NL_NOEXCEPT
{
#if 0
nl_assert(this->isRailNet());
const unsigned int new_Q(m_new_Q);
@ -743,6 +746,24 @@ void detail::net_t::update_devs() NL_NOEXCEPT
/* do nothing */
break;
}
#else
nl_assert(this->isRailNet());
const unsigned int mask((m_new_Q << core_terminal_t::INP_LH_SHIFT)
| (m_cur_Q << core_terminal_t::INP_HL_SHIFT));
m_in_queue = queue_status::DELIVERED; /* mark as taken ... */
switch (mask)
{
case core_terminal_t::STATE_INP_HL:
case core_terminal_t::STATE_INP_LH:
process<KEEP_STATS>(mask | core_terminal_t::STATE_INP_ACTIVE, m_new_Q);
break;
default:
/* do nothing */
break;
}
#endif
}
void detail::net_t::reset()
@ -897,7 +918,7 @@ logic_output_t::logic_output_t(core_device_t &dev, const pstring &aname)
, m_my_net(dev.state(), name() + ".net", this)
{
this->set_net(&m_my_net);
state().register_net(pool_owned_ptr<logic_net_t>(&m_my_net, false));
state().register_net(owned_pool_ptr<logic_net_t>(&m_my_net, false));
set_logic_family(dev.logic_family());
state().setup().register_term(*this);
}
@ -927,7 +948,7 @@ analog_output_t::analog_output_t(core_device_t &dev, const pstring &aname)
: analog_t(dev, aname, STATE_OUT)
, m_my_net(dev.state(), name() + ".net", this)
{
state().register_net(pool_owned_ptr<analog_net_t>(&m_my_net, false));
state().register_net(owned_pool_ptr<analog_net_t>(&m_my_net, false));
this->set_net(&m_my_net);
//net().m_cur_Analog = NL_FCONST(0.0);

134
src/lib/netlist/nl_base.h
View File

@ -144,7 +144,7 @@ class NETLIB_NAME(name) : public device_t
#define NETLIB_TIMESTEP(chip) void NETLIB_NAME(chip) :: timestep(const nl_double step)
#define NETLIB_SUB(chip) nld_ ## chip
#define NETLIB_SUBXX(ns, chip) pool_owned_ptr< ns :: nld_ ## chip >
#define NETLIB_SUBXX(ns, chip) unique_pool_ptr< ns :: nld_ ## chip >
#define NETLIB_HANDLER(chip, name) void NETLIB_NAME(chip) :: name() NL_NOEXCEPT
#define NETLIB_UPDATE(chip) NETLIB_HANDLER(chip, update)
@ -249,9 +249,9 @@ namespace netlist
virtual ~logic_family_desc_t() noexcept = default;
virtual pool_owned_ptr<devices::nld_base_d_to_a_proxy> create_d_a_proxy(netlist_state_t &anetlist, const pstring &name,
virtual unique_pool_ptr<devices::nld_base_d_to_a_proxy> create_d_a_proxy(netlist_state_t &anetlist, const pstring &name,
logic_output_t *proxied) const = 0;
virtual pool_owned_ptr<devices::nld_base_a_to_d_proxy> create_a_d_proxy(netlist_state_t &anetlist, const pstring &name,
virtual unique_pool_ptr<devices::nld_base_a_to_d_proxy> create_a_d_proxy(netlist_state_t &anetlist, const pstring &name,
logic_input_t *proxied) const = 0;
double fixed_V() const { return m_fixed_V; }
@ -698,14 +698,14 @@ namespace netlist
netlist_sig_t Q() const noexcept { return m_cur_Q; }
/* only used for logic nets */
void initial(const netlist_sig_t val) noexcept
void initial(netlist_sig_t val) noexcept
{
m_cur_Q = m_new_Q = val;
update_inputs();
}
/* only used for logic nets */
void set_Q_and_push(const netlist_sig_t newQ, const netlist_time delay) NL_NOEXCEPT
void set_Q_and_push(netlist_sig_t newQ, netlist_time delay) NL_NOEXCEPT
{
if (newQ != m_new_Q)
{
@ -715,7 +715,7 @@ namespace netlist
}
/* only used for logic nets */
void set_Q_time(const netlist_sig_t newQ, const netlist_time at) NL_NOEXCEPT
void set_Q_time(netlist_sig_t newQ, netlist_time at) NL_NOEXCEPT
{
if (newQ != m_new_Q)
{
@ -935,14 +935,14 @@ namespace netlist
logic_output_t(core_device_t &dev, const pstring &aname);
void initial(const netlist_sig_t val);
void initial(netlist_sig_t val);
void push(const netlist_sig_t newQ, const netlist_time delay) NL_NOEXCEPT
void push(netlist_sig_t newQ, netlist_time delay) NL_NOEXCEPT
{
m_my_net.set_Q_and_push(newQ, delay); // take the shortcut
}
void set_Q_time(const netlist_sig_t newQ, const netlist_time at) NL_NOEXCEPT
void set_Q_time(netlist_sig_t newQ, netlist_time at) NL_NOEXCEPT
{
m_my_net.set_Q_time(newQ, at); // take the shortcut
}
@ -1260,9 +1260,9 @@ namespace netlist
const setup_t &setup() const;
template<class C, typename... Args>
void create_and_register_subdevice(const pstring &name, pool_owned_ptr<C> &dev, Args&&... args)
void create_and_register_subdevice(const pstring &name, unique_pool_ptr<C> &dev, Args&&... args)
{
dev = pool().make_poolptr<C>(*this, name, std::forward<Args>(args)...);
dev = pool().make_unique<C>(*this, name, std::forward<Args>(args)...);
}
void register_subalias(const pstring &name, detail::core_terminal_t &term);
@ -1338,10 +1338,10 @@ namespace netlist
{
public:
using nets_collection_type = std::vector<pool_owned_ptr<detail::net_t>>;
using nets_collection_type = std::vector<owned_pool_ptr<detail::net_t>>;
/* need to preserve order of device creation ... */
using devices_collection_type = std::vector<std::pair<pstring, pool_owned_ptr<core_device_t>>>;
using devices_collection_type = std::vector<std::pair<pstring, owned_pool_ptr<core_device_t>>>;
netlist_state_t(const pstring &aname,
netlist_t & anetlist,
plib::unique_ptr<callbacks_t> &&callbacks);
@ -1360,10 +1360,38 @@ namespace netlist
core_device_t *get_single_device(const pstring &classname, bool (*cc)(core_device_t *)) const;
/**
* @brief Get single device filtered by class and name
*
* @tparam C Device class for which devices will be returned
* @param name Name of the device
*
* @return pointers to device
*/
template<class C>
C *get_single_device(const pstring &classname) const
C *get_single_device(const pstring &name) const
{
return dynamic_cast<C *>(get_single_device(classname, check_class<C>));
return dynamic_cast<C *>(get_single_device(name, check_class<C>));
}
/**
* @brief Get vector of devices
*
* @tparam C Device class for which devices will be returned
*
* @return vector with pointers to devices
*/
template<class C>
inline std::vector<C *> get_device_list()
{
std::vector<C *> tmp;
for (auto &d : m_devices)
{
auto dev = dynamic_cast<C *>(d.second.get());
if (dev != nullptr)
tmp.push_back(dev);
}
return tmp;
}
/* logging and name */
@ -1396,21 +1424,16 @@ namespace netlist
std::size_t find_net_id(const detail::net_t *net) const;
template <typename T>
void register_net(pool_owned_ptr<T> &&net) { m_nets.push_back(std::move(net)); }
template<class device_class>
inline std::vector<device_class *> get_device_list()
{
std::vector<device_class *> tmp;
for (auto &d : m_devices)
{
auto dev = dynamic_cast<device_class *>(d.second.get());
if (dev != nullptr)
tmp.push_back(dev);
}
return tmp;
}
void register_net(owned_pool_ptr<T> &&net) { m_nets.push_back(std::move(net)); }
/**
* @brief Get device pointer by name
*
*
* @param name Name of the device
*
* @return core_device_t pointer if device exists, else nullptr
*/
core_device_t *find_device(const pstring &name)
{
for (auto & d : m_devices)
@ -1419,8 +1442,17 @@ namespace netlist
return nullptr;
}
/**
* @brief Register device using owned_ptr
*
* Used to register owned devices. These are devices declared as objects
* in another devices.
*
* @param name Name of the device
* @param dev Device to be registered
*/
template <typename T>
void add_dev(const pstring &name, pool_owned_ptr<T> &&dev)
void register_device(const pstring &name, owned_pool_ptr<T> &&dev)
{
for (auto & d : m_devices)
if (d.first == name)
@ -1432,6 +1464,20 @@ namespace netlist
m_devices.insert(m_devices.end(), { name, std::move(dev) });
}
/**
* @brief Register device using unique_ptr
*
* Used to register devices.
*
* @param name Name of the device
* @param dev Device to be registered
*/
template <typename T>
void register_device(const pstring &name, unique_pool_ptr<T> &&dev)
{
register_device(name, owned_pool_ptr<T>(dev.release(), true, dev.get_deleter()));
}
/**
* @brief Remove device
*
@ -1440,7 +1486,7 @@ namespace netlist
*
* @param dev Device to be removed
*/
void remove_dev(core_device_t *dev)
void remove_device(core_device_t *dev)
{
for (auto it = m_devices.begin(); it != m_devices.end(); it++)
if (it->second.get() == dev)
@ -1451,20 +1497,20 @@ namespace netlist
}
}
/* sole use is to manage lifetime of family objects */
std::unordered_map<pstring, plib::unique_ptr<logic_family_desc_t>> m_family_cache;
setup_t &setup() NL_NOEXCEPT { return *m_setup; }
const setup_t &setup() const NL_NOEXCEPT { return *m_setup; }
nets_collection_type & nets() { return m_nets; }
devices_collection_type & devices() { return m_devices; }
// FIXME: make a postload member and include code there
void rebuild_lists(); /* must be called after post_load ! */
static void compile_defines(std::vector<std::pair<pstring, pstring>> &defs);
nets_collection_type & nets() { return m_nets; }
devices_collection_type & devices() { return m_devices; }
/* sole use is to manage lifetime of family objects */
std::unordered_map<pstring, plib::unique_ptr<logic_family_desc_t>> m_family_cache;
private:
void reset();
@ -1503,7 +1549,7 @@ namespace netlist
netlist_time time() const NL_NOEXCEPT { return m_time; }
void process_queue(const netlist_time delta) NL_NOEXCEPT;
void process_queue(netlist_time delta) NL_NOEXCEPT;
void abort_current_queue_slice() NL_NOEXCEPT { m_queue.retime(detail::queue_t::entry_t(m_time, nullptr)); }
const detail::queue_t &queue() const NL_NOEXCEPT { return m_queue; }
@ -1559,7 +1605,7 @@ namespace netlist
private:
template <bool KEEP_STATS>
void process_queue_stats(const netlist_time delta) NL_NOEXCEPT;
void process_queue_stats(netlist_time delta) NL_NOEXCEPT;
plib::unique_ptr<netlist_state_t> m_state;
devices::NETLIB_NAME(solver) * m_solver;
@ -1708,27 +1754,25 @@ namespace netlist
}
}
inline void detail::net_t::push_to_queue(const netlist_time delay) NL_NOEXCEPT
inline void detail::net_t::push_to_queue(netlist_time delay) NL_NOEXCEPT
{
if ((num_cons() != 0))
{
auto &lexec(exec());
const auto nst(lexec.time() + delay);
m_next_scheduled_time = exec().time() + delay;
if (is_queued())
lexec.qremove(this);
exec().qremove(this);
if (!m_list_active.empty())
{
m_in_queue = queue_status::QUEUED;
lexec.qpush(queue_t::entry_t(nst, this));
exec().qpush(queue_t::entry_t(m_next_scheduled_time, this));
}
else
{
m_in_queue = queue_status::DELAYED_DUE_TO_INACTIVE;
update_inputs();
}
m_next_scheduled_time = nst;
}
}

4
src/lib/netlist/nl_factory.cpp
View File

@ -76,9 +76,9 @@ namespace netlist { namespace factory
// factory_lib_entry_t: factory class to wrap macro based chips/elements
// -----------------------------------------------------------------------------
pool_owned_ptr<device_t> library_element_t::Create(netlist_state_t &anetlist, const pstring &name)
unique_pool_ptr<device_t> library_element_t::Create(netlist_state_t &anetlist, const pstring &name)
{
return pool().make_poolptr<NETLIB_NAME(wrapper)>(anetlist, name);
return pool().make_unique<NETLIB_NAME(wrapper)>(anetlist, name);
}
void library_element_t::macro_actions(nlparse_t &nparser, const pstring &name)

8
src/lib/netlist/nl_factory.h
View File

@ -55,7 +55,7 @@ namespace factory {
COPYASSIGNMOVE(element_t, default)
virtual pool_owned_ptr<device_t> Create(netlist_state_t &anetlist, const pstring &name) = 0;
virtual unique_pool_ptr<device_t> Create(netlist_state_t &anetlist, const pstring &name) = 0;
virtual void macro_actions(nlparse_t &nparser, const pstring &name)
{
plib::unused_var(nparser);
@ -85,9 +85,9 @@ namespace factory {
const pstring &def_param, const pstring &sourcefile)
: element_t(name, classname, def_param, sourcefile) { }
pool_owned_ptr<device_t> Create(netlist_state_t &anetlist, const pstring &name) override
unique_pool_ptr<device_t> Create(netlist_state_t &anetlist, const pstring &name) override
{
return pool().make_poolptr<C>(anetlist, name);
return pool().make_unique<C>(anetlist, name);
}
};
@ -147,7 +147,7 @@ namespace factory {
{
}
pool_owned_ptr<device_t> Create(netlist_state_t &anetlist, const pstring &name) override;
unique_pool_ptr<device_t> Create(netlist_state_t &anetlist, const pstring &name) override;
void macro_actions(nlparse_t &nparser, const pstring &name) override;

31
src/lib/netlist/nl_setup.cpp
View File

@ -474,7 +474,7 @@ devices::nld_base_proxy *setup_t::get_d_a_proxy(detail::core_terminal_t &out)
proxy = new_proxy.get();
m_nlstate.add_dev(new_proxy->name(), std::move(new_proxy));
m_nlstate.register_device(new_proxy->name(), std::move(new_proxy));
}
return proxy;
}
@ -513,7 +513,7 @@ devices::nld_base_proxy *setup_t::get_a_d_proxy(detail::core_terminal_t &inp)
inp.net().core_terms().clear(); // clear the list
}
ret->out().net().add_terminal(inp);
m_nlstate.add_dev(new_proxy->name(), std::move(new_proxy));
m_nlstate.register_device(new_proxy->name(), std::move(new_proxy));
return ret;
}
}
@ -635,7 +635,7 @@ void setup_t::connect_terminals(detail::core_terminal_t &t1, detail::core_termin
{
log().debug("adding analog net ...\n");
// FIXME: Nets should have a unique name
auto anet = pool().make_poolptr<analog_net_t>(m_nlstate,"net." + t1.name());
auto anet = pool().make_owned<analog_net_t>(m_nlstate,"net." + t1.name());
auto anetp = anet.get();
m_nlstate.register_net(std::move(anet));
t1.set_net(anetp);
@ -824,7 +824,7 @@ void setup_t::register_dynamic_log_devices()
auto nc = factory().factory_by_name("LOG")->Create(m_nlstate, name);
register_link(name + ".I", ll);
log().debug(" dynamic link {1}: <{2}>\n",ll, name);
m_nlstate.add_dev(nc->name(), std::move(nc));
m_nlstate.register_device(nc->name(), std::move(nc));
}
}
}
@ -970,19 +970,19 @@ class logic_family_std_proxy_t : public logic_family_desc_t
{
public:
logic_family_std_proxy_t() = default;
pool_owned_ptr<devices::nld_base_d_to_a_proxy> create_d_a_proxy(netlist_state_t &anetlist,
unique_pool_ptr<devices::nld_base_d_to_a_proxy> create_d_a_proxy(netlist_state_t &anetlist,
const pstring &name, logic_output_t *proxied) const override;
pool_owned_ptr<devices::nld_base_a_to_d_proxy> create_a_d_proxy(netlist_state_t &anetlist, const pstring &name, logic_input_t *proxied) const override;
unique_pool_ptr<devices::nld_base_a_to_d_proxy> create_a_d_proxy(netlist_state_t &anetlist, const pstring &name, logic_input_t *proxied) const override;
};
pool_owned_ptr<devices::nld_base_d_to_a_proxy> logic_family_std_proxy_t::create_d_a_proxy(netlist_state_t &anetlist,
unique_pool_ptr<devices::nld_base_d_to_a_proxy> logic_family_std_proxy_t::create_d_a_proxy(netlist_state_t &anetlist,
const pstring &name, logic_output_t *proxied) const
{
return pool().make_poolptr<devices::nld_d_to_a_proxy>(anetlist, name, proxied);
return pool().make_unique<devices::nld_d_to_a_proxy>(anetlist, name, proxied);
}
pool_owned_ptr<devices::nld_base_a_to_d_proxy> logic_family_std_proxy_t::create_a_d_proxy(netlist_state_t &anetlist, const pstring &name, logic_input_t *proxied) const
unique_pool_ptr<devices::nld_base_a_to_d_proxy> logic_family_std_proxy_t::create_a_d_proxy(netlist_state_t &anetlist, const pstring &name, logic_input_t *proxied) const
{
return pool().make_poolptr<devices::nld_a_to_d_proxy>(anetlist, name, proxied);
return pool().make_unique<devices::nld_a_to_d_proxy>(anetlist, name, proxied);
}
@ -1043,7 +1043,7 @@ void setup_t::delete_empty_nets()
{
m_nlstate.nets().erase(
std::remove_if(m_nlstate.nets().begin(), m_nlstate.nets().end(),
[](pool_owned_ptr<detail::net_t> &x)
[](owned_pool_ptr<detail::net_t> &x)
{
if (x->num_cons() == 0)
{
@ -1071,7 +1071,7 @@ void setup_t::prepare_to_run()
if ( factory().is_class<devices::NETLIB_NAME(solver)>(e.second)
|| factory().is_class<devices::NETLIB_NAME(netlistparams)>(e.second))
{
m_nlstate.add_dev(e.first, pool_owned_ptr<device_t>(e.second->Create(m_nlstate, e.first)));
m_nlstate.register_device(e.first, e.second->Create(m_nlstate, e.first));
}
}
@ -1093,8 +1093,8 @@ void setup_t::prepare_to_run()
if ( !factory().is_class<devices::NETLIB_NAME(solver)>(e.second)
&& !factory().is_class<devices::NETLIB_NAME(netlistparams)>(e.second))
{
auto dev = pool_owned_ptr<device_t>(e.second->Create(m_nlstate, e.first));
m_nlstate.add_dev(dev->name(), std::move(dev));
auto dev = e.second->Create(m_nlstate, e.first);
m_nlstate.register_device(dev->name(), std::move(dev));
}
}
@ -1151,7 +1151,7 @@ void setup_t::prepare_to_run()
t->name(), t->m_N.net().name(), t->m_P.net().name()));
t->m_N.net().remove_terminal(t->m_N);
t->m_P.net().remove_terminal(t->m_P);
m_nlstate.remove_dev(t);
m_nlstate.remove_device(t);
}
else
{
@ -1175,7 +1175,6 @@ void setup_t::prepare_to_run()
for (auto &n : m_nlstate.nets())
for (auto & term : n->core_terms())
{
//core_device_t *dev = reinterpret_cast<core_device_t *>(term->m_delegate.object());
core_device_t *dev = &term->device();
dev->set_default_delegate(*term);
}

2
src/lib/netlist/nltypes.h
View File

@ -99,7 +99,7 @@ namespace netlist
*
*/
template <typename T>
using pool_owned_ptr = nlmempool::owned_pool_ptr<T>;
using owned_pool_ptr = nlmempool::owned_pool_ptr<T>;
/*! Unique pointer type for pooled allocations.
*

2
src/lib/netlist/plib/pmempool.h
View File

@ -189,7 +189,7 @@ namespace plib {
using unique_pool_ptr = std::unique_ptr<T, arena_deleter<mempool, T>>;
template<typename T, typename... Args>
owned_pool_ptr<T> make_poolptr(Args&&... args)
owned_pool_ptr<T> make_owned(Args&&... args)
{
auto *mem = this->allocate(alignof(T), sizeof(T));
try

2
src/lib/netlist/prg/nltool.cpp
View File

@ -714,7 +714,7 @@ void tool_app_t::listdevices()
nt.setup().prepare_to_run();
std::vector<netlist::pool_owned_ptr<netlist::core_device_t>> devs;
std::vector<netlist::unique_pool_ptr<netlist::core_device_t>> devs;
for (auto & f : list)
{

4
src/lib/netlist/solver/nld_matrix_solver.cpp
View File

@ -114,9 +114,9 @@ namespace devices
{
pstring nname(this->name() + "." + pstring(plib::pfmt("m{1}")(m_inps.size())));
nl_assert(p->net().is_analog());
auto net_proxy_output_u = pool().make_poolptr<proxied_analog_output_t>(*this, nname, static_cast<analog_net_t *>(&p->net()));
auto net_proxy_output_u = pool().make_unique<proxied_analog_output_t>(*this, nname, static_cast<analog_net_t *>(&p->net()));
net_proxy_output = net_proxy_output_u.get();
m_inps.push_back(std::move(net_proxy_output_u));
m_inps.emplace_back(std::move(net_proxy_output_u));
}
net_proxy_output->net().add_terminal(*p);
// FIXME: repeated calling - kind of brute force

2
src/lib/netlist/solver/nld_matrix_solver.h
View File

@ -370,7 +370,7 @@ namespace devices
std::vector<plib::unique_ptr<terms_for_net_t>> m_terms;
std::vector<pool_owned_ptr<proxied_analog_output_t>> m_inps;
std::vector<unique_pool_ptr<proxied_analog_output_t>> m_inps;
std::vector<plib::unique_ptr<terms_for_net_t>> m_rails_temp;

2
src/lib/netlist/solver/nld_solver.cpp
View File

@ -227,13 +227,13 @@ namespace devices
switch (net_count)
{
#if 0
case 1:
ms = plib::make_unique<matrix_solver_direct1_t<double>>(state(), sname, &m_params);
break;
case 2:
ms = plib::make_unique<matrix_solver_direct2_t<double>>(state(), sname, &m_params);
break;
#if 1
case 3:
ms = create_solver<double, 3>(3, sname);
break;

2521
src/mame/machine/nl_breakout.cpp
View File

File diff suppressed because it is too large Load Diff