Removed hybrid_t usage in netlist.

src/emu/netlist/analog/nld_solver.c

@@ -82,14 +82,14 @@ ATTR_HOT void netlist_matrix_solver_t::update_inputs()
 {
     for (netlist_core_terminal_t * const *p = m_inps.first(); p != NULL; p = m_inps.next(p))
     {
-        if ((*p)->net().m_last.Analog != (*p)->net().m_cur.Analog)
+        if ((*p)->net().m_last_Analog != (*p)->net().m_cur_Analog)
         {
             (*p)->netdev().update_dev();
         }
     }
     for (netlist_core_terminal_t * const *p = m_inps.first(); p != NULL; p = m_inps.next(p))
     {
-        (*p)->net().m_last.Analog = (*p)->net().m_cur.Analog;
+        (*p)->net().m_last_Analog = (*p)->net().m_cur_Analog;
     }
 
 }
@@ -365,7 +365,7 @@ ATTR_HOT double netlist_matrix_solver_direct_t<m_N, _storage_N>::delta(
     double cerr2 = 0;
     for (int i = 0; i < this->N(); i++)
     {
-        double e = (V[i] - this->m_nets[i]->m_cur.Analog);
+        double e = (V[i] - this->m_nets[i]->m_cur_Analog);
         double e2 = (RHS[i] - this->m_RHS[i]);
         cerr += e * e;
         cerr2 += e2 * e2;
@@ -380,7 +380,7 @@ ATTR_HOT void netlist_matrix_solver_direct_t<m_N, _storage_N>::store(
 {
     for (int i = 0; i < this->N(); i++)
     {
-        this->m_nets[i]->m_cur.Analog = this->m_nets[i]->m_new.Analog = V[i];
+        this->m_nets[i]->m_cur_Analog = this->m_nets[i]->m_new_Analog = V[i];
     }
     if (RHS != NULL)
     {
@@ -453,10 +453,10 @@ ATTR_HOT int netlist_matrix_solver_direct1_t::solve_non_dynamic()
 
     double new_val =  m_RHS[0] / m_A[0][0];
 #endif
-    double e = (new_val - net->m_cur.Analog);
+    double e = (new_val - net->m_cur_Analog);
     double cerr = e * e;
 
-    net->m_cur.Analog = net->m_new.Analog = new_val;
+    net->m_cur_Analog = net->m_new_Analog = new_val;
 
     if (is_dynamic() && (cerr  > m_params.m_accuracy * m_params.m_accuracy))
     {
@@ -585,13 +585,13 @@ ATTR_HOT int netlist_matrix_solver_gauss_seidel_t<m_N, _storage_N>::solve_non_dy
                 iIdr += terms[i]->m_go * terms[i]->m_otherterm->net().Q_Analog();
             }
 
-            //double new_val = (net->m_cur.Analog * gabs[k] + iIdr) / (gtot[k]);
+            //double new_val = (net->m_cur_Analog * gabs[k] + iIdr) / (gtot[k]);
-            double new_val = net->m_cur.Analog * one_m_w[k] + iIdr * w[k];
+            double new_val = net->m_cur_Analog * one_m_w[k] + iIdr * w[k];
 
-            double e = (new_val - net->m_cur.Analog);
+            double e = (new_val - net->m_cur_Analog);
             cerr += e * e;
 
-            net->m_cur.Analog = net->m_new.Analog = new_val;
+            net->m_cur_Analog = net->m_new_Analog = new_val;
         }
         if (resched || cerr / m_nets.count() > m_params.m_accuracy * m_params.m_accuracy)
         {

src/emu/netlist/nl_base.c

@@ -484,16 +484,19 @@ template ATTR_COLD void netlist_device_t::register_param(const pstring &sname, n
 ATTR_COLD netlist_net_t::netlist_net_t(const type_t atype, const family_t afamily)
 	: netlist_object_t(atype, afamily)
     , m_solver(NULL)
+    , m_railterminal(NULL)
 	, m_head(NULL)
 	, m_num_cons(0)
 	, m_time(netlist_time::zero)
 	, m_active(0)
 	, m_in_queue(2)
-	, m_railterminal(NULL)
 {
-    m_last.Analog = 0.0;
+    m_last_Q = 0;
-    m_new.Analog = 0.0;
+    m_new_Q = 0;
-    m_cur.Analog = 0.0;
+    m_cur_Q = 0;
+    m_last_Analog = 0.0;
+    m_new_Analog = 0.0;
+    m_cur_Analog = 0.0;
 };
 
 ATTR_COLD netlist_net_t::~netlist_net_t()
@@ -504,12 +507,12 @@ ATTR_COLD netlist_net_t::~netlist_net_t()
 
 ATTR_COLD void netlist_net_t::reset()
 {
-    m_last.Analog = 0.0;
+    m_last_Analog = 0.0;
-    m_cur.Analog = 0.0;
+    m_cur_Analog = 0.0;
-    m_new.Analog = 0.0;
+    m_new_Analog = 0.0;
-    m_last.Q = 0; // set to something we will never hit.
+    m_last_Q = 0; // set to something we will never hit.
-    m_new.Q = 0;
+    m_new_Q = 0;
-    m_cur.Q = 0;
+    m_cur_Q = 0;
     m_time = netlist_time::zero;
     m_active = 0;
     m_in_queue = 2;
@@ -530,12 +533,12 @@ ATTR_COLD void netlist_net_t::init_object(netlist_base_t &nl, const pstring &ana
 
 ATTR_COLD void netlist_net_t::save_register()
 {
-    save(NAME(m_last.Analog));
+    save(NAME(m_last_Analog));
-    save(NAME(m_cur.Analog));
+    save(NAME(m_cur_Analog));
-    save(NAME(m_new.Analog));
+    save(NAME(m_new_Analog));
-    save(NAME(m_last.Q));
+    save(NAME(m_last_Q));
-    save(NAME(m_cur.Q));
+    save(NAME(m_cur_Q));
-    save(NAME(m_new.Q));
+    save(NAME(m_new_Q));
     save(NAME(m_time));
     save(NAME(m_active));
     save(NAME(m_in_queue));
@@ -606,12 +609,13 @@ ATTR_HOT /*ATTR_ALIGN*/ inline void netlist_net_t::update_devs()
 	assert(this->isRailNet());
 
 	const UINT32 masks[4] = { 1, 5, 3, 1 };
-    const UINT32 mask = masks[ (m_last.Q  << 1) | m_new.Q ];
+    const UINT32 mask = masks[ (m_last_Q  << 1) | m_new_Q ];
+    netlist_core_terminal_t *p = m_head;
 
     m_in_queue = 2; /* mark as taken ... */
-    m_cur = m_new;
+    m_cur_Q = m_new_Q;
 
-    netlist_core_terminal_t *p = m_head;
+    m_cur_Analog = m_new_Analog;
 
 #if 1
     switch (m_num_cons)
@@ -638,7 +642,8 @@ ATTR_HOT /*ATTR_ALIGN*/ inline void netlist_net_t::update_devs()
         p = p->m_update_list_next;
     } while (p != NULL);
 #endif
-    m_last = m_cur;
+    m_last_Q = m_cur_Q;
+    m_last_Analog = m_cur_Analog;
 }
 
 ATTR_HOT void netlist_net_t::solve()
@@ -719,9 +724,9 @@ ATTR_COLD netlist_logic_output_t::netlist_logic_output_t()
 
 ATTR_COLD void netlist_logic_output_t::initial(const netlist_sig_t val)
 {
-	net().m_cur.Q = val;
+	net().m_cur_Q = val;
-	net().m_new.Q = val;
+	net().m_new_Q = val;
-    net().m_last.Q = val;
+    net().m_last_Q = val;
 }
 
 // ----------------------------------------------------------------------------------------
@@ -740,16 +745,16 @@ ATTR_COLD netlist_ttl_output_t::netlist_ttl_output_t()
 ATTR_COLD netlist_analog_output_t::netlist_analog_output_t()
 	: netlist_output_t(OUTPUT, ANALOG)
 {
-    net().m_last.Analog = 0.97;
+    net().m_last_Analog = 0.97;
-	net().m_cur.Analog = 0.98;
+	net().m_cur_Analog = 0.98;
-	net().m_new.Analog = 0.99;
+	net().m_new_Analog = 0.99;
 }
 
 ATTR_COLD void netlist_analog_output_t::initial(const double val)
 {
-    net().m_cur.Analog = val * 0.98;
+    net().m_cur_Analog = val * 0.98;
-	net().m_cur.Analog = val * 0.99;
+	net().m_cur_Analog = val * 0.99;
-	net().m_new.Analog = val * 1.0;
+	net().m_new_Analog = val * 1.0;
 }
 
 // ----------------------------------------------------------------------------------------
@@ -844,7 +849,7 @@ ATTR_COLD double netlist_param_model_t::model_value(const pstring &entity, const
 
 ATTR_HOT inline void NETLIB_NAME(mainclock)::mc_update(netlist_net_t &net)
 {
-    net.m_new.Q ^= 1;
+    net.m_new_Q ^= 1;
     net.update_devs();
 }
 
@@ -870,7 +875,7 @@ NETLIB_UPDATE(mainclock)
 {
 	netlist_net_t &net = m_Q.net();
 	// this is only called during setup ...
-	net.m_new.Q = !net.m_new.Q;
+	net.m_new_Q = !net.m_new_Q;
 	net.set_time(netlist().time() + m_inc);
 }
 

src/emu/netlist/nl_base.h

@@ -556,13 +556,6 @@ public:
     friend class netlist_analog_output_t;
     friend class netlist_setup_t;
 
-    struct hybrid_t
-    {
-        inline hybrid_t() : Q(0), Analog(0.0) {}
-        netlist_sig_t Q;
-        double        Analog;
-    };
-
     ATTR_COLD netlist_net_t(const type_t atype, const family_t afamily);
     ATTR_COLD virtual ~netlist_net_t();
 
@@ -575,8 +568,8 @@ public:
     /* inline not always works out */
     ATTR_HOT inline void update_devs();
 
-    ATTR_HOT inline const netlist_time &time() const { return m_time; }
+    ATTR_HOT inline const netlist_time time() const { return m_time; }
-    ATTR_HOT inline void set_time(const netlist_time &ntime) { m_time = ntime; }
+    ATTR_HOT inline void set_time(const netlist_time ntime) { m_time = ntime; }
 
     ATTR_HOT inline bool isRailNet() const { return !(m_railterminal == NULL); }
     ATTR_HOT inline const netlist_core_terminal_t & RESTRICT  railterminal() const { return *m_railterminal; }
@@ -589,26 +582,26 @@ public:
     ATTR_HOT inline const netlist_sig_t Q() const
     {
         assert(family() == LOGIC);
-        return m_cur.Q;
+        return m_cur_Q;
     }
 
     ATTR_HOT inline const netlist_sig_t last_Q() const
     {
         assert(family() == LOGIC);
-        return m_last.Q;
+        return m_last_Q;
     }
 
     ATTR_HOT inline const netlist_sig_t new_Q() const
     {
         assert(family() == LOGIC);
-        return m_new.Q;
+        return m_new_Q;
     }
 
     ATTR_HOT inline const double Q_Analog() const
     {
         //assert(object_type(SIGNAL_MASK) == SIGNAL_ANALOG);
         assert(family() == ANALOG);
-        return m_cur.Analog;
+        return m_cur_Analog;
     }
 
     ATTR_HOT inline void push_to_queue(const netlist_time delay);
@@ -620,14 +613,14 @@ public:
     ATTR_COLD inline netlist_sig_t &Q_state_ptr()
     {
         assert(family() == LOGIC);
-        return m_cur.Q;
+        return m_cur_Q;
     }
 
     ATTR_COLD inline double &Q_Analog_state_ptr()
     {
         //assert(object_type(SIGNAL_MASK) == SIGNAL_ANALOG);
         assert(family() == ANALOG);
-        return m_cur.Analog;
+        return m_cur_Analog;
     }
 
     ATTR_HOT inline int num_cons() const { return m_num_cons; }
@@ -638,6 +631,7 @@ public:
     terminal_list_t m_terms;
     terminal_list_t m_rails;
     netlist_matrix_solver_t *m_solver;
+    netlist_core_terminal_t * RESTRICT m_railterminal;
 
     ATTR_HOT void solve();
 
@@ -647,23 +641,24 @@ protected:  //FIXME: needed by current solver code
 
     UINT16 m_num_cons;
 
-public:
-    hybrid_t m_last;
-    hybrid_t m_cur;
-    hybrid_t m_new;
-
-protected:
-
     ATTR_COLD virtual void save_register();
     ATTR_COLD virtual void reset();
 
 
 private:
+    netlist_sig_t m_new_Q;
+    netlist_sig_t m_cur_Q;
+    netlist_sig_t m_last_Q;
+
     netlist_time m_time;
     INT32        m_active;
     UINT8        m_in_queue;    /* 0: not in queue, 1: in queue, 2: last was taken */
 
-    netlist_core_terminal_t * RESTRICT m_railterminal;
+public:
+    double m_last_Analog;
+    double m_cur_Analog;
+    double m_new_Analog;
+
 };
 
 
@@ -706,9 +701,9 @@ public:
 
     ATTR_HOT inline void set_Q(const netlist_sig_t newQ, const netlist_time delay)
     {
-        if (EXPECTED(newQ !=  net().m_new.Q))
+        if (EXPECTED(newQ !=  net().m_new_Q))
         {
-            net().m_new.Q = newQ;
+            net().m_new_Q = newQ;
             net().push_to_queue(delay);
         }
     }
@@ -735,9 +730,9 @@ public:
 
     ATTR_HOT inline void set_Q(const double newQ, const netlist_time delay)
     {
-        if (newQ != net().m_new.Analog)
+        if (newQ != net().m_new_Analog)
         {
-            net().m_new.Analog = newQ;
+            net().m_new_Analog = newQ;
             net().push_to_queue(delay);
         }
     }
@@ -1226,9 +1221,11 @@ ATTR_HOT inline void netlist_net_t::inc_active()
     {
         if (m_active == 1 && m_in_queue > 0)
         {
-            m_last = m_cur;
+            m_last_Q = m_cur_Q;
+            m_last_Analog = m_cur_Analog; // FIXME: Needed here ?
             railterminal().netdev().inc_active();
-            m_cur = m_new;
+            m_cur_Q = m_new_Q;
+            m_cur_Analog = m_new_Analog;
         }
     }
 
@@ -1241,7 +1238,8 @@ ATTR_HOT inline void netlist_net_t::inc_active()
         }
         else
         {
-            m_cur = m_last = m_new;
+            m_cur_Q = m_last_Q = m_new_Q;
+            m_cur_Analog = m_last_Analog = m_new_Analog;  // FIXME: Needed here?
             m_in_queue = 2;
         }
     }