netlist: Use unique_ptr where possible. (nw)

Also improve code readability.

src/devices/machine/netlist.cpp

@@ -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_name = netlist::pool().make_unique<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_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_poolptr<netlist::param_double_t>(*this, plib::pfmt("OFFSET{1}")(i), 0.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::unique_pool_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_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);

src/devices/machine/netlist.h

@@ -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;
 };

src/lib/netlist/devices/nld_system.cpp

@@ -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",              "")

src/lib/netlist/devices/nlid_truthtable.cpp

@@ -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;

src/lib/netlist/nl_base.cpp

@@ -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;
+	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_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;
+	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_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);

src/lib/netlist/nl_base.h

@@ -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)); }
+		void register_net(owned_pool_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;
-		}
 
+		/**
+		 * @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());
+			m_next_scheduled_time = exec().time() + delay;
-			const auto nst(lexec.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;
 		}
 	}
 

src/lib/netlist/nl_factory.cpp

@@ -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)

src/lib/netlist/nl_factory.h

@@ -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;
 

src/lib/netlist/nl_setup.cpp

@@ -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));
+			auto dev = e.second->Create(m_nlstate, e.first);
-			m_nlstate.add_dev(dev->name(), std::move(dev));
+			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);
 		}

src/lib/netlist/nltypes.h

@@ -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.
 	 *

src/lib/netlist/plib/pmempool.h

@@ -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

src/lib/netlist/prg/nltool.cpp

@@ -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)
 	{

src/lib/netlist/solver/nld_matrix_solver.cpp

@@ -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

src/lib/netlist/solver/nld_matrix_solver.h

@@ -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;
 

src/lib/netlist/solver/nld_solver.cpp

@@ -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;