Sprinter/mame
2
0
Fork 0
mirror of https://github.com/holub/mame synced 2025-04-16 13:34:55 +03:00
Code Issues Actions 1 Packages Projects Releases Wiki Activity

- Added constructors to prepare to move terminal setup into constructor.

Browse Source 
- Reworked twoterm setup. Fixed some timebombs along the way.
- Fix r2r dac. Remove dead code.
- analog_outputs now created in constructor.
- moved analog_input creation into constructor. 
- moved logic output creation to constructor.
- moved all logic inputs into constructor.
- Completely removed init_object. Finally. 
[Couriersud]
This commit is contained in:
couriersud 2016-05-29 19:30:05 +02:00
parent b277908905
commit 3d3f5761f0
41 changed files with 428 additions and 640 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

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

@ -504,9 +504,11 @@ class NETLIB_NAME(analog_callback) : public netlist::device_t
{
public:
NETLIB_NAME(analog_callback)(netlist::netlist_t &anetlist, const pstring &name)
: device_t(anetlist, name), m_cpu_device(nullptr), m_last(0)
: device_t(anetlist, name)
, m_in(*this, "IN")
, m_cpu_device(nullptr)
, m_last(0)
{
enregister("IN", m_in);
m_cpu_device = downcast<netlist_mame_cpu_device_t *>(&downcast<netlist_mame_t &>(netlist()).parent());
save(NLNAME(m_last));
}
@ -555,8 +557,8 @@ public:
, m_channel(*this, "CHAN", 0)
, m_mult(*this, "MULT", 1000.0)
, m_offset(*this, "OFFSET", 0.0)
, m_in(*this, "IN")
{
enregister("IN", m_in);
m_sample = netlist::netlist_time::from_hz(1); //sufficiently big enough
save(NAME(m_last_buffer));
}
@ -624,11 +626,11 @@ class NETLIB_NAME(sound_in) : public netlist::device_t
{
public:
NETLIB_NAME(sound_in)(netlist::netlist_t &anetlist, const pstring &name)
: netlist::device_t(anetlist, name)
: netlist::device_t(anetlist, name)
, m_feedback(*this, "FB") // clock part
, m_Q(*this, "Q")
{
// clock part
enregister("Q", m_Q);
enregister("FB", m_feedback);
connect_late(m_feedback, m_Q);
m_inc = netlist::netlist_time::from_nsec(1);

38
src/lib/netlist/analog/nld_bjt.h
View File

@ -99,21 +99,21 @@ private:
NETLIB_OBJECT_DERIVED(QBJT_switch, QBJT)
{
NETLIB_CONSTRUCTOR_DERIVED(QBJT_switch, QBJT)
, m_RB(owner, "m_RB")
, m_RC(owner, "m_RC")
, m_BC_dummy(owner, "m_BC")
, m_RB(*this, "m_RB", true)
, m_RC(*this, "m_RC", true)
, m_BC_dummy(*this, "m_BC", true)
, m_gB(NETLIST_GMIN_DEFAULT)
, m_gC(NETLIST_GMIN_DEFAULT)
, m_V(0.0)
, m_state_on(0)
{
enregister("B", m_RB.m_P);
enregister("E", m_RB.m_N);
enregister("C", m_RC.m_P);
enregister("_E1", m_RC.m_N);
register_subalias("B", m_RB.m_P);
register_subalias("E", m_RB.m_N);
register_subalias("C", m_RC.m_P);
//register_term("_E1", m_RC.m_N);
enregister("_B1", m_BC_dummy.m_P);
enregister("_C1", m_BC_dummy.m_N);
//register_term("_B1", m_BC_dummy.m_P);
//register_term("_C1", m_BC_dummy.m_N);
connect_late(m_RB.m_N, m_RC.m_N);
@ -155,20 +155,20 @@ NETLIB_OBJECT_DERIVED(QBJT_EB, QBJT)
{
public:
NETLIB_CONSTRUCTOR_DERIVED(QBJT_EB, QBJT)
, m_D_CB(owner, "m_D_CB")
, m_D_EB(owner, "m_D_EB")
, m_D_EC(owner, "m_D_EC")
, m_D_CB(*this, "m_D_CB", true)
, m_D_EB(*this, "m_D_EB", true)
, m_D_EC(*this, "m_D_EC", true)
, m_alpha_f(0)
, m_alpha_r(0)
{
enregister("E", m_D_EB.m_P); // Cathode
enregister("B", m_D_EB.m_N); // Anode
register_subalias("E", m_D_EB.m_P); // Cathode
register_subalias("B", m_D_EB.m_N); // Anode
enregister("C", m_D_CB.m_P); // Cathode
enregister("_B1", m_D_CB.m_N); // Anode
register_subalias("C", m_D_CB.m_P); // Cathode
//register_term("_B1", m_D_CB.m_N); // Anode
enregister("_E1", m_D_EC.m_P);
enregister("_C1", m_D_EC.m_N);
//register_term("_E1", m_D_EC.m_P);
//register_term("_C1", m_D_EC.m_N);
connect_late(m_D_EB.m_P, m_D_EC.m_P);
connect_late(m_D_EB.m_N, m_D_CB.m_N);
@ -188,6 +188,7 @@ protected:
generic_diode m_gD_BC;
generic_diode m_gD_BE;
private:
nld_twoterm m_D_CB; // gcc, gce - gcc, gec - gcc, gcc - gce | Ic
nld_twoterm m_D_EB; // gee, gec - gee, gce - gee, gee - gec | Ie
nld_twoterm m_D_EC; // 0, -gec, -gcc, 0 | 0
@ -195,7 +196,6 @@ protected:
nl_double m_alpha_f;
nl_double m_alpha_r;
private:
};
} //namespace devices

22
src/lib/netlist/analog/nld_fourterm.h
View File

@ -60,17 +60,14 @@ public:
NETLIB_CONSTRUCTOR(VCCS)
, m_G(*this, "G", 1.0)
, m_RI(*this, "RI", NL_FCONST(1.0) / netlist().gmin())
, m_OP(*this, "OP")
, m_ON(*this, "ON")
, m_IP(*this, "IP")
, m_IN(*this, "IN")
, m_OP1(*this, "_OP1")
, m_ON1(*this, "_ON1")
, m_gfac(1.0)
{
enregister("IP", m_IP);
enregister("IN", m_IN);
enregister("OP", m_OP);
enregister("ON", m_ON);
enregister("_OP1", m_OP1);
enregister("_ON1", m_ON1);
m_IP.m_otherterm = &m_IN; // <= this should be NULL and terminal be filtered out prior to solving...
m_IN.m_otherterm = &m_IP; // <= this should be NULL and terminal be filtered out prior to solving...
@ -205,12 +202,11 @@ NETLIB_OBJECT_DERIVED(VCVS, VCCS)
{
public:
NETLIB_CONSTRUCTOR_DERIVED(VCVS, VCCS)
, m_RO(*this, "RO",1.0)
, m_RO(*this, "RO", 1.0)
, m_OP2(*this, "_OP2")
, m_ON2(*this, "_ON2")
{
enregister("_OP2", m_OP2);
enregister("_ON2", m_ON2);
m_OP2.m_otherterm = &m_ON2;
m_ON2.m_otherterm = &m_OP2;

12
src/lib/netlist/analog/nld_opamps.h
View File

@ -42,18 +42,16 @@ NETLIB_OBJECT(OPAMP)
NETLIB_CONSTRUCTOR(OPAMP)
, m_RP(*this, "RP1")
, m_G1(*this, "G1")
, m_VCC(*this, "VCC")
, m_GND(*this, "GND")
, m_model(*this, "MODEL", "")
, m_VH(*this, "VH")
, m_VL(*this, "VL")
, m_VREF(*this, "VREF")
{
m_type = m_model.model_value("TYPE");
enregister("VCC", m_VCC);
enregister("GND", m_GND);
enregister("VL", m_VL);
enregister("VH", m_VH);
enregister("VREF", m_VREF);
if (m_type == 1)
{
register_subalias("PLUS", "G1.IP");

4
src/lib/netlist/analog/nld_twoterm.cpp
View File

@ -53,10 +53,6 @@ ATTR_COLD void generic_diode::save(pstring name, object_t &parent)
NETLIB_UPDATE(twoterm)
{
/* FIXME: some proxies created seem to be disconnected again
* or not even properly connected.
* Example: pong proxy_da_c9c.Q_1.RV
*/
/* only called if connected to a rail net ==> notify the solver to recalculate */
/* we only need to call the non-rail terminal */
if (m_P.has_net() && !m_P.net().isRailNet())

34
src/lib/netlist/analog/nld_twoterm.h
View File

@ -105,8 +105,9 @@ namespace netlist
NETLIB_OBJECT(twoterm)
{
public:
NETLIB_CONSTRUCTOR(twoterm)
NETLIB_CONSTRUCTOR_EX(twoterm, bool terminals_owned = false)
, m_P(bselect(terminals_owned, owner, *this), (terminals_owned ? name + "." : "") + "1")
, m_N(bselect(terminals_owned, owner, *this), (terminals_owned ? name + "." : "") + "2")
{
m_P.m_otherterm = &m_N;
m_N.m_otherterm = &m_P;
@ -115,8 +116,8 @@ public:
terminal_t m_P;
terminal_t m_N;
NETLIB_UPDATE_TERMINALSI() { }
NETLIB_RESETI() { }
//NETLIB_UPDATE_TERMINALSI() { }
//NETLIB_RESETI() { }
NETLIB_UPDATEI();
public:
@ -140,8 +141,15 @@ public:
}
private:
template <class C>
static core_device_t &bselect(bool b, C &d1, core_device_t &d2)
{
core_device_t *h = dynamic_cast<core_device_t *>(&d1);
return b ? *h : d2;
}
};
// -----------------------------------------------------------------------------
// nld_R
// -----------------------------------------------------------------------------
@ -150,8 +158,6 @@ NETLIB_OBJECT_DERIVED(R_base, twoterm)
{
NETLIB_CONSTRUCTOR_DERIVED(R_base, twoterm)
{
enregister("1", m_P);
enregister("2", m_N);
}
public:
@ -272,8 +278,8 @@ public:
, m_C(*this, "C", 1e-6)
, m_GParallel(0.0)
{
enregister("1", m_P);
enregister("2", m_N);
//register_term("1", m_P);
//register_term("2", m_N);
}
NETLIB_TIMESTEP()
@ -380,8 +386,8 @@ public:
NETLIB_CONSTRUCTOR_DERIVED(D, twoterm)
, m_model(*this, "MODEL", "")
{
enregister("A", m_P);
enregister("K", m_N);
register_subalias("A", m_P);
register_subalias("K", m_N);
m_D.save("m_D", *this);
}
@ -415,8 +421,8 @@ public:
, m_V(*this, "V", 0.0)
{
enregister("P", m_P);
enregister("N", m_N);
register_subalias("P", m_P);
register_subalias("N", m_N);
}
protected:
@ -437,8 +443,8 @@ public:
NETLIB_CONSTRUCTOR_DERIVED(CS, twoterm)
, m_I(*this, "I", 1.0)
{
enregister("P", m_P);
enregister("N", m_N);
register_subalias("P", m_P);
register_subalias("N", m_N);
}
NETLIB_UPDATEI();

27
src/lib/netlist/devices/nld_4020.cpp
View File

@ -10,6 +10,8 @@
namespace netlist
{
namespace devices
{
@ -17,23 +19,11 @@ namespace netlist
{
NETLIB_CONSTRUCTOR(CD4020_sub)
NETLIB_FAMILY("CD4XXX")
, m_IP(*this, "IP")
, m_Q(*this, {"Q1", "_Q2", "_Q3", "Q4", "Q5", "Q6", "Q7", "Q8", "Q9",
"Q10", "Q11", "Q12", "Q13", "Q14"})
, m_cnt(0)
{
enregister("IP", m_IP);
enregister("Q1", m_Q[0]);
enregister("Q4", m_Q[3]);
enregister("Q5", m_Q[4]);
enregister("Q6", m_Q[5]);
enregister("Q7", m_Q[6]);
enregister("Q8", m_Q[7]);
enregister("Q9", m_Q[8]);
enregister("Q10", m_Q[9]);
enregister("Q11", m_Q[10]);
enregister("Q12", m_Q[11]);
enregister("Q13", m_Q[12]);
enregister("Q14", m_Q[13]);
save(NLNAME(m_cnt));
}
@ -49,7 +39,7 @@ namespace netlist
ATTR_HOT void update_outputs(const UINT16 cnt);
logic_input_t m_IP;
logic_output_t m_Q[14];
object_array_t<logic_output_t, 14> m_Q;
UINT16 m_cnt;
};
@ -60,9 +50,8 @@ namespace netlist
NETLIB_FAMILY("CD4XXX")
, m_sub(*this, "sub")
, m_supply(*this, "supply")
, m_RESET(*this, "RESET")
{
enregister("RESET", m_RESET);
register_subalias("IP", m_sub.m_IP);
register_subalias("Q1", m_sub.m_Q[0]);
register_subalias("Q4", m_sub.m_Q[3]);
@ -124,7 +113,7 @@ namespace netlist
NLTIME_FROM_NS(1380), NLTIME_FROM_NS(1480),
};
OUTLOGIC(m_Q[0], 0, out_delayQn[0]);
OUTLOGIC(m_Q[0], cnt & 1, out_delayQn[0]);
for (int i=3; i<14; i++)
OUTLOGIC(m_Q[i], (cnt >> i) & 1, out_delayQn[i]);
}

3
src/lib/netlist/devices/nld_4066.cpp
View File

@ -6,6 +6,7 @@
*/
#include <devices/nlid_cmos.h>
#include "analog/nld_twoterm.h"
#include "nld_4066.h"
namespace netlist
@ -19,9 +20,9 @@ namespace netlist
NETLIB_FAMILY("CD4XXX")
, m_supply(*this, "PS")
, m_R(*this, "R")
, m_control(*this, "CTL")
, m_base_r(*this, "BASER", 270.0)
{
enregister("CTL", m_control);
}
NETLIB_RESETI() { }

14
src/lib/netlist/devices/nld_74107.cpp
View File

@ -15,15 +15,14 @@ namespace netlist
NETLIB_OBJECT(74107Asub)
{
NETLIB_CONSTRUCTOR(74107Asub)
, m_clk(*this, "CLK")
, m_Q(*this, "Q")
, m_QQ(*this, "QQ")
, m_Q1(0)
, m_Q2(0)
, m_F(0)
{
enregister("CLK", m_clk);
enregister("Q", m_Q);
enregister("QQ", m_QQ);
save(NLNAME(m_Q1));
save(NLNAME(m_Q2));
save(NLNAME(m_F));
@ -50,12 +49,11 @@ namespace netlist
{
NETLIB_CONSTRUCTOR(74107A)
, m_sub(*this, "sub")
, m_J(*this, "J")
, m_K(*this, "K")
, m_clrQ(*this, "CLRQ")
{
register_subalias("CLK", m_sub.m_clk);
enregister("J", m_J);
enregister("K", m_K);
enregister("CLRQ", m_clrQ);
register_subalias("Q", m_sub.m_Q);
register_subalias("QQ", m_sub.m_QQ);
}

19
src/lib/netlist/devices/nld_74123.cpp
View File

@ -24,23 +24,20 @@ namespace netlist
, m_dev_type(dev_type)
, m_RP(*this, "RP")
, m_RN(*this, "RN")
, m_RP_Q(*this, "_RP_Q")
, m_RN_Q(*this, "_RN_Q")
, m_A(*this, "A")
, m_B(*this, "B")
, m_CLRQ(*this, "CLRQ")
, m_Q(*this, "Q")
, m_QQ(*this, "QQ")
, m_CV(*this, "_CV") // internal
, m_K(*this, "K", (m_dev_type == 4538) ? 0.4 : 0.4)
, m_RI(*this, "RI", 400.0) // around 250 for HC series, 400 on LS/TTL, estimated from datasheets
{
if ((m_dev_type != 9602) && (m_dev_type != 4538) )
m_dev_type = 74123;
enregister("A", m_A);
enregister("B", m_B);
enregister("CLRQ", m_CLRQ);
enregister("Q", m_Q);
enregister("QQ", m_QQ);
enregister("_RP_Q", m_RP_Q); // internal
enregister("_RN_Q", m_RN_Q); // internal
enregister("_CV", m_CV); // internal
register_subalias("GND", m_RN.m_R.m_N);
register_subalias("VCC", m_RP.m_R.m_P);
register_subalias("C", m_RN.m_R.m_N);

21
src/lib/netlist/devices/nld_74153.cpp
View File

@ -20,16 +20,11 @@ namespace netlist
NETLIB_OBJECT(74153sub)
{
NETLIB_CONSTRUCTOR(74153sub)
, m_C(*this, {"C0", "C1", "C2", "C3"})
, m_G(*this, "G")
, m_Y(*this, "AY") //FIXME: Change netlists
, m_chan(0)
{
enregister("C0", m_C[0]);
enregister("C1", m_C[1]);
enregister("C2", m_C[2]);
enregister("C3", m_C[3]);
enregister("G", m_G);
enregister("AY", m_Y); //FIXME: Change netlists
save(NLNAME(m_chan));
}
@ -37,7 +32,7 @@ namespace netlist
NETLIB_UPDATEI();
public:
logic_input_t m_C[4];
object_array_t<logic_input_t, 4> m_C;
logic_input_t m_G;
logic_output_t m_Y;
@ -49,14 +44,14 @@ namespace netlist
{
NETLIB_CONSTRUCTOR(74153)
, m_sub(*this, "sub")
, m_A(*this, "A")
, m_B(*this, "B")
{
register_subalias("C0", m_sub.m_C[0]);
register_subalias("C1", m_sub.m_C[1]);
register_subalias("C2", m_sub.m_C[2]);
register_subalias("C3", m_sub.m_C[3]);
enregister("A", m_A);
enregister("B", m_B);
register_subalias("G", m_sub.m_G);
register_subalias("AY", m_sub.m_Y); //FIXME: Change netlists
@ -74,10 +69,11 @@ namespace netlist
NETLIB_CONSTRUCTOR(74153_dip)
, m_1(*this, "1")
, m_2(*this, "2")
, m_A(*this, "14") // m_2.m_B
, m_B(*this, "2") // m_2.m_B
{
register_subalias("1", m_1.m_G);
enregister("2", m_B); // m_2.m_B
register_subalias("3", m_1.m_C[3]);
register_subalias("4", m_1.m_C[2]);
register_subalias("5", m_1.m_C[1]);
@ -90,7 +86,6 @@ namespace netlist
register_subalias("12", m_2.m_C[2]);
register_subalias("13", m_2.m_C[3]);
enregister("14", m_A); // m_2.m_B
register_subalias("15", m_2.m_G);
}

27
src/lib/netlist/devices/nld_74175.cpp
View File

@ -15,19 +15,11 @@ namespace netlist
NETLIB_OBJECT(74175_sub)
{
NETLIB_CONSTRUCTOR(74175_sub)
, m_CLK(*this, "CLK")
, m_Q(*this, {"Q1", "Q2", "Q3", "Q4"})
, m_QQ(*this, {"Q1Q", "Q2Q", "Q3Q", "Q4Q"})
, m_data(0)
{
enregister("CLK", m_CLK);
enregister("Q1", m_Q[0]);
enregister("Q1Q", m_QQ[0]);
enregister("Q2", m_Q[1]);
enregister("Q2Q", m_QQ[1]);
enregister("Q3", m_Q[2]);
enregister("Q3Q", m_QQ[2]);
enregister("Q4", m_Q[3]);
enregister("Q4Q", m_QQ[3]);
save(NLNAME(m_clrq));
save(NLNAME(m_data));
}
@ -37,8 +29,8 @@ namespace netlist
public:
logic_input_t m_CLK;
logic_output_t m_Q[4];
logic_output_t m_QQ[4];
object_array_t<logic_output_t, 4> m_Q;
object_array_t<logic_output_t, 4> m_QQ;
netlist_sig_t m_clrq;
UINT8 m_data;
@ -48,24 +40,21 @@ namespace netlist
{
NETLIB_CONSTRUCTOR(74175)
, m_sub(*this, "sub")
, m_D(*this, {"D1", "D2", "D3", "D4"})
, m_CLRQ(*this, "CLRQ")
{
register_subalias("CLK", m_sub.m_CLK);
enregister("CLRQ", m_CLRQ);
enregister("D1", m_D[0]);
register_subalias("Q1", m_sub.m_Q[0]);
register_subalias("Q1Q", m_sub.m_QQ[0]);
enregister("D2", m_D[1]);
register_subalias("Q2", m_sub.m_Q[1]);
register_subalias("Q2Q", m_sub.m_QQ[1]);
enregister("D3", m_D[2]);
register_subalias("Q3", m_sub.m_Q[2]);
register_subalias("Q3Q", m_sub.m_QQ[2]);
enregister("D4", m_D[3]);
register_subalias("Q4", m_sub.m_Q[3]);
register_subalias("Q4Q", m_sub.m_QQ[3]);
}
@ -75,7 +64,7 @@ namespace netlist
protected:
NETLIB_SUB(74175_sub) m_sub;
logic_input_t m_D[4];
object_array_t<logic_input_t, 4> m_D;
logic_input_t m_CLRQ;
};

28
src/lib/netlist/devices/nld_74192.cpp
View File

@ -17,11 +17,11 @@ namespace netlist
NETLIB_OBJECT(74192_subABCD)
{
NETLIB_CONSTRUCTOR(74192_subABCD)
, m_A(*this, "A")
, m_B(*this, "B")
, m_C(*this, "C")
, m_D(*this, "D")
{
enregister("A", m_A);
enregister("B", m_B);
enregister("C", m_C);
enregister("D", m_D);
}
NETLIB_RESETI()
@ -52,22 +52,18 @@ namespace netlist
{
NETLIB_CONSTRUCTOR(74192)
, m_ABCD(*this, "subABCD")
, m_CLEAR(*this, "CLEAR")
, m_LOADQ(*this, "LOADQ")
, m_CU(*this, "CU")
, m_CD(*this, "CD")
, m_Q(*this, {"QA", "QB", "QC", "QD"})
, m_BORROWQ(*this, "BORROWQ")
, m_CARRYQ(*this, "CARRYQ")
{
register_subalias("A", m_ABCD.m_A);
register_subalias("B", m_ABCD.m_B);
register_subalias("C", m_ABCD.m_C);
register_subalias("D", m_ABCD.m_D);
enregister("CLEAR", m_CLEAR);
enregister("LOADQ", m_LOADQ);
enregister("CU", m_CU);
enregister("CD", m_CD);
enregister("QA", m_Q[0]);
enregister("QB", m_Q[1]);
enregister("QC", m_Q[2]);
enregister("QD", m_Q[3]);
enregister("BORROWQ", m_BORROWQ);
enregister("CARRYQ", m_CARRYQ);
save(NLNAME(m_cnt));
save(NLNAME(m_last_CU));
@ -88,7 +84,7 @@ namespace netlist
UINT8 m_last_CU;
UINT8 m_last_CD;
logic_output_t m_Q[4];
object_array_t<logic_output_t, 4> m_Q;
logic_output_t m_BORROWQ;
logic_output_t m_CARRYQ;
};

28
src/lib/netlist/devices/nld_74193.cpp
View File

@ -17,25 +17,21 @@ namespace netlist
NETLIB_OBJECT(74193)
{
NETLIB_CONSTRUCTOR(74193)
, m_A(*this, "A")
, m_B(*this, "B")
, m_C(*this, "C")
, m_D(*this, "D")
, m_CLEAR(*this, "CLEAR")
, m_LOADQ(*this, "LOADQ")
, m_CU(*this, "CU")
, m_CD(*this, "CD")
, m_cnt(0)
, m_last_CU(0)
, m_last_CD(0)
, m_Q(*this, {"QA", "QB", "QC", "QD"})
, m_BORROWQ(*this, "BORROWQ")
, m_CARRYQ(*this, "CARRYQ")
{
enregister("A", m_A);
enregister("B", m_B);
enregister("C", m_C);
enregister("D", m_D);
enregister("CLEAR", m_CLEAR);
enregister("LOADQ", m_LOADQ);
enregister("CU", m_CU);
enregister("CD", m_CD);
enregister("QA", m_Q[0]);
enregister("QB", m_Q[1]);
enregister("QC", m_Q[2]);
enregister("QD", m_Q[3]);
enregister("BORROWQ", m_BORROWQ);
enregister("CARRYQ", m_CARRYQ);
save(NLNAME(m_cnt));
save(NLNAME(m_last_CU));
@ -59,7 +55,7 @@ namespace netlist
UINT8 m_last_CU;
UINT8 m_last_CD;
logic_output_t m_Q[4];
object_array_t<logic_output_t, 4> m_Q;
logic_output_t m_BORROWQ;
logic_output_t m_CARRYQ;
};

26
src/lib/netlist/devices/nld_7448.cpp
View File

@ -28,24 +28,16 @@ namespace netlist
NETLIB_OBJECT(7448)
{
NETLIB_CONSTRUCTOR(7448)
, m_A(*this, "A")
, m_B(*this, "B")
, m_C(*this, "C")
, m_D(*this, "D")
, m_LTQ(*this, "LTQ")
, m_BIQ(*this, "BIQ")
, m_RBIQ(*this, "RBIQ")
, m_state(0)
, m_Q(*this, {"a", "b", "c", "d", "e", "f", "g"})
{
enregister("A", m_A);
enregister("B", m_B);
enregister("C", m_C);
enregister("D", m_D);
enregister("LTQ", m_LTQ);
enregister("BIQ", m_BIQ);
enregister("RBIQ", m_RBIQ);
enregister("a", m_Q[0]);
enregister("b", m_Q[1]);
enregister("c", m_Q[2]);
enregister("d", m_Q[3]);
enregister("e", m_Q[4]);
enregister("f", m_Q[5]);
enregister("g", m_Q[6]);
save(NLNAME(m_state));
}
@ -66,7 +58,7 @@ namespace netlist
UINT8 m_state;
logic_output_t m_Q[7]; /* a .. g */
object_array_t<logic_output_t, 7> m_Q; /* a .. g */
};

10
src/lib/netlist/devices/nld_7450.cpp
View File

@ -15,12 +15,12 @@ namespace netlist
NETLIB_OBJECT(7450)
{
NETLIB_CONSTRUCTOR(7450)
, m_A(*this, "A")
, m_B(*this, "B")
, m_C(*this, "C")
, m_D(*this, "D")
, m_Q(*this, "Q")
{
enregister("A", m_A);
enregister("B", m_B);
enregister("C", m_C);
enregister("D", m_D);
enregister("Q", m_Q);
}
//NETLIB_RESETI();
NETLIB_UPDATEI();

13
src/lib/netlist/devices/nld_7474.cpp
View File

@ -15,12 +15,11 @@ namespace netlist
NETLIB_OBJECT(7474sub)
{
NETLIB_CONSTRUCTOR(7474sub)
, m_CLK(*this, "CLK")
, m_Q(*this, "Q")
, m_QQ(*this, "QQ")
, m_nextD(0)
{
enregister("CLK", m_CLK);
enregister("Q", m_Q);
enregister("QQ", m_QQ);
save(NLNAME(m_nextD));
}
@ -44,11 +43,11 @@ namespace netlist
{
NETLIB_CONSTRUCTOR(7474)
, sub(*this, "sub")
, m_D(*this, "D")
, m_CLRQ(*this, "CLRQ")
, m_PREQ(*this, "PREQ")
{
register_subalias("CLK", sub.m_CLK);
enregister("D", m_D);
enregister("CLRQ", m_CLRQ);
enregister("PREQ", m_PREQ);
register_subalias("Q", sub.m_Q);
register_subalias("QQ", sub.m_QQ);

30
src/lib/netlist/devices/nld_7483.cpp
View File

@ -15,24 +15,22 @@ namespace netlist
NETLIB_OBJECT(7483)
{
NETLIB_CONSTRUCTOR(7483)
, m_C0(*this, "C0")
, m_A1(*this, "A1")
, m_A2(*this, "A2")
, m_A3(*this, "A3")
, m_A4(*this, "A4")
, m_B1(*this, "B1")
, m_B2(*this, "B2")
, m_B3(*this, "B3")
, m_B4(*this, "B4")
, m_lastr(0)
, m_S1(*this, "S1")
, m_S2(*this, "S2")
, m_S3(*this, "S3")
, m_S4(*this, "S4")
, m_C4(*this, "C4")
{
enregister("A1", m_A1);
enregister("A2", m_A2);
enregister("A3", m_A3);
enregister("A4", m_A4);
enregister("B1", m_B1);
enregister("B2", m_B2);
enregister("B3", m_B3);
enregister("B4", m_B4);
enregister("C0", m_C0);
enregister("S1", m_S1);
enregister("S2", m_S2);
enregister("S3", m_S3);
enregister("S4", m_S4);
enregister("C4", m_C4);
save(NLNAME(m_lastr));
}
NETLIB_RESETI();

25
src/lib/netlist/devices/nld_7490.cpp
View File

@ -15,22 +15,17 @@ namespace netlist
NETLIB_OBJECT(7490)
{
NETLIB_CONSTRUCTOR(7490)
, m_A(*this, "A")
, m_B(*this, "B")
, m_R1(*this, "R1")
, m_R2(*this, "R2")
, m_R91(*this, "R91")
, m_R92(*this, "R92")
, m_cnt(0)
, m_last_A(0)
, m_last_B(0)
, m_Q(*this, {"QA", "QB", "QC", "QD"})
{
enregister("A", m_A);
enregister("B", m_B);
enregister("R1", m_R1);
enregister("R2", m_R2);
enregister("R91", m_R91);
enregister("R92", m_R92);
enregister("QA", m_Q[0]);
enregister("QB", m_Q[1]);
enregister("QC", m_Q[2]);
enregister("QD", m_Q[3]);
save(NLNAME(m_cnt));
save(NLNAME(m_last_A));
save(NLNAME(m_last_B));
@ -42,18 +37,18 @@ namespace netlist
protected:
ATTR_HOT void update_outputs();
logic_input_t m_A;
logic_input_t m_B;
logic_input_t m_R1;
logic_input_t m_R2;
logic_input_t m_R91;
logic_input_t m_R92;
logic_input_t m_A;
logic_input_t m_B;
UINT8 m_cnt;
UINT8 m_last_A;
UINT8 m_last_B;
logic_output_t m_Q[4];
object_array_t<logic_output_t, 4> m_Q;
};
NETLIB_OBJECT_DERIVED(7490_dip, 7490)

8
src/lib/netlist/devices/nld_7493.cpp
View File

@ -17,9 +17,9 @@ namespace netlist
NETLIB_OBJECT(7493ff)
{
NETLIB_CONSTRUCTOR(7493ff)
, m_I(*this, "CLK")
, m_Q(*this, "Q")
{
enregister("CLK", m_I);
enregister("Q", m_Q);
save(NLNAME(m_reset));
save(NLNAME(m_state));
@ -39,6 +39,8 @@ namespace netlist
NETLIB_OBJECT(7493)
{
NETLIB_CONSTRUCTOR(7493)
, m_R1(*this, "R1")
, m_R2(*this, "R2")
, A(*this, "A")
, B(*this, "B")
, C(*this, "C")
@ -46,8 +48,6 @@ namespace netlist
{
register_subalias("CLKA", A.m_I);
register_subalias("CLKB", B.m_I);
enregister("R1", m_R1);
enregister("R2", m_R2);
register_subalias("QA", A.m_Q);
register_subalias("QB", B.m_Q);

11
src/lib/netlist/devices/nld_74ls629.cpp
View File

@ -50,13 +50,12 @@ namespace netlist
NETLIB_OBJECT(SN74LS629clk)
{
NETLIB_CONSTRUCTOR(SN74LS629clk)
, m_FB(*this, "FB")
, m_Y(*this, "Y")
, m_enableq(1)
, m_out(0)
, m_inc(netlist_time::zero)
{
enregister("FB", m_FB);
enregister("Y", m_Y);
connect_late(m_FB, m_Y);
save(NLNAME(m_enableq));
@ -88,11 +87,11 @@ namespace netlist
, m_clock(*this, "OSC")
, m_R_FC(*this, "R_FC")
, m_R_RNG(*this, "R_RNG")
, m_ENQ(*this, "ENQ")
, m_RNG(*this, "RNG")
, m_FC(*this, "FC")
, m_CAP(*this, "CAP", 1e-6)
{
enregister("ENQ", m_ENQ);
enregister("RNG", m_RNG);
enregister("FC", m_FC);
register_subalias("GND", m_R_FC.m_N);
connect_late(m_FC, m_R_FC.m_P);

56
src/lib/netlist/devices/nld_82S16.cpp
View File

@ -15,34 +15,22 @@ namespace netlist
NETLIB_OBJECT(82S16)
{
NETLIB_CONSTRUCTOR(82S16)
, m_A(*this, { "A0", "A1", "A2", "A3", "A4", "A5", "A6", "A7" })
, m_CE1Q(*this, "CE1Q")
, m_CE2Q(*this, "CE2Q")
, m_CE3Q(*this, "CE3Q")
, m_WEQ(*this, "WEQ")
, m_DIN(*this, "DIN")
, m_DOUTQ(*this, "DOUTQ")
{
enregister("A0", m_A[0]);
enregister("A1", m_A[1]);
enregister("A2", m_A[2]);
enregister("A3", m_A[3]);
enregister("A4", m_A[4]);
enregister("A5", m_A[5]);
enregister("A6", m_A[6]);
enregister("A7", m_A[7]);
enregister("CE1Q", m_CE1Q);
enregister("CE2Q", m_CE2Q);
enregister("CE3Q", m_CE3Q);
enregister("WEQ", m_WEQ);
enregister("DIN", m_DIN);
enregister("DOUTQ",m_DOUTQ);
save(NLNAME(m_ram));
}
NETLIB_RESETI();
NETLIB_UPDATEI();
protected:
logic_input_t m_A[8];
object_array_t<logic_input_t, 8> m_A;
logic_input_t m_CE1Q;
logic_input_t m_CE2Q;
logic_input_t m_CE3Q;
@ -58,23 +46,23 @@ namespace netlist
{
NETLIB_CONSTRUCTOR_DERIVED(82S16_dip, 82S16)
{
enregister("2", m_A[0]);
enregister("1", m_A[1]);
enregister("15", m_A[2]);
enregister("14", m_A[3]);
enregister("7", m_A[4]);
enregister("9", m_A[5]);
enregister("10", m_A[6]);
enregister("11", m_A[7]);
register_subalias("2", m_A[0]);
register_subalias("1", m_A[1]);
register_subalias("15", m_A[2]);
register_subalias("14", m_A[3]);
register_subalias("7", m_A[4]);
register_subalias("9", m_A[5]);
register_subalias("10", m_A[6]);
register_subalias("11", m_A[7]);
enregister("3", m_CE1Q);
enregister("4", m_CE2Q);
enregister("5", m_CE3Q);
register_subalias("3", m_CE1Q);
register_subalias("4", m_CE2Q);
register_subalias("5", m_CE3Q);
enregister("12", m_WEQ);
enregister("13", m_DIN);
register_subalias("12", m_WEQ);
register_subalias("13", m_DIN);
enregister("6", m_DOUTQ);
register_subalias("6", m_DOUTQ);
}
};

38
src/lib/netlist/devices/nld_9310.cpp
View File

@ -17,11 +17,11 @@ namespace netlist
NETLIB_OBJECT(9310_subABCD)
{
NETLIB_CONSTRUCTOR(9310_subABCD)
, m_A(*this, "A")
, m_B(*this, "B")
, m_C(*this, "C")
, m_D(*this, "D")
{
enregister("A", m_A);
enregister("B", m_B);
enregister("C", m_C);
enregister("D", m_D);
}
NETLIB_RESETI();
@ -43,19 +43,17 @@ namespace netlist
NETLIB_OBJECT(9310_sub)
{
NETLIB_CONSTRUCTOR(9310_sub)
, m_cnt(0)
, m_CLK(*this, "CLK")
, m_ABCD(nullptr)
, m_QA(*this, "QA")
, m_QB(*this, "QB")
, m_QC(*this, "QC")
, m_QD(*this, "QD")
, m_RC(*this, "RC")
, m_cnt(0)
, m_loadq(0)
, m_ent(0)
{
enregister("CLK", m_CLK);
enregister("QA", m_QA);
enregister("QB", m_QB);
enregister("QC", m_QC);
enregister("QD", m_QD);
enregister("RC", m_RC);
save(NLNAME(m_cnt));
save(NLNAME(m_loadq));
save(NLNAME(m_ent));
@ -68,16 +66,16 @@ namespace netlist
logic_input_t m_CLK;
UINT8 m_cnt;
NETLIB_NAME(9310_subABCD) *m_ABCD;
netlist_sig_t m_loadq;
netlist_sig_t m_ent;
logic_output_t m_QA;
logic_output_t m_QB;
logic_output_t m_QC;
logic_output_t m_QD;
logic_output_t m_RC;
UINT8 m_cnt;
netlist_sig_t m_loadq;
netlist_sig_t m_ent;
};
NETLIB_OBJECT(9310)
@ -85,15 +83,15 @@ namespace netlist
NETLIB_CONSTRUCTOR(9310)
, subABCD(*this, "subABCD")
, sub(*this, "sub")
, m_ENP(*this, "ENP")
, m_ENT(*this, "ENT")
, m_CLRQ(*this, "CLRQ")
, m_LOADQ(*this, "LOADQ")
{
sub.m_ABCD = &(subABCD);
register_subalias("CLK", sub.m_CLK);
enregister("ENP", m_ENP);
enregister("ENT", m_ENT);
enregister("CLRQ", m_CLRQ);
enregister("LOADQ", m_LOADQ);
register_subalias("A", subABCD.m_A);
register_subalias("B", subABCD.m_B);

30
src/lib/netlist/devices/nld_9316.cpp
View File

@ -17,11 +17,11 @@ namespace netlist
NETLIB_OBJECT(9316_subABCD)
{
NETLIB_CONSTRUCTOR(9316_subABCD)
, m_A(*this, "A")
, m_B(*this, "B")
, m_C(*this, "C")
, m_D(*this, "D")
{
enregister("A", m_A);
enregister("B", m_B);
enregister("C", m_C);
enregister("D", m_D);
}
NETLIB_RESETI()
@ -51,18 +51,17 @@ namespace netlist
NETLIB_OBJECT(9316_sub)
{
NETLIB_CONSTRUCTOR(9316_sub)
, m_CLK(*this, "CLK")
, m_QA(*this, "QA")
, m_QB(*this, "QB")
, m_QC(*this, "QC")
, m_QD(*this, "QD")
, m_RC(*this, "RC")
, m_cnt(0)
, m_ABCD(nullptr)
, m_loadq(0)
, m_ent(0)
{
enregister("CLK", m_CLK);
enregister("QA", m_QA);
enregister("QB", m_QB);
enregister("QC", m_QC);
enregister("QD", m_QD);
enregister("RC", m_RC);
save(NLNAME(m_cnt));
save(NLNAME(m_loadq));
@ -95,16 +94,15 @@ namespace netlist
NETLIB_CONSTRUCTOR(9316)
, sub(*this, "sub")
, subABCD(*this, "subABCD")
, m_ENP(*this, "ENP")
, m_ENT(*this, "ENT")
, m_CLRQ(*this, "CLRQ")
, m_LOADQ(*this, "LOADQ")
{
sub.m_ABCD = &(subABCD);
register_subalias("CLK", sub.m_CLK);
enregister("ENP", m_ENP);
enregister("ENT", m_ENT);
enregister("CLRQ", m_CLRQ);
enregister("LOADQ", m_LOADQ);
register_subalias("A", subABCD.m_A);
register_subalias("B", subABCD.m_B);
register_subalias("C", subABCD.m_C);

14
src/lib/netlist/devices/nld_legacy.cpp
View File

@ -16,11 +16,11 @@ namespace netlist
NETLIB_OBJECT(nicRSFF)
{
NETLIB_CONSTRUCTOR(nicRSFF)
, m_S(*this, "S")
, m_R(*this, "R")
, m_Q(*this, "Q")
, m_QQ(*this, "QQ")
{
enregister("S", m_S);
enregister("R", m_R);
enregister("Q", m_Q);
enregister("QQ", m_QQ);
}
NETLIB_RESETI();
@ -38,13 +38,12 @@ namespace netlist
NETLIB_OBJECT(nicDelay)
{
NETLIB_CONSTRUCTOR(nicDelay)
, m_I(*this, "1")
, m_Q(*this, "2")
, m_L_to_H(*this, "L_TO_H", 10)
, m_H_to_L(*this, "H_TO_L", 10)
, m_last(0)
{
enregister("1", m_I);
enregister("2", m_Q);
save(NLNAME(m_last));
}
@ -54,7 +53,6 @@ namespace netlist
protected:
logic_input_t m_I;
logic_output_t m_Q;
param_int_t m_L_to_H;

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

@ -20,8 +20,8 @@ namespace netlist
NETLIB_OBJECT(log)
{
NETLIB_CONSTRUCTOR(log)
, m_I(*this, "I")
{
enregister("I", m_I);
pstring filename = plib::pfmt("{1}.log")(this->name());
m_strm = plib::make_unique<plib::pofilestream>(filename);
@ -42,8 +42,8 @@ namespace netlist
NETLIB_OBJECT_DERIVED(logD, log)
{
NETLIB_CONSTRUCTOR_DERIVED(logD, log)
, m_I2(*this, "I2")
{
enregister("I2", m_I2);
}
NETLIB_UPDATEI()

18
src/lib/netlist/devices/nld_mm5837.cpp
View File

@ -21,25 +21,25 @@ namespace netlist
{
NETLIB_CONSTRUCTOR(MM5837_dip)
, m_RV(*this, "RV")
, m_VDD(*this, "1")
, m_VGG(*this, "2")
, m_VSS(*this, "4")
, m_V0(*this, "_Q")
/* clock */
, m_feedback(*this, "FB")
, m_Q(*this, "Q")
, m_is_timestep(false)
{
/* clock */
enregister("Q", m_Q);
enregister("FB", m_feedback);
m_inc = netlist_time::from_hz(56000);
connect_late(m_feedback, m_Q);
/* output */
enregister("_RV1", m_RV.m_P);
enregister("_RV2", m_RV.m_N);
enregister("_Q", m_V0);
//register_term("_RV1", m_RV.m_P);
//register_term("_RV2", m_RV.m_N);
connect_late(m_RV.m_N, m_V0);
/* device */
enregister("1", m_VDD);
enregister("2", m_VGG);
register_subalias("3", m_RV.m_P);
enregister("4", m_VSS);
save(NLNAME(m_shift));

8
src/lib/netlist/devices/nld_ne555.cpp
View File

@ -24,16 +24,16 @@ namespace netlist
, m_R2(*this, "R2")
, m_R3(*this, "R3")
, m_RDIS(*this, "RDIS")
, m_RESET(*this, "RESET") // Pin 4
, m_THRES(*this, "THRESH") // Pin 6
, m_TRIG(*this, "TRIG") // Pin 2
, m_OUT(*this, "OUT") // Pin 3
, m_last_out(false)
, m_ff(false)
{
register_subalias("GND", m_R3.m_N); // Pin 1
enregister("TRIG", m_TRIG); // Pin 2
enregister("OUT", m_OUT); // Pin 3
enregister("RESET", m_RESET); // Pin 4
register_subalias("CONT", m_R1.m_N); // Pin 5
enregister("THRESH", m_THRES); // Pin 6
register_subalias("DISCH", m_RDIS.m_P); // Pin 7
register_subalias("VCC", m_R1.m_P); // Pin 8

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

@ -21,8 +21,8 @@ namespace netlist
, m_num(*this, "N", 1)
, m_val(*this, "VAL", 1)
{
enregister("VOUT", m_P);
enregister("VGND", m_N);
register_subalias("VOUT", m_P);
register_subalias("VGND", m_N);
}
NETLIB_UPDATE_PARAMI();

9
src/lib/netlist/devices/nld_truthtable.h
View File

@ -165,15 +165,16 @@ public:
for (unsigned i=0; i < m_NI; i++)
{
new (&m_I[i]) logic_input_t();
//new (&m_I[i]) logic_input_t();
inout[i] = inout[i].trim();
enregister(inout[i], m_I[i]);
m_I.emplace(i, *this, inout[i]);
}
for (unsigned i=0; i < m_NO; i++)
{
new (&m_Q[i]) logic_output_t();
//new (&m_Q[i]) logic_output_t();
out[i] = out[i].trim();
enregister(out[i], m_Q[i]);
m_Q.emplace(i, *this, out[i]);
//enregister(out[i], m_Q[i]);
}
// Connect output "Q" to input "_Q" if this exists
// This enables timed state without having explicit state ....

5
src/lib/netlist/devices/nlid_cmos.h
View File

@ -9,7 +9,6 @@
#define NLID_CMOS_H_
#include "nl_base.h"
#include "analog/nld_twoterm.h"
namespace netlist
{
@ -19,9 +18,9 @@ namespace netlist
NETLIB_OBJECT(vdd_vss)
{
NETLIB_CONSTRUCTOR(vdd_vss)
, m_vdd(*this, "VDD")
, m_vss(*this, "VSS")
{
enregister("VDD", m_vdd);
enregister("VSS", m_vss);
}
NETLIB_UPDATEI() {};

66
src/lib/netlist/devices/nlid_system.h
View File

@ -45,9 +45,9 @@ namespace netlist
NETLIB_OBJECT(mainclock)
{
NETLIB_CONSTRUCTOR(mainclock)
, m_Q(*this, "Q")
, m_freq(*this, "FREQ", 7159000.0 * 5)
{
enregister("Q", m_Q);
m_inc = netlist_time::from_hz(m_freq.Value()*2);
}
@ -86,11 +86,10 @@ namespace netlist
NETLIB_OBJECT(clock)
{
NETLIB_CONSTRUCTOR(clock)
, m_feedback(*this, "FB")
, m_Q(*this, "Q")
, m_freq(*this, "FREQ", 7159000.0 * 5.0)
{
enregister("Q", m_Q);
enregister("FB", m_feedback);
m_inc = netlist_time::from_hz(m_freq.Value()*2);
@ -118,10 +117,9 @@ namespace netlist
, m_freq(*this, "FREQ", 7159000.0 * 5.0)
, m_pattern(*this, "PATTERN", "1,1")
, m_offset(*this, "OFFSET", 0.0)
, m_feedback(*this, "FB")
, m_Q(*this, "Q")
{
enregister("Q", m_Q);
enregister("FB", m_feedback);
m_inc[0] = netlist_time::from_hz(m_freq.Value()*2);
connect_late(m_feedback, m_Q);
@ -173,14 +171,14 @@ namespace netlist
NETLIB_OBJECT(logic_input)
{
NETLIB_CONSTRUCTOR(logic_input)
, m_Q(*this, "Q")
, m_IN(*this, "IN", 0)
/* make sure we get the family first */
, m_FAMILY(*this, "FAMILY", "FAMILY(TYPE=TTL)")
{
set_logic_family(netlist().setup().family_from_model(m_FAMILY.Value()));
enregister("Q", m_Q);
}
NETLIB_UPDATE_AFTER_PARAM_CHANGE()
NETLIB_UPDATEI();
@ -197,9 +195,9 @@ namespace netlist
NETLIB_OBJECT(analog_input)
{
NETLIB_CONSTRUCTOR(analog_input)
, m_Q(*this, "Q")
, m_IN(*this, "IN", 0.0)
{
enregister("Q", m_Q);
}
NETLIB_UPDATE_AFTER_PARAM_CHANGE()
@ -218,8 +216,8 @@ namespace netlist
NETLIB_OBJECT(gnd)
{
NETLIB_CONSTRUCTOR(gnd)
, m_Q(*this, "Q")
{
enregister("Q", m_Q);
}
NETLIB_UPDATEI()
{
@ -238,8 +236,8 @@ namespace netlist
{
public:
NETLIB_CONSTRUCTOR_DERIVED(dummy_input, base_dummy)
, m_I(*this, "I")
{
enregister("I", m_I);
}
protected:
@ -260,20 +258,20 @@ namespace netlist
{
public:
NETLIB_CONSTRUCTOR_DERIVED(frontier, base_dummy)
, m_RIN(netlist(), "m_RIN")
, m_ROUT(netlist(), "m_ROUT")
, m_RIN(*this, "m_RIN")
, m_ROUT(*this, "m_ROUT", true)
, m_I(*this, "_I")
, m_Q(*this, "_Q")
, m_p_RIN(*this, "RIN", 1.0e6)
, m_p_ROUT(*this, "ROUT", 50.0)
{
enregister("_I", m_I);
enregister("I",m_RIN.m_P);
enregister("G",m_RIN.m_N);
register_subalias("I", m_RIN.m_P);
register_subalias("G", m_RIN.m_N);
connect_late(m_I, m_RIN.m_P);
enregister("_Q", m_Q);
enregister("_OP",m_ROUT.m_P);
enregister("Q",m_ROUT.m_N);
register_subalias("_OP", m_ROUT.m_P);
register_subalias("Q", m_ROUT.m_N);
connect_late(m_Q, m_ROUT.m_P);
}
@ -290,6 +288,7 @@ namespace netlist
private:
NETLIB_NAME(twoterm) m_RIN;
/* Fixme: only works if the device is time-stepped - need to rework */
NETLIB_NAME(twoterm) m_ROUT;
analog_input_t m_I;
analog_output_t m_Q;
@ -309,11 +308,11 @@ namespace netlist
NETLIB_CONSTRUCTOR(function)
, m_N(*this, "N", 2)
, m_func(*this, "FUNC", "")
, m_Q(*this, "Q")
{
enregister("Q", m_Q);
for (int i=0; i < m_N; i++)
enregister(plib::pfmt("A{1}")(i), m_I[i]);
m_I.emplace(i, *this, plib::pfmt("A{1}")(i));
plib::pstring_vector_t cmds(m_func.Value(), " ");
m_precompiled.clear();
@ -376,7 +375,7 @@ namespace netlist
param_int_t m_N;
param_str_t m_func;
analog_output_t m_Q;
analog_input_t m_I[10];
plib::uninitialised_array_t<analog_input_t, 10> m_I;
plib::pvector_t<rpn_inst> m_precompiled;
};
@ -390,12 +389,11 @@ namespace netlist
public:
NETLIB_CONSTRUCTOR(res_sw)
, m_R(*this, "R")
, m_I(*this, "I")
, m_RON(*this, "RON", 1.0)
, m_ROFF(*this, "ROFF", 1.0E20)
, m_last_state(0)
{
enregister("I", m_I);
register_subalias("1", m_R.m_P);
register_subalias("2", m_R.m_N);
@ -462,9 +460,9 @@ namespace netlist
public:
nld_a_to_d_proxy(netlist_t &anetlist, const pstring &name, logic_input_t *in_proxied)
: nld_base_proxy(anetlist, name, in_proxied, &m_I)
, m_I(*this, "I")
, m_Q(*this, "Q")
{
enregister("I", m_I);
enregister("Q", m_Q);
}
virtual ~nld_a_to_d_proxy() {}
@ -503,9 +501,9 @@ namespace netlist
protected:
nld_base_d_to_a_proxy(netlist_t &anetlist, const pstring &name, logic_output_t *out_proxied, core_terminal_t &proxy_out)
: nld_base_proxy(anetlist, name, out_proxied, &proxy_out)
: nld_base_proxy(anetlist, name, out_proxied, &proxy_out)
, m_I(*this, "I")
{
enregister("I", m_I);
}
logic_input_t m_I;
@ -518,18 +516,18 @@ namespace netlist
public:
nld_d_to_a_proxy(netlist_t &anetlist, const pstring &name, logic_output_t *out_proxied)
: nld_base_d_to_a_proxy(anetlist, name, out_proxied, m_RV.m_P)
, m_GNDHack(*this, "_Q")
, m_RV(*this, "RV")
, m_last_state(-1)
, m_is_timestep(false)
{
//register_sub(m_RV);
enregister("1", m_RV.m_P);
enregister("2", m_RV.m_N);
//register_term("1", m_RV.m_P);
//register_term("2", m_RV.m_N);
enregister("_Q", m_Q);
register_subalias("Q", m_RV.m_P);
connect_late(m_RV.m_N, m_Q);
connect_late(m_RV.m_N, m_GNDHack);
save(NLNAME(m_last_state));
}
@ -542,7 +540,7 @@ namespace netlist
NETLIB_UPDATEI();
private:
analog_output_t m_Q;
analog_output_t m_GNDHack; // FIXME: LOng term, we need to connect proxy gnd to device gnd
NETLIB_SUB(twoterm) m_RV;
int m_last_state;
bool m_is_timestep;

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

@ -154,16 +154,6 @@ void queue_t::on_post_load()
// object_t
// ----------------------------------------------------------------------------------------
ATTR_COLD object_t::object_t(const type_t atype)
: m_objtype(atype)
, m_netlist(nullptr)
{}
ATTR_COLD object_t::object_t(netlist_t &nl, const type_t atype)
: m_objtype(atype)
, m_netlist(&nl)
{}
ATTR_COLD object_t::object_t(netlist_t &nl, const pstring &aname, const type_t atype)
: m_name(aname)
, m_objtype(atype)
@ -175,17 +165,8 @@ ATTR_COLD object_t::~object_t()
{
}
ATTR_COLD void object_t::init_object(netlist_t &nl, const pstring &aname)
{
m_netlist = &nl;
m_name = aname;
save_register();
}
ATTR_COLD const pstring &object_t::name() const
{
if (m_name == "")
netlist().log().fatal("object not initialized");
return m_name;
}
@ -193,18 +174,12 @@ ATTR_COLD const pstring &object_t::name() const
// device_object_t
// ----------------------------------------------------------------------------------------
ATTR_COLD device_object_t::device_object_t(const type_t atype)
: object_t(atype)
, m_device(nullptr)
ATTR_COLD device_object_t::device_object_t(core_device_t &dev, const pstring &aname, const type_t atype)
: object_t(dev.netlist(), aname, atype)
, m_device(&dev)
{
}
ATTR_COLD void device_object_t::init_object(core_device_t &dev,
const pstring &aname)
{
object_t::init_object(dev.netlist(), aname);
m_device = &dev;
}
// ----------------------------------------------------------------------------------------
// netlist_t
@ -443,32 +418,12 @@ template class param_template_t<int, param_t::LOGIC>;
template class param_template_t<pstring, param_t::STRING>;
template class param_template_t<pstring, param_t::MODEL>;
#if 0
template <class C, class T>
ATTR_COLD void device_t::register_param(const pstring &sname, C &param, const T initialVal)
{
pstring fullname = this->name() + "." + sname;
param.init_object(*this, fullname);
param.initial(initialVal);
setup().register_object(*this, fullname, param);
}
template ATTR_COLD void device_t::register_param(const pstring &sname, param_double_t &param, const double initialVal);
template ATTR_COLD void device_t::register_param(const pstring &sname, param_double_t &param, const float initialVal);
template ATTR_COLD void device_t::register_param(const pstring &sname, param_int_t &param, const int initialVal);
template ATTR_COLD void device_t::register_param(const pstring &sname, param_logic_t &param, const int initialVal);
template ATTR_COLD void device_t::register_param(const pstring &sname, param_str_t &param, const char * const initialVal);
template ATTR_COLD void device_t::register_param(const pstring &sname, param_str_t &param, const pstring &initialVal);
template ATTR_COLD void device_t::register_param(const pstring &sname, param_model_t &param, const char * const initialVal);
#endif
// ----------------------------------------------------------------------------------------
// core_device_t
// ----------------------------------------------------------------------------------------
ATTR_COLD core_device_t::core_device_t(netlist_t &owner, const pstring &name)
: object_t(DEVICE), logic_family_t()
: object_t(owner, name, DEVICE), logic_family_t()
#if (NL_KEEP_STATISTICS)
, stat_total_time(0)
, stat_update_count(0)
@ -477,11 +432,11 @@ ATTR_COLD core_device_t::core_device_t(netlist_t &owner, const pstring &name)
{
if (logic_family() == nullptr)
set_logic_family(family_TTL());
init_object(owner, name);
}
ATTR_COLD core_device_t::core_device_t(core_device_t &owner, const pstring &name)
: object_t(DEVICE), logic_family_t()
: object_t(owner.netlist(), owner.name() + "." + name, DEVICE)
, logic_family_t()
#if (NL_KEEP_STATISTICS)
, stat_total_time(0)
, stat_update_count(0)
@ -491,7 +446,6 @@ ATTR_COLD 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());
init_object(owner.netlist(), owner.name() + "." + name);
owner.netlist().m_devices.push_back(plib::owned_ptr<core_device_t>(this, false));
}
@ -576,7 +530,7 @@ ATTR_COLD void device_t::register_subalias(const pstring &name, const pstring &a
ATTR_COLD void device_t::register_p(const pstring &name, object_t &obj)
{
setup().register_object(*this, name, obj);
setup().register_object(obj);
}
ATTR_COLD void device_t::connect_late(core_terminal_t &t1, core_terminal_t &t2)
@ -617,8 +571,15 @@ family_setter_t::family_setter_t(core_device_t &dev, const logic_family_desc_t *
// net_t
// ----------------------------------------------------------------------------------------
ATTR_COLD net_t::net_t()
: object_t(NET)
// FIXME: move somewhere central
struct do_nothing_deleter{
template<typename T> void operator()(T*){}
};
ATTR_COLD net_t::net_t(netlist_t &nl, const pstring &aname, core_terminal_t *mr)
: object_t(nl, aname, NET)
, m_new_Q(0)
, m_cur_Q (0)
, m_railterminal(nullptr)
@ -627,28 +588,23 @@ ATTR_COLD net_t::net_t()
, m_in_queue(2)
, m_cur_Analog(0.0)
{
}
ATTR_COLD net_t::~net_t()
{
if (isInitialized())
netlist().remove_save_items(this);
}
// FIXME: move somewhere central
struct do_nothing_deleter{
template<typename T> void operator()(T*){}
};
ATTR_COLD void net_t::init_object(netlist_t &nl, const pstring &aname, core_terminal_t *mr)
{
object_t::init_object(nl, aname);
m_railterminal = mr;
if (mr != nullptr)
nl.m_nets.push_back(std::shared_ptr<net_t>(this, do_nothing_deleter()));
else
nl.m_nets.push_back(std::shared_ptr<net_t>(this));
save(NLNAME(m_time));
save(NLNAME(m_active));
save(NLNAME(m_in_queue));
save(NLNAME(m_cur_Analog));
save(NLNAME(m_cur_Q));
save(NLNAME(m_new_Q));
}
ATTR_COLD net_t::~net_t()
{
netlist().remove_save_items(this);
}
ATTR_HOT void net_t::inc_active(core_terminal_t &term)
@ -705,17 +661,6 @@ ATTR_COLD void net_t::rebuild_list()
m_active = cnt;
}
ATTR_COLD void net_t::save_register()
{
save(NLNAME(m_time));
save(NLNAME(m_active));
save(NLNAME(m_in_queue));
save(NLNAME(m_cur_Analog));
save(NLNAME(m_cur_Q));
save(NLNAME(m_new_Q));
object_t::save_register();
}
ATTR_HOT /* inline */ void net_t::update_devs()
{
//assert(m_num_cons != 0);
@ -820,8 +765,8 @@ ATTR_COLD void net_t::merge_net(net_t *othernet)
// logic_net_t
// ----------------------------------------------------------------------------------------
ATTR_COLD logic_net_t::logic_net_t()
: net_t()
ATTR_COLD logic_net_t::logic_net_t(netlist_t &nl, const pstring &aname, core_terminal_t *mr)
: net_t(nl, aname, mr)
{
}
@ -831,38 +776,21 @@ ATTR_COLD void logic_net_t::reset()
net_t::reset();
}
ATTR_COLD void logic_net_t::save_register()
{
net_t::save_register();
}
// ----------------------------------------------------------------------------------------
// analog_net_t
// ----------------------------------------------------------------------------------------
ATTR_COLD analog_net_t::analog_net_t()
: net_t()
ATTR_COLD analog_net_t::analog_net_t(netlist_t &nl, const pstring &aname, core_terminal_t *mr)
: net_t(nl, aname, mr)
, m_solver(nullptr)
{
}
ATTR_COLD analog_net_t::analog_net_t(netlist_t &nl, const pstring &aname)
: net_t()
, m_solver(nullptr)
{
init_object(nl, aname);
}
ATTR_COLD void analog_net_t::reset()
{
net_t::reset();
}
ATTR_COLD void analog_net_t::save_register()
{
net_t::save_register();
}
ATTR_COLD bool analog_net_t::already_processed(plib::pvector_t<list_t> &groups)
{
if (isRailNet())
@ -898,12 +826,13 @@ ATTR_COLD void analog_net_t::process_net(plib::pvector_t<list_t> &groups)
// core_terminal_t
// ----------------------------------------------------------------------------------------
ATTR_COLD core_terminal_t::core_terminal_t(const type_t atype)
: device_object_t(atype)
ATTR_COLD core_terminal_t::core_terminal_t(core_device_t &dev, const pstring &aname, const type_t atype)
: device_object_t(dev, dev.name() + "." + aname, atype)
, plinkedlist_element_t()
, m_net(nullptr)
, m_state(STATE_NONEX)
{
save(NLNAME(m_state));
}
ATTR_COLD void core_terminal_t::set_net(net_t::ptr_t anet)
@ -921,13 +850,17 @@ ATTR_COLD void core_terminal_t::clear_net()
// terminal_t
// ----------------------------------------------------------------------------------------
ATTR_COLD terminal_t::terminal_t()
: analog_t(TERMINAL)
ATTR_COLD terminal_t::terminal_t(core_device_t &dev, const pstring &aname)
: analog_t(dev, aname, TERMINAL)
, m_otherterm(nullptr)
, m_Idr1(nullptr)
, m_go1(nullptr)
, m_gt1(nullptr)
{
netlist().setup().register_object(*this);
save(NLNAME(m_Idr1));
save(NLNAME(m_go1));
save(NLNAME(m_gt1));
}
@ -953,14 +886,6 @@ ATTR_COLD void terminal_t::reset()
set_ptr(m_gt1, netlist().gmin());
}
ATTR_COLD void terminal_t::save_register()
{
save(NLNAME(m_Idr1));
save(NLNAME(m_go1));
save(NLNAME(m_gt1));
core_terminal_t::save_register();
}
// ----------------------------------------------------------------------------------------
// net_input_t
@ -974,17 +899,14 @@ ATTR_COLD void terminal_t::save_register()
// logic_output_t
// ----------------------------------------------------------------------------------------
ATTR_COLD logic_output_t::logic_output_t()
: logic_t(OUTPUT)
ATTR_COLD logic_output_t::logic_output_t(core_device_t &dev, const pstring &aname)
: logic_t(dev, aname, OUTPUT)
, m_my_net(dev.netlist(), name() + ".net", this)
{
set_state(STATE_OUT);
this->set_net(&m_my_net);
}
ATTR_COLD void logic_output_t::init_object(core_device_t &dev, const pstring &aname)
{
core_terminal_t::init_object(dev, aname);
net().init_object(dev.netlist(), aname + ".net", this);
set_logic_family(dev.logic_family());
netlist().setup().register_object(*this);
}
ATTR_COLD void logic_output_t::initial(const netlist_sig_t val)
@ -992,38 +914,30 @@ ATTR_COLD void logic_output_t::initial(const netlist_sig_t val)
net().as_logic().initial(val);
}
// ----------------------------------------------------------------------------------------
// analog_input_t
// ----------------------------------------------------------------------------------------
ATTR_COLD analog_input_t::analog_input_t(core_device_t &dev, const pstring &aname)
: analog_t(dev, aname, INPUT)
{
set_state(STATE_INP_ACTIVE);
netlist().setup().register_object(*this);
}
// ----------------------------------------------------------------------------------------
// analog_output_t
// ----------------------------------------------------------------------------------------
ATTR_COLD analog_output_t::analog_output_t(core_device_t &dev, const pstring &aname)
: analog_t(OUTPUT), m_proxied_net(nullptr)
: analog_t(dev, aname, OUTPUT), m_proxied_net(nullptr)
, m_my_net(dev.netlist(), name() + ".net", this)
{
this->set_net(&m_my_net);
set_state(STATE_OUT);
//net().m_cur_Analog = NL_FCONST(0.99);
net().m_cur_Analog = NL_FCONST(0.0);
analog_t::init_object(dev, aname);
net().init_object(dev.netlist(), aname + ".net", this);
}
ATTR_COLD analog_output_t::analog_output_t()
: analog_t(OUTPUT), m_proxied_net(nullptr)
{
this->set_net(&m_my_net);
set_state(STATE_OUT);
//net().m_cur_Analog = NL_FCONST(0.99);
net().m_cur_Analog = NL_FCONST(0.0);
}
ATTR_COLD void analog_output_t::init_object(core_device_t &dev, const pstring &aname)
{
analog_t::init_object(dev, aname);
net().init_object(dev.netlist(), aname + ".net", this);
netlist().setup().register_object(*this);
}
ATTR_COLD void analog_output_t::initial(const nl_double val)
@ -1031,15 +945,26 @@ ATTR_COLD void analog_output_t::initial(const nl_double val)
net().m_cur_Analog = val;
}
// -----------------------------------------------------------------------------
// logic_input_t
// -----------------------------------------------------------------------------
ATTR_COLD logic_input_t::logic_input_t(core_device_t &dev, const pstring &aname)
: logic_t(dev, aname, INPUT)
{
set_state(STATE_INP_ACTIVE);
set_logic_family(dev.logic_family());
netlist().setup().register_object(*this);
}
// ----------------------------------------------------------------------------------------
// param_t & friends
// ----------------------------------------------------------------------------------------
ATTR_COLD param_t::param_t(const param_type_t atype, device_t &device, const pstring &name)
: device_object_t(PARAM)
: device_object_t(device, name, PARAM)
, m_param_type(atype)
{
init_object(device, name);
}
ATTR_COLD const pstring param_model_t::model_type()

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

@ -359,15 +359,10 @@ namespace netlist
QUEUE = 6
};
ATTR_COLD object_t(const type_t atype);
ATTR_COLD object_t(netlist_t &nl, const type_t atype);
ATTR_COLD object_t(netlist_t &nl, const pstring &aname, const type_t atype);
virtual ~object_t();
ATTR_COLD void init_object(netlist_t &nl, const pstring &aname);
ATTR_COLD bool isInitialized() { return (m_netlist != nullptr); }
ATTR_COLD const pstring &name() const;
ATTR_COLD inline plib::pstate_manager_t *state_manager();
@ -388,7 +383,7 @@ namespace netlist
virtual void reset() { }
// must call parent save_register !
virtual void save_register() { }
//virtual void save_register() { }
private:
pstring m_name;
@ -410,10 +405,7 @@ namespace netlist
{
P_PREVENT_COPYING(device_object_t)
public:
ATTR_COLD device_object_t(const type_t atype);
ATTR_COLD void init_object(core_device_t &dev, const pstring &aname);
ATTR_COLD device_object_t(core_device_t &dev, const pstring &aname, const type_t atype);
ATTR_HOT core_device_t &device() const { return *m_device; }
private:
core_device_t * m_device;
@ -442,8 +434,7 @@ namespace netlist
STATE_NONEX = 256
};
ATTR_COLD core_terminal_t(const type_t atype);
ATTR_COLD core_terminal_t(core_device_t &dev, const pstring &aname, const type_t atype);
ATTR_COLD void set_net(net_t *anet);
ATTR_COLD void clear_net();
@ -463,13 +454,6 @@ namespace netlist
m_state = astate;
}
protected:
virtual void save_register() override
{
save(NLNAME(m_state));
device_object_t::save_register();
}
private:
net_t * m_net;
state_e m_state;
@ -483,9 +467,8 @@ namespace netlist
{
public:
ATTR_COLD analog_t(const type_t atype)
: core_terminal_t(atype)
ATTR_COLD analog_t(core_device_t &dev, const pstring &aname, const type_t atype)
: core_terminal_t(dev, aname, atype)
{
}
@ -512,7 +495,7 @@ namespace netlist
using list_t = plib::pvector_t<terminal_t *>;
ATTR_COLD terminal_t();
ATTR_COLD terminal_t(core_device_t &dev, const pstring &aname);
terminal_t *m_otherterm;
@ -548,8 +531,6 @@ namespace netlist
}
protected:
virtual void save_register() override;
virtual void reset() override;
private:
ATTR_HOT void set_ptr(nl_double *ptr, const nl_double val)
@ -574,10 +555,8 @@ namespace netlist
class logic_t : public core_terminal_t, public logic_family_t
{
public:
ATTR_COLD logic_t(const type_t atype)
: core_terminal_t(atype), logic_family_t(),
ATTR_COLD logic_t(core_device_t &dev, const pstring &aname, const type_t atype)
: core_terminal_t(dev, aname, atype), logic_family_t(),
m_proxy(nullptr)
{
}
@ -603,14 +582,9 @@ namespace netlist
class logic_input_t : public logic_t
{
public:
ATTR_COLD logic_input_t()
: logic_t(INPUT)
{
set_state(STATE_INP_ACTIVE);
}
ATTR_COLD logic_input_t(core_device_t &dev, const pstring &aname);
ATTR_HOT netlist_sig_t Q() const;
ATTR_HOT netlist_sig_t last_Q() const;
ATTR_HOT void inactivate();
ATTR_HOT void activate();
@ -633,12 +607,7 @@ namespace netlist
class analog_input_t : public analog_t
{
public:
ATTR_COLD analog_input_t()
: analog_t(INPUT)
{
set_state(STATE_INP_ACTIVE);
}
ATTR_COLD analog_input_t(core_device_t &dev, const pstring &aname);
ATTR_HOT nl_double Q_Analog() const;
protected:
@ -650,7 +619,7 @@ namespace netlist
};
// -----------------------------------------------------------------------------
// net_net_t
// net_t
// -----------------------------------------------------------------------------
class net_t : public object_t
@ -661,11 +630,9 @@ namespace netlist
using ptr_t = net_t *;
using list_t = plib::pvector_t<std::shared_ptr<net_t>>;
ATTR_COLD net_t();
ATTR_COLD net_t(netlist_t &nl, const pstring &aname, core_terminal_t *mr = nullptr);
virtual ~net_t();
ATTR_COLD void init_object(netlist_t &nl, const pstring &aname, core_terminal_t *mr = nullptr);
ATTR_COLD void register_con(core_terminal_t &terminal);
ATTR_COLD void merge_net(net_t *othernet);
@ -713,7 +680,6 @@ namespace netlist
protected: //FIXME: needed by current solver code
virtual void save_register() override;
virtual void reset() override;
netlist_sig_t m_new_Q;
@ -743,7 +709,7 @@ namespace netlist
using list_t = plib::pvector_t<logic_net_t *>;
ATTR_COLD logic_net_t();
ATTR_COLD logic_net_t(netlist_t &nl, const pstring &aname, core_terminal_t *mr = nullptr);
virtual ~logic_net_t() { };
ATTR_HOT netlist_sig_t Q() const
@ -786,10 +752,8 @@ namespace netlist
protected: //FIXME: needed by current solver code
virtual void save_register() override;
virtual void reset() override;
private:
public:
@ -803,8 +767,7 @@ namespace netlist
using list_t = plib::pvector_t<analog_net_t *>;
ATTR_COLD analog_net_t();
ATTR_COLD analog_net_t(netlist_t &nl, const pstring &aname);
ATTR_COLD analog_net_t(netlist_t &nl, const pstring &aname, core_terminal_t *mr = nullptr);
virtual ~analog_net_t() { };
@ -825,7 +788,6 @@ namespace netlist
protected:
virtual void save_register() override;
virtual void reset() override;
@ -846,9 +808,8 @@ namespace netlist
P_PREVENT_COPYING(logic_output_t)
public:
ATTR_COLD logic_output_t();
ATTR_COLD logic_output_t(core_device_t &dev, const pstring &aname);
ATTR_COLD void init_object(core_device_t &dev, const pstring &aname);
virtual void reset() override
{
set_state(STATE_OUT);
@ -871,9 +832,7 @@ namespace netlist
public:
ATTR_COLD analog_output_t(core_device_t &dev, const pstring &aname);
ATTR_COLD analog_output_t();
ATTR_COLD void init_object(core_device_t &dev, const pstring &aname);
virtual void reset() override
{
set_state(STATE_OUT);
@ -1006,8 +965,6 @@ namespace netlist
ATTR_HOT netlist_sig_t INPLOGIC(const logic_input_t &inp) const
{
//if (inp.state() == logic_t::STATE_INP_PASSIVE)
// printf("argh input %s\n", inp.name().cstr());
nl_assert(inp.state() != logic_t::STATE_INP_PASSIVE);
return inp.Q();
}
@ -1107,11 +1064,11 @@ namespace netlist
ATTR_COLD void register_subalias(const pstring &name, core_terminal_t &term);
ATTR_COLD void register_subalias(const pstring &name, const pstring &aliased);
ATTR_COLD void enregister(const pstring &name, terminal_t &port) { register_p(name, port); }
ATTR_COLD void enregister(const pstring &name, analog_output_t &out) { register_p(name, out); };
ATTR_COLD void enregister(const pstring &name, logic_output_t &out) { register_p(name, out); };
ATTR_COLD void enregister(const pstring &name, analog_input_t &in) { register_p(name, in); };
ATTR_COLD void enregister(const pstring &name, logic_input_t &in) { register_p(name, in); };
//ATTR_COLD void register_term(const pstring &name, terminal_t &port) { register_p(name, port); }
//ATTR_COLD void enregister(const pstring &name, analog_output_t &out) { register_p(name, out); };
//ATTR_COLD void enregister(const pstring &name, logic_output_t &out) { register_p(name, out); };
//ATTR_COLD void enregister(const pstring &name, analog_input_t &in) { register_p(name, in); };
//ATTR_COLD void enregister(const pstring &name, logic_input_t &in) { register_p(name, in); };
ATTR_COLD void connect_late(const pstring &t1, const pstring &t2);
ATTR_COLD void connect_late(core_terminal_t &t1, core_terminal_t &t2);
@ -1299,6 +1256,24 @@ protected:
plib::dynlib *m_lib; // external lib needs to be loaded as long as netlist exists
};
// -----------------------------------------------------------------------------
// Support classes for devices
// -----------------------------------------------------------------------------
template<class C, int N>
class object_array_t : public plib::uninitialised_array_t<C, N>
{
public:
struct init
{
const char *p[N];
};
object_array_t(core_device_t &dev, init names)
{
for (std::size_t i = 0; i<N; i++)
this->emplace(i, dev, names.p[i]);
}
};
// -----------------------------------------------------------------------------
// inline implementations

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

@ -45,23 +45,6 @@ factory_list_t::~factory_list_t()
clear();
}
#if 0
device_t *factory_list_t::new_device_by_classname(const pstring &classname) const
{
for (std::size_t i=0; i < m_list.size(); i++)
{
base_factory_t *p = m_list[i];
if (p->classname() == classname)
{
device_t *ret = p->Create();
return ret;
}
p++;
}
return nullptr; // appease code analysis
}
#endif
void factory_list_t::error(const pstring &s)
{
m_setup.log().fatal("{1}", s);

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

@ -105,7 +105,6 @@ void setup_t::register_dev(plib::owned_ptr<device_t> dev)
for (auto & d : netlist().m_devices)
if (d->name() == dev->name())
log().fatal("Error adding {1} to device list. Duplicate name \n", d->name());
netlist().m_devices.push_back(std::move(dev));
}
@ -245,7 +244,7 @@ void setup_t::register_and_set_param(pstring name, param_t &param)
log().fatal("Error adding parameter {1} to parameter list\n", name);
}
void setup_t::register_object(device_t &dev, const pstring &name, object_t &obj)
void setup_t::register_object(object_t &obj)
{
switch (obj.type())
{
@ -256,36 +255,18 @@ void setup_t::register_object(device_t &dev, const pstring &name, object_t &obj)
core_terminal_t &term = dynamic_cast<core_terminal_t &>(obj);
if (term.isType(terminal_t::OUTPUT))
{
if (term.is_logic())
{
logic_output_t &port = dynamic_cast<logic_output_t &>(term);
port.set_logic_family(dev.logic_family());
dynamic_cast<logic_output_t &>(term).init_object(dev, dev.name() + "." + name);
}
else if (term.is_analog())
dynamic_cast<analog_output_t &>(term).init_object(dev, dev.name() + "." + name);
else
log().fatal("Error adding {1} {2} to terminal list, neither LOGIC nor ANALOG\n", objtype_as_astr(term), term.name());
}
else if (term.isType(terminal_t::INPUT))
{
if (term.is_logic())
{
logic_input_t &port = dynamic_cast<logic_input_t &>(term);
port.set_logic_family(dev.logic_family());
}
term.init_object(dev, dev.name() + "." + name);
dev.m_terminals.push_back(obj.name());
static_cast<device_t &>(term.device()).m_terminals.push_back(obj.name());
}
else
{
term.init_object(dev, dev.name() + "." + name);
dev.m_terminals.push_back(obj.name());
static_cast<device_t &>(term.device()).m_terminals.push_back(obj.name());
}
if (!m_terminals.add(term.name(), &term))
log().fatal("Error adding {1} {2} to terminal list\n", objtype_as_astr(term), term.name());
log().debug("{1} {2}\n", objtype_as_astr(term), name);
log().fatal("Error adding {1} {2} to terminal list\n", objtype_as_astr(obj), obj.name());
log().debug("{1} {2}\n", objtype_as_astr(obj), obj.name());
}
break;
case terminal_t::NET:
@ -297,10 +278,10 @@ void setup_t::register_object(device_t &dev, const pstring &name, object_t &obj)
}
break;
case terminal_t::DEVICE:
log().fatal("Device registration not yet supported - {1}\n", name);
log().fatal("Device registration not yet supported - {1}\n", obj.name());
break;
case terminal_t::QUEUE:
log().fatal("QUEUE registration not yet supported - {1}\n", name);
log().fatal("QUEUE registration not yet supported - {1}\n", obj.name());
break;
}
}

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

@ -113,7 +113,7 @@ namespace netlist
void register_and_set_param(pstring name, param_t &param);
void register_object(device_t &dev, const pstring &name, object_t &obj);
void register_object(object_t &obj);
template<class NETLIST_X>
void register_dev_s(plib::owned_ptr<NETLIST_X> dev)

18
src/lib/netlist/plib/plists.h
View File

@ -13,6 +13,7 @@
#include <algorithm>
#include <stack>
#include <vector>
#include <type_traits>
#include "palloc.h"
#include "pstring.h"
@ -105,22 +106,25 @@ public:
~uninitialised_array_t()
{
for (std::size_t i=0; i<N; i++)
{
C &r = (*this)[i];
r.~C();
}
(*this)[i].~C();
}
size_t size() { return N; }
C& operator[](const std::size_t &index)
{
return *reinterpret_cast<C *>(reinterpret_cast<char *>(m_buf) + index * sizeof(C));
return *reinterpret_cast<C *>(&m_buf[index]);
}
const C& operator[](const std::size_t &index) const
{
return *reinterpret_cast<C *>(reinterpret_cast<char *>(m_buf) + index * sizeof(C));
return *reinterpret_cast<C *>(&m_buf[index]);
}
template<typename... Args>
void emplace(const std::size_t index, Args&&... args)
{
new (&m_buf[index]) C(std::forward<Args>(args)...);
}
protected:
@ -128,7 +132,7 @@ protected:
private:
/* ensure proper alignment */
UINT64 m_buf[(N * sizeof(C) + sizeof(UINT64) - 1) / sizeof(UINT64)];
typename std::aligned_storage<sizeof(C), alignof(C)>::type m_buf[N];
};
// ----------------------------------------------------------------------------------------

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

@ -97,10 +97,10 @@ public:
m_iterative_total(0),
m_params(*params),
m_cur_ts(0),
m_fb_sync(*this, "FB_sync"),
m_Q_sync(*this, "Q_sync"),
m_sort(sort)
{
enregister("Q_sync", m_Q_sync);
enregister("FB_sync", m_fb_sync);
connect_post_start(m_fb_sync, m_Q_sync);
save(NLNAME(m_last_step));

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

@ -31,7 +31,6 @@
#include <iostream>
#include <algorithm>
//#include "nld_twoterm.h"
#include "nl_lists.h"
#if HAS_OPENMP

5
src/lib/netlist/solver/nld_solver.h
View File

@ -57,6 +57,8 @@ class matrix_solver_t;
NETLIB_OBJECT(solver)
{
NETLIB_CONSTRUCTOR(solver)
, m_fb_step(*this, "FB_step")
, m_Q_step(*this, "Q_step")
, m_sync_delay(*this, "SYNC_DELAY", NLTIME_FROM_NS(10).as_double())
, m_freq(*this, "FREQ", 48000.0)
@ -80,11 +82,8 @@ NETLIB_OBJECT(solver)
, m_log_stats(*this, "LOG_STATS", 1) // nl_double timestep resolution
{
enregister("Q_step", m_Q_step);
// internal staff
enregister("FB_step", m_fb_step);
connect_late(m_fb_step, m_Q_step);
}