Sprinter/mame
2
0
Fork 0
mirror of https://github.com/holub/mame synced 2025-06-29 23:48:56 +03:00
Code Issues Actions Packages Projects Releases Wiki Activity

Converted most subdevices to unique_ptr. This is a temporary measure

Browse Source 
until the device initialisation is moved into the constructor. Started
converting constructors of devices to be passed name and netlist. (nw)
This commit is contained in:
couriersud 2016-04-23 23:35:27 +02:00
parent 28eeb49676
commit 576189b169
96 changed files with 1129 additions and 1107 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

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

@ -503,8 +503,8 @@ private:
class NETLIB_NAME(analog_callback) : public netlist::device_t
{
public:
NETLIB_NAME(analog_callback)()
: device_t(), m_cpu_device(nullptr), m_last(0) { }
NETLIB_NAME(analog_callback)(netlist::netlist_t &anetlist, const pstring &name)
: device_t(anetlist, name), m_cpu_device(nullptr), m_last(0) { }
ATTR_COLD void start() override
{
@ -552,8 +552,8 @@ private:
class NETLIB_NAME(sound_out) : public netlist::device_t
{
public:
NETLIB_NAME(sound_out)()
: netlist::device_t() { }
NETLIB_NAME(sound_out)(netlist::netlist_t &anetlist, const pstring &name)
: netlist::device_t(anetlist, name) { }
static const int BUFSIZE = 2048;
@ -626,8 +626,8 @@ private:
class NETLIB_NAME(sound_in) : public netlist::device_t
{
public:
NETLIB_NAME(sound_in)()
: netlist::device_t() { }
NETLIB_NAME(sound_in)(netlist::netlist_t &anetlist, const pstring &name)
: netlist::device_t(anetlist, name) { }
static const int MAX_INPUT_CHANNELS = 10;

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

@ -44,8 +44,8 @@ private:
// nld_Q
// ----------------------------------------------------------------------------------------
NETLIB_NAME(Q)::NETLIB_NAME(Q)(const family_t afamily)
: device_t(afamily)
NETLIB_NAME(Q)::NETLIB_NAME(Q)(const family_t afamily, netlist_t &anetlist, const pstring &name)
: device_t(afamily, anetlist, name)
, m_qtype(BJT_NPN) { }
NETLIB_NAME(Q)::~NETLIB_NAME(Q)()

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

@ -40,7 +40,7 @@ public:
BJT_PNP
};
NETLIB_NAME(Q)(const family_t afamily);
NETLIB_NAME(Q)(const family_t afamily, netlist_t &anetlist, const pstring &name);
virtual ~NETLIB_NAME(Q)();
inline q_type qtype() const { return m_qtype; }
@ -60,8 +60,8 @@ class NETLIB_NAME(QBJT) : public NETLIB_NAME(Q)
{
public:
NETLIB_NAME(QBJT)(const family_t afamily)
: NETLIB_NAME(Q)(afamily) { }
NETLIB_NAME(QBJT)(const family_t afamily, netlist_t &anetlist, const pstring &name)
: NETLIB_NAME(Q)(afamily, anetlist, name) { }
virtual ~NETLIB_NAME(QBJT)() { }
@ -94,12 +94,15 @@ private:
class NETLIB_NAME(QBJT_switch) : public NETLIB_NAME(QBJT)
{
public:
ATTR_COLD NETLIB_NAME(QBJT_switch)()
: NETLIB_NAME(QBJT)(BJT_SWITCH),
m_RB(object_t::ANALOG),
m_RC(object_t::ANALOG),
m_BC_dummy(object_t::ANALOG),
m_gB(NETLIST_GMIN_DEFAULT), m_gC(NETLIST_GMIN_DEFAULT), m_V(0.0), m_state_on(0) { }
ATTR_COLD NETLIB_NAME(QBJT_switch)(netlist_t &anetlist, const pstring &name)
: NETLIB_NAME(QBJT)(BJT_SWITCH, anetlist, name),
m_RB(object_t::ANALOG, anetlist, "m_RB"),
m_RC(object_t::ANALOG, anetlist, "m_RC"),
m_BC_dummy(object_t::ANALOG, anetlist, "m_BC"),
m_gB(NETLIST_GMIN_DEFAULT),
m_gC(NETLIST_GMIN_DEFAULT),
m_V(0.0),
m_state_on(0) { }
ATTR_HOT void virtual update() override;
@ -134,11 +137,11 @@ private:
class NETLIB_NAME(QBJT_EB) : public NETLIB_NAME(QBJT)
{
public:
ATTR_COLD NETLIB_NAME(QBJT_EB)()
: NETLIB_NAME(QBJT)(BJT_EB),
m_D_CB(object_t::ANALOG),
m_D_EB(object_t::ANALOG),
m_D_EC(object_t::ANALOG),
ATTR_COLD NETLIB_NAME(QBJT_EB)(netlist_t &anetlist, const pstring &name)
: NETLIB_NAME(QBJT)(BJT_EB, anetlist, name),
m_D_CB(object_t::ANALOG, anetlist, "m_D_CB"),
m_D_EB(object_t::ANALOG, anetlist, "m_D_EB"),
m_D_EC(object_t::ANALOG, anetlist, "m_D_EC"),
m_alpha_f(0),
m_alpha_r(0)
{ }

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

@ -34,8 +34,8 @@ void NETLIB_NAME(VCCS)::start_internal(const nl_double def_RI)
register_terminal("_OP1", m_OP1);
register_terminal("_ON1", m_ON1);
m_IP.m_otherterm = &m_IN; // <= this should be nullptr and terminal be filtered out prior to solving...
m_IN.m_otherterm = &m_IP; // <= this should be nullptr and terminal be filtered out prior to solving...
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...
m_OP.m_otherterm = &m_IP;
m_OP1.m_otherterm = &m_IN;

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

@ -54,10 +54,10 @@ NETLIB_NAMESPACE_DEVICES_START()
class NETLIB_NAME(VCCS) : public device_t
{
public:
ATTR_COLD NETLIB_NAME(VCCS)()
: device_t(VCCS), m_gfac(1.0) { }
ATTR_COLD NETLIB_NAME(VCCS)(const family_t afamily)
: device_t(afamily), m_gfac(1.0) { }
ATTR_COLD NETLIB_NAME(VCCS)(netlist_t &anetlist, const pstring &name)
: device_t(VCCS, anetlist, name), m_gfac(1.0) { }
ATTR_COLD NETLIB_NAME(VCCS)(const family_t afamily, netlist_t &anetlist, const pstring &name)
: device_t(afamily, anetlist, name), m_gfac(1.0) { }
param_double_t m_G;
param_double_t m_RI;
@ -87,10 +87,10 @@ protected:
class NETLIB_NAME(LVCCS) : public NETLIB_NAME(VCCS)
{
public:
ATTR_COLD NETLIB_NAME(LVCCS)()
: NETLIB_NAME(VCCS)(LVCCS), m_vi(0.0) { }
ATTR_COLD NETLIB_NAME(LVCCS)(const family_t afamily)
: NETLIB_NAME(VCCS)(afamily), m_vi(0.0) { }
ATTR_COLD NETLIB_NAME(LVCCS)(netlist_t &anetlist, const pstring &name)
: NETLIB_NAME(VCCS)(LVCCS, anetlist, name), m_vi(0.0) { }
ATTR_COLD NETLIB_NAME(LVCCS)(const family_t afamily, netlist_t &anetlist, const pstring &name)
: NETLIB_NAME(VCCS)(afamily, anetlist, name), m_vi(0.0) { }
param_double_t m_cur_limit; /* current limit */
@ -130,8 +130,8 @@ protected:
class NETLIB_NAME(CCCS) : public NETLIB_NAME(VCCS)
{
public:
ATTR_COLD NETLIB_NAME(CCCS)()
: NETLIB_NAME(VCCS)(CCCS), m_gfac(1.0) { }
ATTR_COLD NETLIB_NAME(CCCS)(netlist_t &anetlist, const pstring &name)
: NETLIB_NAME(VCCS)(CCCS, anetlist, name), m_gfac(1.0) { }
protected:
virtual void start() override;
@ -174,8 +174,8 @@ protected:
class NETLIB_NAME(VCVS) : public NETLIB_NAME(VCCS)
{
public:
ATTR_COLD NETLIB_NAME(VCVS)()
: NETLIB_NAME(VCCS)(VCVS) { }
ATTR_COLD NETLIB_NAME(VCVS)(netlist_t &anetlist, const pstring &name)
: NETLIB_NAME(VCCS)(VCVS, anetlist, name) { }
param_double_t m_RO;

32
src/lib/netlist/analog/nld_opamps.cpp
View File

@ -123,36 +123,36 @@ NETLIB_UPDATE(OPAMP)
NETLIB_RESET(OPAMP)
{
m_G1.do_reset();
m_G1.m_RI.setTo(m_model.model_value("RI"));
m_G1->do_reset();
m_G1->m_RI.setTo(m_model.model_value("RI"));
if (m_type == 1)
{
double RO = m_model.model_value("RO");
double G = m_model.model_value("UGF") / m_model.model_value("FPF") / RO;
m_RP.set_R(RO);
m_G1.m_G.setTo(G);
m_RP->set_R(RO);
m_G1->m_G.setTo(G);
}
else if (m_type == 3)
{
m_EBUF.do_reset();
m_DP.do_reset();
m_DN.do_reset();
m_CP.do_reset();
m_RP.do_reset();
m_EBUF->do_reset();
m_DP->do_reset();
m_DN->do_reset();
m_CP->do_reset();
m_RP->do_reset();
m_EBUF.m_G.setTo(1.0);
m_EBUF.m_RO.setTo(m_model.model_value("RO"));
m_DP.m_model.setTo("D(IS=1e-15 N=1)");
m_DN.m_model.setTo("D(IS=1e-15 N=1)");
m_EBUF->m_G.setTo(1.0);
m_EBUF->m_RO.setTo(m_model.model_value("RO"));
m_DP->m_model.setTo("D(IS=1e-15 N=1)");
m_DN->m_model.setTo("D(IS=1e-15 N=1)");
double CP = m_model.model_value("DAB") / m_model.model_value("SLEW");
double RP = 0.5 / 3.1459 / CP / m_model.model_value("FPF");
double G = m_model.model_value("UGF") / m_model.model_value("FPF") / RP;
m_CP.m_C.setTo(CP);
m_RP.set_R(RP);
m_G1.m_G.setTo(G);
m_CP->m_C.setTo(CP);
m_RP->set_R(RP);
m_G1->m_G.setTo(G);
}

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

@ -35,12 +35,12 @@ NETLIST_EXTERNAL(opamp_lm3900)
NETLIB_NAMESPACE_DEVICES_START()
NETLIB_DEVICE_WITH_PARAMS(OPAMP,
NETLIB_NAME(R) m_RP;
NETLIB_NAME(C) m_CP;
NETLIB_NAME(VCCS) m_G1;
NETLIB_NAME(VCVS) m_EBUF;
NETLIB_NAME(D) m_DP;
NETLIB_NAME(D) m_DN;
NETLIB_SUB(R) m_RP;
NETLIB_SUB(C) m_CP;
NETLIB_SUB(VCCS) m_G1;
NETLIB_SUB(VCVS) m_EBUF;
NETLIB_SUB(D) m_DP;
NETLIB_SUB(D) m_DN;
analog_input_t m_VCC;
analog_input_t m_GND;

42
src/lib/netlist/analog/nld_switches.cpp
View File

@ -23,29 +23,29 @@ NETLIB_START(switch1)
register_param("POS", m_POS, 0);
register_subalias("1", m_R.m_P);
register_subalias("2", m_R.m_N);
register_subalias("1", m_R->m_P);
register_subalias("2", m_R->m_N);
}
NETLIB_RESET(switch1)
{
m_R.do_reset();
m_R->do_reset();
m_R.set_R(R_OFF);
m_R->set_R(R_OFF);
}
NETLIB_UPDATE(switch1)
{
if (m_POS.Value() == 0)
{
m_R.set_R(R_OFF);
m_R->set_R(R_OFF);
}
else
{
m_R.set_R(R_ON);
m_R->set_R(R_ON);
}
m_R.update_dev();
m_R->update_dev();
}
NETLIB_UPDATE_PARAM(switch1)
@ -65,38 +65,38 @@ NETLIB_START(switch2)
register_param("POS", m_POS, 0);
connect_late(m_R[0].m_N, m_R[1].m_N);
connect_late(m_R[0]->m_N, m_R[1]->m_N);
register_subalias("1", m_R[0].m_P);
register_subalias("2", m_R[1].m_P);
register_subalias("1", m_R[0]->m_P);
register_subalias("2", m_R[1]->m_P);
register_subalias("Q", m_R[0].m_N);
register_subalias("Q", m_R[0]->m_N);
}
NETLIB_RESET(switch2)
{
m_R[0].do_reset();
m_R[1].do_reset();
m_R[0]->do_reset();
m_R[1]->do_reset();
m_R[0].set_R(R_ON);
m_R[1].set_R(R_OFF);
m_R[0]->set_R(R_ON);
m_R[1]->set_R(R_OFF);
}
NETLIB_UPDATE(switch2)
{
if (m_POS.Value() == 0)
{
m_R[0].set_R(R_ON);
m_R[1].set_R(R_OFF);
m_R[0]->set_R(R_ON);
m_R[1]->set_R(R_OFF);
}
else
{
m_R[0].set_R(R_OFF);
m_R[1].set_R(R_ON);
m_R[0]->set_R(R_OFF);
m_R[1]->set_R(R_ON);
}
m_R[0].update_dev();
m_R[1].update_dev();
m_R[0]->update_dev();
m_R[1]->update_dev();
}
NETLIB_UPDATE_PARAM(switch2)

4
src/lib/netlist/analog/nld_switches.h
View File

@ -30,13 +30,13 @@
NETLIB_NAMESPACE_DEVICES_START()
NETLIB_DEVICE_WITH_PARAMS(switch1,
NETLIB_NAME(R_base) m_R;
NETLIB_SUB(R_base) m_R;
param_int_t m_POS;
);
NETLIB_DEVICE_WITH_PARAMS(switch2,
NETLIB_NAME(R_base) m_R[2];
NETLIB_SUB(R_base) m_R[2];
param_int_t m_POS;
);

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

@ -48,15 +48,15 @@ ATTR_COLD void generic_diode::save(pstring name, object_t &parent)
// nld_twoterm
// ----------------------------------------------------------------------------------------
ATTR_COLD NETLIB_NAME(twoterm)::NETLIB_NAME(twoterm)(const family_t afamily)
: device_t(afamily)
ATTR_COLD NETLIB_NAME(twoterm)::NETLIB_NAME(twoterm)(const family_t afamily, netlist_t &anetlist, const pstring &name)
: device_t(afamily, anetlist, name)
{
m_P.m_otherterm = &m_N;
m_N.m_otherterm = &m_P;
}
ATTR_COLD NETLIB_NAME(twoterm)::NETLIB_NAME(twoterm)()
: device_t(TWOTERM)
ATTR_COLD NETLIB_NAME(twoterm)::NETLIB_NAME(twoterm)(netlist_t &anetlist, const pstring &name)
: device_t(TWOTERM, anetlist, name)
{
m_P.m_otherterm = &m_N;
m_N.m_otherterm = &m_P;
@ -137,11 +137,11 @@ NETLIB_START(POT)
register_sub("R1", m_R1);
register_sub("R2", m_R2);
register_subalias("1", m_R1.m_P);
register_subalias("2", m_R1.m_N);
register_subalias("3", m_R2.m_N);
register_subalias("1", m_R1->m_P);
register_subalias("2", m_R1->m_N);
register_subalias("3", m_R2->m_N);
connect_late(m_R2.m_P, m_R1.m_N);
connect_late(m_R2->m_P, m_R1->m_N);
register_param("R", m_R, 1.0 / netlist().gmin());
register_param("DIAL", m_Dial, 0.5);
@ -151,14 +151,14 @@ NETLIB_START(POT)
NETLIB_RESET(POT)
{
m_R1.do_reset();
m_R2.do_reset();
m_R1->do_reset();
m_R2->do_reset();
}
NETLIB_UPDATE(POT)
{
m_R1.update_dev();
m_R2.update_dev();
m_R1->update_dev();
m_R2->update_dev();
}
NETLIB_UPDATE_PARAM(POT)
@ -167,11 +167,11 @@ NETLIB_UPDATE_PARAM(POT)
if (m_DialIsLog.Value())
v = (nl_math::exp(v) - 1.0) / (nl_math::exp(1.0) - 1.0);
m_R1.update_dev();
m_R2.update_dev();
m_R1->update_dev();
m_R2->update_dev();
m_R1.set_R(std::max(m_R.Value() * v, netlist().gmin()));
m_R2.set_R(std::max(m_R.Value() * (NL_FCONST(1.0) - v), netlist().gmin()));
m_R1->set_R(std::max(m_R.Value() * v, netlist().gmin()));
m_R2->set_R(std::max(m_R.Value() * (NL_FCONST(1.0) - v), netlist().gmin()));
}
@ -183,8 +183,8 @@ NETLIB_START(POT2)
{
register_sub("R1", m_R1);
register_subalias("1", m_R1.m_P);
register_subalias("2", m_R1.m_N);
register_subalias("1", m_R1->m_P);
register_subalias("2", m_R1->m_N);
register_param("R", m_R, 1.0 / netlist().gmin());
register_param("DIAL", m_Dial, 0.5);
@ -195,12 +195,12 @@ NETLIB_START(POT2)
NETLIB_RESET(POT2)
{
m_R1.do_reset();
m_R1->do_reset();
}
NETLIB_UPDATE(POT2)
{
m_R1.update_dev();
m_R1->update_dev();
}
NETLIB_UPDATE_PARAM(POT2)
@ -212,9 +212,9 @@ NETLIB_UPDATE_PARAM(POT2)
if (m_Reverse.Value())
v = 1.0 - v;
m_R1.update_dev();
m_R1->update_dev();
m_R1.set_R(std::max(m_R.Value() * v, netlist().gmin()));
m_R1->set_R(std::max(m_R.Value() * v, netlist().gmin()));
}
// ----------------------------------------------------------------------------------------

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

@ -103,8 +103,8 @@ NETLIB_NAMESPACE_DEVICES_START()
class NETLIB_NAME(twoterm) : public device_t
{
public:
ATTR_COLD NETLIB_NAME(twoterm)(const family_t afamily);
ATTR_COLD NETLIB_NAME(twoterm)();
ATTR_COLD NETLIB_NAME(twoterm)(const family_t afamily, netlist_t &anetlist, const pstring &name);
ATTR_COLD NETLIB_NAME(twoterm)(netlist_t &anetlist, const pstring &name);
terminal_t m_P;
terminal_t m_N;
@ -147,7 +147,8 @@ private:
class NETLIB_NAME(R_base) : public NETLIB_NAME(twoterm)
{
public:
ATTR_COLD NETLIB_NAME(R_base)() : NETLIB_NAME(twoterm)(RESISTOR) { }
ATTR_COLD NETLIB_NAME(R_base)(netlist_t &anetlist, const pstring &name)
: NETLIB_NAME(twoterm)(RESISTOR, anetlist, name) { }
inline void set_R(const nl_double R)
{
@ -169,8 +170,8 @@ NETLIB_DEVICE_WITH_PARAMS_DERIVED(R, R_base,
// -----------------------------------------------------------------------------
NETLIB_DEVICE_WITH_PARAMS(POT,
NETLIB_NAME(R_base) m_R1;
NETLIB_NAME(R_base) m_R2;
NETLIB_SUB(R_base) m_R1;
NETLIB_SUB(R_base) m_R2;
param_double_t m_R;
param_double_t m_Dial;
@ -178,7 +179,7 @@ NETLIB_DEVICE_WITH_PARAMS(POT,
);
NETLIB_DEVICE_WITH_PARAMS(POT2,
NETLIB_NAME(R_base) m_R1;
NETLIB_SUB(R_base) m_R1;
param_double_t m_R;
param_double_t m_Dial;
@ -194,7 +195,8 @@ NETLIB_DEVICE_WITH_PARAMS(POT2,
class NETLIB_NAME(C) : public NETLIB_NAME(twoterm)
{
public:
ATTR_COLD NETLIB_NAME(C)() : NETLIB_NAME(twoterm)(CAPACITOR), m_GParallel(0.0) { }
ATTR_COLD NETLIB_NAME(C)(netlist_t &anetlist, const pstring &name)
: NETLIB_NAME(twoterm)(CAPACITOR, anetlist, name), m_GParallel(0.0) { }
ATTR_HOT void step_time(const nl_double st) override;
@ -291,7 +293,8 @@ private:
class NETLIB_NAME(D) : public NETLIB_NAME(twoterm)
{
public:
ATTR_COLD NETLIB_NAME(D)() : NETLIB_NAME(twoterm)(DIODE) { }
ATTR_COLD NETLIB_NAME(D)(netlist_t &anetlist, const pstring &name)
: NETLIB_NAME(twoterm)(DIODE, anetlist, name) { }
NETLIB_UPDATE_TERMINALSI();
@ -314,7 +317,8 @@ protected:
class NETLIB_NAME(VS) : public NETLIB_NAME(twoterm)
{
public:
ATTR_COLD NETLIB_NAME(VS)() : NETLIB_NAME(twoterm)(VS) { }
ATTR_COLD NETLIB_NAME(VS)(netlist_t &anetlist, const pstring &name)
: NETLIB_NAME(twoterm)(VS, anetlist, name) { }
protected:
virtual void start() override;
@ -332,7 +336,8 @@ protected:
class NETLIB_NAME(CS) : public NETLIB_NAME(twoterm)
{
public:
ATTR_COLD NETLIB_NAME(CS)() : NETLIB_NAME(twoterm)(CS) { }
ATTR_COLD NETLIB_NAME(CS)(netlist_t &anetlist, const pstring &name)
: NETLIB_NAME(twoterm)(CS, anetlist, name) { }
protected:
virtual void start() override;

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

@ -15,26 +15,26 @@ NETLIB_START(CD4020)
register_sub("supply", m_supply);
register_input("RESET", m_RESET);
register_subalias("IP", sub.m_IP);
register_subalias("Q1", sub.m_Q[0]);
register_subalias("Q4", sub.m_Q[3]);
register_subalias("Q5", sub.m_Q[4]);
register_subalias("Q6", sub.m_Q[5]);
register_subalias("Q7", sub.m_Q[6]);
register_subalias("Q8", sub.m_Q[7]);
register_subalias("Q9", sub.m_Q[8]);
register_subalias("Q10", sub.m_Q[9]);
register_subalias("Q11", sub.m_Q[10]);
register_subalias("Q12", sub.m_Q[11]);
register_subalias("Q13", sub.m_Q[12]);
register_subalias("Q14", sub.m_Q[13]);
register_subalias("VDD", m_supply.m_vdd);
register_subalias("VSS", m_supply.m_vss);
register_subalias("IP", sub->m_IP);
register_subalias("Q1", sub->m_Q[0]);
register_subalias("Q4", sub->m_Q[3]);
register_subalias("Q5", sub->m_Q[4]);
register_subalias("Q6", sub->m_Q[5]);
register_subalias("Q7", sub->m_Q[6]);
register_subalias("Q8", sub->m_Q[7]);
register_subalias("Q9", sub->m_Q[8]);
register_subalias("Q10", sub->m_Q[9]);
register_subalias("Q11", sub->m_Q[10]);
register_subalias("Q12", sub->m_Q[11]);
register_subalias("Q13", sub->m_Q[12]);
register_subalias("Q14", sub->m_Q[13]);
register_subalias("VDD", m_supply->m_vdd);
register_subalias("VSS", m_supply->m_vss);
}
NETLIB_RESET(CD4020)
{
sub.do_reset();
sub->do_reset();
}
@ -76,15 +76,15 @@ NETLIB_UPDATE(CD4020)
{
if (INPLOGIC(m_RESET))
{
sub.m_cnt = 0;
sub.m_IP.inactivate();
sub->m_cnt = 0;
sub->m_IP.inactivate();
/* static */ const netlist_time reset_time = netlist_time::from_nsec(140);
OUTLOGIC(sub.m_Q[0], 0, reset_time);
OUTLOGIC(sub->m_Q[0], 0, reset_time);
for (int i=3; i<14; i++)
OUTLOGIC(sub.m_Q[i], 0, reset_time);
OUTLOGIC(sub->m_Q[i], 0, reset_time);
}
else
sub.m_IP.activate_hl();
sub->m_IP.activate_hl();
}
inline NETLIB_FUNC_VOID(CD4020_sub, update_outputs, (const UINT16 cnt))

4
src/lib/netlist/devices/nld_4020.h
View File

@ -57,8 +57,8 @@ NETLIB_SUBDEVICE(CD4020_sub,
NETLIB_DEVICE(CD4020,
NETLIB_LOGIC_FAMILY(CD4XXX)
NETLIB_NAME(CD4020_sub) sub;
NETLIB_NAME(vdd_vss) m_supply;
NETLIB_SUB(CD4020_sub) sub;
NETLIB_SUB(vdd_vss) m_supply;
logic_input_t m_RESET;
);

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

@ -19,15 +19,15 @@ NETLIB_START(CD4066_GATE)
NETLIB_RESET(CD4066_GATE)
{
m_R.do_reset();
m_R->do_reset();
}
NETLIB_UPDATE(CD4066_GATE)
{
nl_double sup = (m_supply.vdd() - m_supply.vss());
nl_double sup = (m_supply->vdd() - m_supply->vss());
nl_double low = NL_FCONST(0.45) * sup;
nl_double high = NL_FCONST(0.55) * sup;
nl_double in = INPANALOG(m_control) - m_supply.vss();
nl_double in = INPANALOG(m_control) - m_supply->vss();
nl_double rON = m_base_r * NL_FCONST(5.0) / sup;
nl_double R = -1.0;
@ -44,14 +44,14 @@ NETLIB_UPDATE(CD4066_GATE)
// We only need to update the net first if this is a time stepping net
if (1) // m_R.m_P.net().as_analog().solver()->is_timestep())
{
m_R.update_dev();
m_R.set_R(R);
m_R.m_P.schedule_after(NLTIME_FROM_NS(1));
m_R->update_dev();
m_R->set_R(R);
m_R->m_P.schedule_after(NLTIME_FROM_NS(1));
}
else
{
m_R.set_R(R);
m_R.update_dev();
m_R->set_R(R);
m_R->update_dev();
}
}
}

4
src/lib/netlist/devices/nld_4066.h
View File

@ -37,9 +37,9 @@ NETLIB_DEVICE(CD4066_GATE,
public:
analog_input_t m_control;
NETLIB_NAME(R) m_R;
NETLIB_SUB(R) m_R;
NETLIB_NAME(vdd_vss) m_supply;
NETLIB_SUB(vdd_vss) m_supply;
param_double_t m_base_r;
);

40
src/lib/netlist/devices/nld_7402.cpp
View File

@ -28,38 +28,38 @@ NETLIB_START(7402_dip)
register_sub("3", m_3);
register_sub("4", m_4);
register_subalias("1", m_1.m_Q[0]);
register_subalias("2", m_1.m_I[0]);
register_subalias("3", m_1.m_I[1]);
register_subalias("1", m_1->m_Q[0]);
register_subalias("2", m_1->m_I[0]);
register_subalias("3", m_1->m_I[1]);
register_subalias("4", m_2.m_Q[0]);
register_subalias("5", m_2.m_I[0]);
register_subalias("6", m_2.m_I[1]);
register_subalias("4", m_2->m_Q[0]);
register_subalias("5", m_2->m_I[0]);
register_subalias("6", m_2->m_I[1]);
register_subalias("8", m_3.m_I[0]);
register_subalias("9", m_3.m_I[1]);
register_subalias("10", m_3.m_Q[0]);
register_subalias("8", m_3->m_I[0]);
register_subalias("9", m_3->m_I[1]);
register_subalias("10", m_3->m_Q[0]);
register_subalias("11", m_4.m_I[0]);
register_subalias("12", m_4.m_I[1]);
register_subalias("13", m_4.m_Q[0]);
register_subalias("11", m_4->m_I[0]);
register_subalias("12", m_4->m_I[1]);
register_subalias("13", m_4->m_Q[0]);
}
NETLIB_UPDATE(7402_dip)
{
/* only called during startup */
m_1.update_dev();
m_2.update_dev();
m_3.update_dev();
m_4.update_dev();
m_1->update_dev();
m_2->update_dev();
m_3->update_dev();
m_4->update_dev();
}
NETLIB_RESET(7402_dip)
{
m_1.do_reset();
m_2.do_reset();
m_3.do_reset();
m_4.do_reset();
m_1->do_reset();
m_2->do_reset();
m_3->do_reset();
m_4->do_reset();
}
NETLIB_NAMESPACE_DEVICES_END()

8
src/lib/netlist/devices/nld_7402.h
View File

@ -54,10 +54,10 @@ NETLIB_SIGNAL(7402, 2, 1, 0);
NETLIB_DEVICE(7402_dip,
NETLIB_NAME(7402) m_1;
NETLIB_NAME(7402) m_2;
NETLIB_NAME(7402) m_3;
NETLIB_NAME(7402) m_4;
NETLIB_SUB(7402) m_1;
NETLIB_SUB(7402) m_2;
NETLIB_SUB(7402) m_3;
NETLIB_SUB(7402) m_4;
);
NETLIB_NAMESPACE_DEVICES_END()

48
src/lib/netlist/devices/nld_7404.cpp
View File

@ -46,45 +46,45 @@ NETLIB_START(7404_dip)
register_sub("5", m_5);
register_sub("6", m_6);
register_subalias("1", m_1.m_I[0]);
register_subalias("2", m_1.m_Q[0]);
register_subalias("1", m_1->m_I[0]);
register_subalias("2", m_1->m_Q[0]);
register_subalias("3", m_2.m_I[0]);
register_subalias("4", m_2.m_Q[0]);
register_subalias("3", m_2->m_I[0]);
register_subalias("4", m_2->m_Q[0]);
register_subalias("5", m_3.m_I[0]);
register_subalias("6", m_3.m_Q[0]);
register_subalias("5", m_3->m_I[0]);
register_subalias("6", m_3->m_Q[0]);
register_subalias("8", m_4.m_Q[0]);
register_subalias("9", m_4.m_I[0]);
register_subalias("8", m_4->m_Q[0]);
register_subalias("9", m_4->m_I[0]);
register_subalias("10", m_5.m_Q[0]);
register_subalias("11", m_5.m_I[0]);
register_subalias("10", m_5->m_Q[0]);
register_subalias("11", m_5->m_I[0]);
register_subalias("12", m_6.m_Q[0]);
register_subalias("13", m_6.m_I[0]);
register_subalias("12", m_6->m_Q[0]);
register_subalias("13", m_6->m_I[0]);
}
NETLIB_UPDATE(7404_dip)
{
/* only called during startup */
m_1.update_dev();
m_2.update_dev();
m_3.update_dev();
m_4.update_dev();
m_5.update_dev();
m_6.update_dev();
m_1->update_dev();
m_2->update_dev();
m_3->update_dev();
m_4->update_dev();
m_5->update_dev();
m_6->update_dev();
}
NETLIB_RESET(7404_dip)
{
m_1.do_reset();
m_2.do_reset();
m_3.do_reset();
m_4.do_reset();
m_5.do_reset();
m_6.do_reset();
m_1->do_reset();
m_2->do_reset();
m_3->do_reset();
m_4->do_reset();
m_5->do_reset();
m_6->do_reset();
}
NETLIB_NAMESPACE_DEVICES_END()

12
src/lib/netlist/devices/nld_7404.h
View File

@ -54,12 +54,12 @@ public:
NETLIB_DEVICE(7404_dip,
NETLIB_NAME(7404) m_1;
NETLIB_NAME(7404) m_2;
NETLIB_NAME(7404) m_3;
NETLIB_NAME(7404) m_4;
NETLIB_NAME(7404) m_5;
NETLIB_NAME(7404) m_6;
NETLIB_SUB(7404) m_1;
NETLIB_SUB(7404) m_2;
NETLIB_SUB(7404) m_3;
NETLIB_SUB(7404) m_4;
NETLIB_SUB(7404) m_5;
NETLIB_SUB(7404) m_6;
);
NETLIB_NAMESPACE_DEVICES_END()

40
src/lib/netlist/devices/nld_7408.cpp
View File

@ -28,38 +28,38 @@ NETLIB_START(7408_dip)
register_sub("3", m_3);
register_sub("4", m_4);
register_subalias("1", m_1.m_I[0]);
register_subalias("2", m_1.m_I[1]);
register_subalias("3", m_1.m_Q[0]);
register_subalias("1", m_1->m_I[0]);
register_subalias("2", m_1->m_I[1]);
register_subalias("3", m_1->m_Q[0]);
register_subalias("4", m_2.m_I[0]);
register_subalias("5", m_2.m_I[1]);
register_subalias("6", m_2.m_Q[0]);
register_subalias("4", m_2->m_I[0]);
register_subalias("5", m_2->m_I[1]);
register_subalias("6", m_2->m_Q[0]);
register_subalias("9", m_3.m_I[0]);
register_subalias("10", m_3.m_I[1]);
register_subalias("8", m_3.m_Q[0]);
register_subalias("9", m_3->m_I[0]);
register_subalias("10", m_3->m_I[1]);
register_subalias("8", m_3->m_Q[0]);
register_subalias("12", m_4.m_I[0]);
register_subalias("13", m_4.m_I[1]);
register_subalias("11", m_4.m_Q[0]);
register_subalias("12", m_4->m_I[0]);
register_subalias("13", m_4->m_I[1]);
register_subalias("11", m_4->m_Q[0]);
}
NETLIB_UPDATE(7408_dip)
{
/* only called during startup */
m_1.update_dev();
m_2.update_dev();
m_3.update_dev();
m_4.update_dev();
m_1->update_dev();
m_2->update_dev();
m_3->update_dev();
m_4->update_dev();
}
NETLIB_RESET(7408_dip)
{
m_1.do_reset();
m_2.do_reset();
m_3.do_reset();
m_4.do_reset();
m_1->do_reset();
m_2->do_reset();
m_3->do_reset();
m_4->do_reset();
}
NETLIB_NAMESPACE_DEVICES_END()

8
src/lib/netlist/devices/nld_7408.h
View File

@ -54,10 +54,10 @@ NETLIB_SIGNAL(7408, 2, 0, 1);
NETLIB_DEVICE(7408_dip,
NETLIB_NAME(7408) m_1;
NETLIB_NAME(7408) m_2;
NETLIB_NAME(7408) m_3;
NETLIB_NAME(7408) m_4;
NETLIB_SUB(7408) m_1;
NETLIB_SUB(7408) m_2;
NETLIB_SUB(7408) m_3;
NETLIB_SUB(7408) m_4;
);
NETLIB_NAMESPACE_DEVICES_END()

36
src/lib/netlist/devices/nld_7410.cpp
View File

@ -29,35 +29,35 @@ NETLIB_START(7410_dip)
register_sub("2", m_2);
register_sub("3", m_3);
register_subalias("1", m_1.m_I[0]);
register_subalias("2", m_1.m_I[1]);
register_subalias("3", m_2.m_I[0]);
register_subalias("4", m_2.m_I[1]);
register_subalias("5", m_2.m_I[2]);
register_subalias("6", m_2.m_Q[0]);
register_subalias("1", m_1->m_I[0]);
register_subalias("2", m_1->m_I[1]);
register_subalias("3", m_2->m_I[0]);
register_subalias("4", m_2->m_I[1]);
register_subalias("5", m_2->m_I[2]);
register_subalias("6", m_2->m_Q[0]);
register_subalias("8", m_3.m_Q[0]);
register_subalias("9", m_3.m_I[0]);
register_subalias("10", m_3.m_I[1]);
register_subalias("11", m_3.m_I[2]);
register_subalias("8", m_3->m_Q[0]);
register_subalias("9", m_3->m_I[0]);
register_subalias("10", m_3->m_I[1]);
register_subalias("11", m_3->m_I[2]);
register_subalias("12", m_1.m_Q[0]);
register_subalias("13", m_1.m_I[2]);
register_subalias("12", m_1->m_Q[0]);
register_subalias("13", m_1->m_I[2]);
}
NETLIB_UPDATE(7410_dip)
{
/* only called during startup */
m_1.update_dev();
m_2.update_dev();
m_3.update_dev();
m_1->update_dev();
m_2->update_dev();
m_3->update_dev();
}
NETLIB_RESET(7410_dip)
{
m_1.do_reset();
m_2.do_reset();
m_3.do_reset();
m_1->do_reset();
m_2->do_reset();
m_3->do_reset();
}
NETLIB_NAMESPACE_DEVICES_END()

6
src/lib/netlist/devices/nld_7410.h
View File

@ -54,9 +54,9 @@ NETLIB_SIGNAL(7410, 3, 0, 0);
NETLIB_DEVICE(7410_dip,
NETLIB_NAME(7410) m_1;
NETLIB_NAME(7410) m_2;
NETLIB_NAME(7410) m_3;
NETLIB_SUB(7410) m_1;
NETLIB_SUB(7410) m_2;
NETLIB_SUB(7410) m_3;
);
NETLIB_NAMESPACE_DEVICES_END()

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

@ -35,18 +35,18 @@ NETLIB_START(74107A)
{
register_sub("sub", sub);
register_subalias("CLK", sub.m_clk);
register_subalias("CLK", sub->m_clk);
register_input("J", m_J);
register_input("K", m_K);
register_input("CLRQ", m_clrQ);
register_subalias("Q", sub.m_Q);
register_subalias("QQ", sub.m_QQ);
register_subalias("Q", sub->m_Q);
register_subalias("QQ", sub->m_QQ);
}
NETLIB_RESET(74107A)
{
sub.reset();
sub->reset();
}
ATTR_HOT inline void NETLIB_NAME(74107Asub)::newstate(const netlist_sig_t state)
@ -72,25 +72,25 @@ NETLIB_UPDATE(74107A)
switch (JK)
{
case 0:
sub.m_Q1 = 0;
sub.m_Q2 = 1;
sub.m_F = 0;
sub.m_clk.inactivate();
sub->m_Q1 = 0;
sub->m_Q2 = 1;
sub->m_F = 0;
sub->m_clk.inactivate();
break;
case 1: // (!INPLOGIC(m_J) & INPLOGIC(m_K))
sub.m_Q1 = 0;
sub.m_Q2 = 0;
sub.m_F = 0;
sub->m_Q1 = 0;
sub->m_Q2 = 0;
sub->m_F = 0;
break;
case 2: // (INPLOGIC(m_J) & !INPLOGIC(m_K))
sub.m_Q1 = 0;
sub.m_Q2 = 0;
sub.m_F = 1;
sub->m_Q1 = 0;
sub->m_Q2 = 0;
sub->m_F = 1;
break;
case 3: // (INPLOGIC(m_J) & INPLOGIC(m_K))
sub.m_Q1 = 1;
sub.m_Q2 = 0;
sub.m_F = 0;
sub->m_Q1 = 1;
sub->m_Q2 = 0;
sub->m_F = 0;
break;
default:
break;
@ -98,11 +98,11 @@ NETLIB_UPDATE(74107A)
if (!INPLOGIC(m_clrQ))
{
sub.m_clk.inactivate();
sub.newstate(0);
sub->m_clk.inactivate();
sub->newstate(0);
}
else if (!sub.m_Q2)
sub.m_clk.activate_hl();
else if (!sub->m_Q2)
sub->m_clk.activate_hl();
}
NETLIB_START(74107_dip)
@ -110,38 +110,38 @@ NETLIB_START(74107_dip)
register_sub("1", m_1);
register_sub("2", m_2);
register_subalias("1", m_1.m_J);
register_subalias("2", m_1.sub.m_QQ);
register_subalias("3", m_1.sub.m_Q);
register_subalias("1", m_1->m_J);
register_subalias("2", m_1->sub->m_QQ);
register_subalias("3", m_1->sub->m_Q);
register_subalias("4", m_1.m_K);
register_subalias("5", m_2.sub.m_Q);
register_subalias("6", m_2.sub.m_QQ);
register_subalias("4", m_1->m_K);
register_subalias("5", m_2->sub->m_Q);
register_subalias("6", m_2->sub->m_QQ);
// register_subalias("7", ); ==> GND
register_subalias("8", m_2.m_J);
register_subalias("9", m_2.sub.m_clk);
register_subalias("10", m_2.m_clrQ);
register_subalias("8", m_2->m_J);
register_subalias("9", m_2->sub->m_clk);
register_subalias("10", m_2->m_clrQ);
register_subalias("11", m_2.m_K);
register_subalias("12", m_1.sub.m_clk);
register_subalias("13", m_1.m_clrQ);
register_subalias("11", m_2->m_K);
register_subalias("12", m_1->sub->m_clk);
register_subalias("13", m_1->m_clrQ);
// register_subalias("14", ); ==> VCC
}
NETLIB_RESET(74107_dip)
{
m_1.do_reset();
m_2.do_reset();
m_1->do_reset();
m_2->do_reset();
}
NETLIB_UPDATE(74107_dip)
{
/* only called during startup */
m_1.update_dev();
m_2.update_dev();
m_1->update_dev();
m_2->update_dev();
}
NETLIB_NAMESPACE_DEVICES_END()

10
src/lib/netlist/devices/nld_74107.h
View File

@ -92,7 +92,7 @@ NETLIB_SUBDEVICE(74107Asub,
NETLIB_DEVICE(74107A,
public:
NETLIB_NAME(74107Asub) sub;
NETLIB_SUB(74107Asub) sub;
logic_input_t m_J;
logic_input_t m_K;
@ -103,15 +103,15 @@ public:
class NETLIB_NAME(74107) : public NETLIB_NAME(74107A)
{
public:
NETLIB_NAME(74107) ()
: NETLIB_NAME(74107A) () {}
NETLIB_NAME(74107) (netlist_t &anetlist, const pstring &name)
: NETLIB_NAME(74107A) (anetlist, name) {}
};
NETLIB_DEVICE(74107_dip,
NETLIB_NAME(74107) m_1;
NETLIB_NAME(74107) m_2;
NETLIB_SUB(74107) m_1;
NETLIB_SUB(74107) m_2;
);
NETLIB_NAMESPACE_DEVICES_END()

36
src/lib/netlist/devices/nld_7411.cpp
View File

@ -27,35 +27,35 @@ NETLIB_START(7411_dip)
register_sub("2", m_2);
register_sub("3", m_3);
register_subalias("1", m_1.m_I[0]);
register_subalias("2", m_1.m_I[1]);
register_subalias("3", m_2.m_I[0]);
register_subalias("4", m_2.m_I[1]);
register_subalias("5", m_2.m_I[2]);
register_subalias("6", m_2.m_Q[0]);
register_subalias("1", m_1->m_I[0]);
register_subalias("2", m_1->m_I[1]);
register_subalias("3", m_2->m_I[0]);
register_subalias("4", m_2->m_I[1]);
register_subalias("5", m_2->m_I[2]);
register_subalias("6", m_2->m_Q[0]);
register_subalias("8", m_3.m_Q[0]);
register_subalias("9", m_3.m_I[0]);
register_subalias("10", m_3.m_I[1]);
register_subalias("11", m_3.m_I[2]);
register_subalias("8", m_3->m_Q[0]);
register_subalias("9", m_3->m_I[0]);
register_subalias("10", m_3->m_I[1]);
register_subalias("11", m_3->m_I[2]);
register_subalias("12", m_1.m_Q[0]);
register_subalias("13", m_1.m_I[2]);
register_subalias("12", m_1->m_Q[0]);
register_subalias("13", m_1->m_I[2]);
}
NETLIB_UPDATE(7411_dip)
{
/* only called during startup */
m_1.update_dev();
m_2.update_dev();
m_3.update_dev();
m_1->update_dev();
m_2->update_dev();
m_3->update_dev();
}
NETLIB_RESET(7411_dip)
{
m_1.do_reset();
m_2.do_reset();
m_3.do_reset();
m_1->do_reset();
m_2->do_reset();
m_3->do_reset();
}
NETLIB_NAMESPACE_DEVICES_END()

6
src/lib/netlist/devices/nld_7411.h
View File

@ -55,9 +55,9 @@ NETLIB_SIGNAL(7411, 3, 0, 1);
NETLIB_DEVICE(7411_dip,
NETLIB_NAME(7411) m_1;
NETLIB_NAME(7411) m_2;
NETLIB_NAME(7411) m_3;
NETLIB_SUB(7411) m_1;
NETLIB_SUB(7411) m_2;
NETLIB_SUB(7411) m_3;
);
NETLIB_NAMESPACE_DEVICES_END()

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

@ -31,10 +31,10 @@ NETLIB_START(74123)
register_input("_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);
register_subalias("RC", m_RN.m_R.m_P);
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);
register_subalias("RC", m_RN->m_R->m_P);
if (m_dev_type == 4538)
register_param("K", m_K, 0.4);
@ -43,11 +43,11 @@ NETLIB_START(74123)
register_param("RI", m_RI, 400.0); // around 250 for HC series, 400 on LS/TTL, estimated from datasheets
connect_late(m_RP_Q, m_RP.m_I);
connect_late(m_RN_Q, m_RN.m_I);
connect_late(m_RP_Q, m_RP->m_I);
connect_late(m_RN_Q, m_RN->m_I);
connect_late(m_RN.m_R.m_P, m_RP.m_R.m_N);
connect_late(m_CV, m_RN.m_R.m_P);
connect_late(m_RN->m_R->m_P, m_RP->m_R->m_N);
connect_late(m_CV, m_RN->m_R->m_P);
save(NLNAME(m_last_trig));
save(NLNAME(m_state));
@ -107,7 +107,7 @@ NETLIB_UPDATE(74123)
if (m_state == 1)
{
const nl_double vLow = m_KP * TERMANALOG(m_RP.m_R.m_P);
const nl_double vLow = m_KP * TERMANALOG(m_RP->m_R->m_P);
if (INPANALOG(m_CV) < vLow)
{
OUTLOGIC(m_RN_Q, 0, NLTIME_FROM_NS(10)); // R_OFF
@ -116,7 +116,7 @@ NETLIB_UPDATE(74123)
}
if (m_state == 2)
{
const nl_double vHigh = TERMANALOG(m_RP.m_R.m_P) * (1.0 - m_KP);
const nl_double vHigh = TERMANALOG(m_RP->m_R->m_P) * (1.0 - m_KP);
if (INPANALOG(m_CV) > vHigh)
{
OUTLOGIC(m_RP_Q, 0, NLTIME_FROM_NS(10)); // R_OFF
@ -132,11 +132,11 @@ NETLIB_RESET(74123)
{
m_KP = 1.0 / (1.0 + exp(m_K.Value()));
m_RP.do_reset();
m_RN.do_reset();
m_RP->do_reset();
m_RN->do_reset();
//m_RP.set_R(R_OFF);
//m_RN.set_R(R_OFF);
//m_RP->set_R(R_OFF);
//m_RN->set_R(R_OFF);
m_last_trig = 0;
m_state = 0;
@ -147,122 +147,123 @@ NETLIB_START(74123_dip)
register_sub("1", m_1);
register_sub("2", m_2);
register_subalias("1", m_1.m_A);
register_subalias("2", m_1.m_B);
register_subalias("3", m_1.m_CLRQ);
register_subalias("4", m_1.m_QQ);
register_subalias("5", m_2.m_Q);
register_subalias("6", m_2.m_RN.m_R.m_N);
register_subalias("7", m_2.m_RN.m_R.m_P);
register_subalias("8", m_1.m_RN.m_R.m_N);
connect_late(m_1.m_RN.m_R.m_N, m_2.m_RN.m_R.m_N);
register_subalias("1", m_1->m_A);
register_subalias("2", m_1->m_B);
register_subalias("3", m_1->m_CLRQ);
register_subalias("4", m_1->m_QQ);
register_subalias("5", m_2->m_Q);
register_subalias("6", m_2->m_RN->m_R->m_N);
register_subalias("7", m_2->m_RN->m_R->m_P);
register_subalias("8", m_1->m_RN->m_R->m_N);
connect_late(m_1->m_RN->m_R->m_N, m_2->m_RN->m_R->m_N);
register_subalias("9", m_2.m_A);
register_subalias("10", m_2.m_B);
register_subalias("11", m_2.m_CLRQ);
register_subalias("12", m_2.m_QQ);
register_subalias("13", m_1.m_Q);
register_subalias("14", m_1.m_RN.m_R.m_N);
register_subalias("15", m_1.m_RN.m_R.m_P);
register_subalias("16", m_1.m_RP.m_R.m_P);
connect_late(m_1.m_RP.m_R.m_P, m_2.m_RP.m_R.m_P);
register_subalias("9", m_2->m_A);
register_subalias("10", m_2->m_B);
register_subalias("11", m_2->m_CLRQ);
register_subalias("12", m_2->m_QQ);
register_subalias("13", m_1->m_Q);
register_subalias("14", m_1->m_RN->m_R->m_N);
register_subalias("15", m_1->m_RN->m_R->m_P);
register_subalias("16", m_1->m_RP->m_R->m_P);
connect_late(m_1->m_RP->m_R->m_P, m_2->m_RP->m_R->m_P);
}
NETLIB_UPDATE(74123_dip)
{
/* only called during startup */
m_1.update_dev();
m_2.update_dev();
m_1->update_dev();
m_2->update_dev();
}
NETLIB_RESET(74123_dip)
{
m_1.do_reset();
m_2.do_reset();
m_1->do_reset();
m_2->do_reset();
}
NETLIB_START(9602_dip)
{
m_1.m_dev_type = 9602;
m_2.m_dev_type = 9602;
register_sub("1", m_1);
register_sub("2", m_2);
register_subalias("1", m_1.m_RN.m_R.m_N); // C1
register_subalias("2", m_1.m_RN.m_R.m_P); // RC1
register_subalias("3", m_1.m_CLRQ);
register_subalias("4", m_1.m_B);
register_subalias("5", m_1.m_A);
register_subalias("6", m_1.m_Q);
register_subalias("7", m_1.m_QQ);
register_subalias("8", m_1.m_RN.m_R.m_N);
connect_late(m_1.m_RN.m_R.m_N, m_2.m_RN.m_R.m_N);
m_1->m_dev_type = 9602;
m_2->m_dev_type = 9602;
register_subalias("9", m_2.m_QQ);
register_subalias("10", m_2.m_Q);
register_subalias("11", m_2.m_A);
register_subalias("12", m_2.m_B);
register_subalias("13", m_2.m_CLRQ);
register_subalias("14", m_2.m_RN.m_R.m_P); // RC2
register_subalias("15", m_2.m_RN.m_R.m_N); // C2
register_subalias("16", m_1.m_RP.m_R.m_P);
connect_late(m_1.m_RP.m_R.m_P, m_2.m_RP.m_R.m_P);
register_subalias("1", m_1->m_RN->m_R->m_N); // C1
register_subalias("2", m_1->m_RN->m_R->m_P); // RC1
register_subalias("3", m_1->m_CLRQ);
register_subalias("4", m_1->m_B);
register_subalias("5", m_1->m_A);
register_subalias("6", m_1->m_Q);
register_subalias("7", m_1->m_QQ);
register_subalias("8", m_1->m_RN->m_R->m_N);
connect_late(m_1->m_RN->m_R->m_N, m_2->m_RN->m_R->m_N);
register_subalias("9", m_2->m_QQ);
register_subalias("10", m_2->m_Q);
register_subalias("11", m_2->m_A);
register_subalias("12", m_2->m_B);
register_subalias("13", m_2->m_CLRQ);
register_subalias("14", m_2->m_RN->m_R->m_P); // RC2
register_subalias("15", m_2->m_RN->m_R->m_N); // C2
register_subalias("16", m_1->m_RP->m_R->m_P);
connect_late(m_1->m_RP->m_R->m_P, m_2->m_RP->m_R->m_P);
}
NETLIB_UPDATE(9602_dip)
{
/* only called during startup */
m_1.update_dev();
m_2.update_dev();
m_1->update_dev();
m_2->update_dev();
}
NETLIB_RESET(9602_dip)
{
m_1.do_reset();
m_2.do_reset();
m_1->do_reset();
m_2->do_reset();
}
NETLIB_START(4538_dip)
{
m_1.m_dev_type = 4538;
m_2.m_dev_type = 4538;
m_1->m_dev_type = 4538;
m_2->m_dev_type = 4538;
register_sub("1", m_1);
register_sub("2", m_2);
register_subalias("1", m_1.m_RN.m_R.m_N); // C1
register_subalias("2", m_1.m_RN.m_R.m_P); // RC1
register_subalias("3", m_1.m_CLRQ);
register_subalias("4", m_1.m_A);
register_subalias("5", m_1.m_B);
register_subalias("6", m_1.m_Q);
register_subalias("7", m_1.m_QQ);
register_subalias("8", m_1.m_RN.m_R.m_N);
connect_late(m_1.m_RN.m_R.m_N, m_2.m_RN.m_R.m_N);
register_subalias("1", m_1->m_RN->m_R->m_N); // C1
register_subalias("2", m_1->m_RN->m_R->m_P); // RC1
register_subalias("3", m_1->m_CLRQ);
register_subalias("4", m_1->m_A);
register_subalias("5", m_1->m_B);
register_subalias("6", m_1->m_Q);
register_subalias("7", m_1->m_QQ);
register_subalias("8", m_1->m_RN->m_R->m_N);
connect_late(m_1->m_RN->m_R->m_N, m_2->m_RN->m_R->m_N);
register_subalias("9", m_2.m_QQ);
register_subalias("10", m_2.m_Q);
register_subalias("11", m_2.m_B);
register_subalias("12", m_2.m_A);
register_subalias("13", m_2.m_CLRQ);
register_subalias("14", m_2.m_RN.m_R.m_P); // RC2
register_subalias("15", m_2.m_RN.m_R.m_N); // C2
register_subalias("16", m_1.m_RP.m_R.m_P);
connect_late(m_1.m_RP.m_R.m_P, m_2.m_RP.m_R.m_P);
register_subalias("9", m_2->m_QQ);
register_subalias("10", m_2->m_Q);
register_subalias("11", m_2->m_B);
register_subalias("12", m_2->m_A);
register_subalias("13", m_2->m_CLRQ);
register_subalias("14", m_2->m_RN->m_R->m_P); // RC2
register_subalias("15", m_2->m_RN->m_R->m_N); // C2
register_subalias("16", m_1->m_RP->m_R->m_P);
connect_late(m_1->m_RP->m_R->m_P, m_2->m_RP->m_R->m_P);
}
NETLIB_UPDATE(4538_dip)
{
/* only called during startup */
m_1.update_dev();
m_2.update_dev();
m_1->update_dev();
m_2->update_dev();
}
NETLIB_RESET(4538_dip)
{
m_1.do_reset();
m_2.do_reset();
m_1->do_reset();
m_2->do_reset();
}
NETLIB_NAMESPACE_DEVICES_END()

16
src/lib/netlist/devices/nld_74123.h
View File

@ -60,8 +60,8 @@ NETLIB_NAMESPACE_DEVICES_START()
NETLIB_DEVICE(74123,
public:
NETLIB_NAME(res_sw) m_RP;
NETLIB_NAME(res_sw) m_RN;
NETLIB_SUB(res_sw) m_RP;
NETLIB_SUB(res_sw) m_RN;
logic_output_t m_RP_Q;
logic_output_t m_RN_Q;
@ -89,8 +89,8 @@ public:
NETLIB_DEVICE(74123_dip,
NETLIB_NAME(74123) m_1;
NETLIB_NAME(74123) m_2;
NETLIB_SUB(74123) m_1;
NETLIB_SUB(74123) m_2;
);
@ -103,8 +103,8 @@ NETLIB_DEVICE(74123_dip,
NETLIB_DEVICE(9602_dip,
NETLIB_NAME(74123) m_1;
NETLIB_NAME(74123) m_2;
NETLIB_SUB(74123) m_1;
NETLIB_SUB(74123) m_2;
);
@ -117,8 +117,8 @@ NETLIB_DEVICE(9602_dip,
NETLIB_DEVICE(4538_dip,
NETLIB_LOGIC_FAMILY(CD4XXX)
NETLIB_NAME(74123) m_1;
NETLIB_NAME(74123) m_2;
NETLIB_SUB(74123) m_1;
NETLIB_SUB(74123) m_2;
);
NETLIB_NAMESPACE_DEVICES_END()

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

@ -53,15 +53,15 @@ NETLIB_START(74153)
{
register_sub("sub", m_sub);
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]);
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]);
register_input("A", m_A);
register_input("B", m_B);
register_subalias("G", m_sub.m_G);
register_subalias("G", m_sub->m_G);
register_subalias("AY", m_sub.m_Y); //FIXME: Change netlists
register_subalias("AY", m_sub->m_Y); //FIXME: Change netlists
}
NETLIB_RESET(74153)
@ -72,8 +72,8 @@ NETLIB_RESET(74153)
NETLIB_UPDATE(74153)
{
m_sub.m_chan = (INPLOGIC(m_A) | (INPLOGIC(m_B)<<1));
m_sub.update();
m_sub->m_chan = (INPLOGIC(m_A) | (INPLOGIC(m_B)<<1));
m_sub->update();
}
@ -82,35 +82,35 @@ NETLIB_START(74153_dip)
register_sub("1", m_1);
register_sub("2", m_2);
register_subalias("1", m_1.m_G);
register_input("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]);
register_subalias("6", m_1.m_C[0]);
register_subalias("7", m_1.m_Y);
register_subalias("1", m_1->m_G);
register_input("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]);
register_subalias("6", m_1->m_C[0]);
register_subalias("7", m_1->m_Y);
register_subalias("9", m_2.m_Y);
register_subalias("10", m_2.m_C[0]);
register_subalias("11", m_2.m_C[1]);
register_subalias("12", m_2.m_C[2]);
register_subalias("13", m_2.m_C[3]);
register_subalias("9", m_2->m_Y);
register_subalias("10", m_2->m_C[0]);
register_subalias("11", m_2->m_C[1]);
register_subalias("12", m_2->m_C[2]);
register_subalias("13", m_2->m_C[3]);
register_input("14", m_A); // m_2.m_B
register_subalias("15", m_2.m_G);
register_input("14", m_A); // m_2->m_B
register_subalias("15", m_2->m_G);
}
NETLIB_UPDATE(74153_dip)
{
m_2.m_chan = m_1.m_chan = (INPLOGIC(m_A) | (INPLOGIC(m_B)<<1));
m_1.update();
m_2.update();
m_2->m_chan = m_1->m_chan = (INPLOGIC(m_A) | (INPLOGIC(m_B)<<1));
m_1->update();
m_2->update();
}
NETLIB_RESET(74153_dip)
{
m_1.do_reset();
m_2.do_reset();
m_1->do_reset();
m_2->do_reset();
}
NETLIB_NAMESPACE_DEVICES_END()

6
src/lib/netlist/devices/nld_74153.h
View File

@ -73,15 +73,15 @@ NETLIB_SUBDEVICE(74153sub,
NETLIB_DEVICE(74153,
public:
NETLIB_NAME(74153sub) m_sub;
NETLIB_SUB(74153sub) m_sub;
logic_input_t m_A;
logic_input_t m_B;
);
NETLIB_DEVICE(74153_dip,
NETLIB_NAME(74153sub) m_1;
NETLIB_NAME(74153sub) m_2;
NETLIB_SUB(74153sub) m_1;
NETLIB_SUB(74153sub) m_2;
logic_input_t m_A;
logic_input_t m_B;
);

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

@ -57,19 +57,19 @@ NETLIB_UPDATE(74175)
{
d |= (INPLOGIC(m_D[i]) << i);
}
m_sub.m_clrq = INPLOGIC(m_CLRQ);
if (!m_sub.m_clrq)
m_sub->m_clrq = INPLOGIC(m_CLRQ);
if (!m_sub->m_clrq)
{
for (int i=0; i<4; i++)
{
OUTLOGIC(m_sub.m_Q[i], 0, delay_clear[0]);
OUTLOGIC(m_sub.m_QQ[i], 1, delay_clear[1]);
OUTLOGIC(m_sub->m_Q[i], 0, delay_clear[0]);
OUTLOGIC(m_sub->m_QQ[i], 1, delay_clear[1]);
}
m_sub.m_data = 0;
} else if (d != m_sub.m_data)
m_sub->m_data = 0;
} else if (d != m_sub->m_data)
{
m_sub.m_data = d;
m_sub.m_CLK.activate_lh();
m_sub->m_data = d;
m_sub->m_CLK.activate_lh();
}
}
@ -77,55 +77,55 @@ NETLIB_START(74175)
{
register_sub("sub", m_sub);
register_subalias("CLK", m_sub.m_CLK);
register_subalias("CLK", m_sub->m_CLK);
register_input("CLRQ", m_CLRQ);
register_input("D1", m_D[0]);
register_subalias("Q1", m_sub.m_Q[0]);
register_subalias("Q1Q", m_sub.m_QQ[0]);
register_subalias("Q1", m_sub->m_Q[0]);
register_subalias("Q1Q", m_sub->m_QQ[0]);
register_input("D2", m_D[1]);
register_subalias("Q2", m_sub.m_Q[1]);
register_subalias("Q2Q", m_sub.m_QQ[1]);
register_subalias("Q2", m_sub->m_Q[1]);
register_subalias("Q2Q", m_sub->m_QQ[1]);
register_input("D3", m_D[2]);
register_subalias("Q3", m_sub.m_Q[2]);
register_subalias("Q3Q", m_sub.m_QQ[2]);
register_subalias("Q3", m_sub->m_Q[2]);
register_subalias("Q3Q", m_sub->m_QQ[2]);
register_input("D4", m_D[3]);
register_subalias("Q4", m_sub.m_Q[3]);
register_subalias("Q4Q", m_sub.m_QQ[3]);
register_subalias("Q4", m_sub->m_Q[3]);
register_subalias("Q4Q", m_sub->m_QQ[3]);
}
NETLIB_RESET(74175)
{
m_sub.do_reset();
m_sub->do_reset();
}
NETLIB_START(74175_dip)
{
register_sub("sub", m_sub);
register_subalias("9", m_sub.m_CLK);
register_subalias("9", m_sub->m_CLK);
register_input("1", m_CLRQ);
register_input("4", m_D[0]);
register_subalias("2", m_sub.m_Q[0]);
register_subalias("3", m_sub.m_QQ[0]);
register_subalias("2", m_sub->m_Q[0]);
register_subalias("3", m_sub->m_QQ[0]);
register_input("5", m_D[1]);
register_subalias("7", m_sub.m_Q[1]);
register_subalias("6", m_sub.m_QQ[1]);
register_subalias("7", m_sub->m_Q[1]);
register_subalias("6", m_sub->m_QQ[1]);
register_input("12", m_D[2]);
register_subalias("10", m_sub.m_Q[2]);
register_subalias("11", m_sub.m_QQ[2]);
register_subalias("10", m_sub->m_Q[2]);
register_subalias("11", m_sub->m_QQ[2]);
register_input("13", m_D[3]);
register_subalias("15", m_sub.m_Q[3]);
register_subalias("14", m_sub.m_QQ[3]);
register_subalias("15", m_sub->m_Q[3]);
register_subalias("14", m_sub->m_QQ[3]);
}

2
src/lib/netlist/devices/nld_74175.h
View File

@ -57,7 +57,7 @@ NETLIB_SUBDEVICE(74175_sub,
NETLIB_DEVICE(74175,
NETLIB_NAME(74175_sub) m_sub;
NETLIB_SUB(74175_sub) m_sub;
logic_input_t m_D[4];
logic_input_t m_CLRQ;
);

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

@ -14,10 +14,10 @@ NETLIB_NAMESPACE_DEVICES_START()
NETLIB_START(74192)
{
register_sub("subABCD", m_ABCD);
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);
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);
register_input("CLEAR", m_CLEAR);
register_input("LOADQ", m_LOADQ);
register_input("CU", m_CU);
@ -62,7 +62,7 @@ NETLIB_UPDATE(74192)
}
else if (!INPLOGIC(m_LOADQ))
{
m_cnt = m_ABCD.read_ABCD();
m_cnt = m_ABCD->read_ABCD();
}
else
{
@ -105,7 +105,7 @@ NETLIB_START(74192_dip)
{
NETLIB_NAME(74192)::start();
register_subalias("1", m_ABCD.m_B);
register_subalias("1", m_ABCD->m_B);
register_subalias("2", m_Q[1]);
register_subalias("3", m_Q[0]);
register_subalias("4", m_CD);
@ -113,13 +113,13 @@ NETLIB_START(74192_dip)
register_subalias("6", m_Q[2]);
register_subalias("7", m_Q[3]);
register_subalias("9", m_ABCD.m_D);
register_subalias("10", m_ABCD.m_C);
register_subalias("9", m_ABCD->m_D);
register_subalias("10", m_ABCD->m_C);
register_subalias("11", m_LOADQ);
register_subalias("12", m_CARRYQ);
register_subalias("13", m_BORROWQ);
register_subalias("14", m_CLEAR);
register_subalias("15", m_ABCD.m_A);
register_subalias("15", m_ABCD->m_A);
}

2
src/lib/netlist/devices/nld_74192.h
View File

@ -43,7 +43,7 @@ NETLIB_NAMESPACE_DEVICES_START()
NETLIB_DEVICE(74192,
ATTR_HOT void update_outputs();
NETLIB_NAME(9316_subABCD) m_ABCD;
NETLIB_SUB(9316_subABCD) m_ABCD;
logic_input_t m_CLEAR;
logic_input_t m_LOADQ;
logic_input_t m_CU;

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

@ -27,33 +27,33 @@ NETLIB_START(7420_dip)
register_sub("1", m_1);
register_sub("2", m_2);
register_subalias("1", m_1.m_I[0]);
register_subalias("2", m_1.m_I[1]);
register_subalias("1", m_1->m_I[0]);
register_subalias("2", m_1->m_I[1]);
register_subalias("4", m_1.m_I[2]);
register_subalias("5", m_1.m_I[3]);
register_subalias("6", m_1.m_Q[0]);
register_subalias("4", m_1->m_I[2]);
register_subalias("5", m_1->m_I[3]);
register_subalias("6", m_1->m_Q[0]);
register_subalias("8", m_2.m_Q[0]);
register_subalias("9", m_2.m_I[0]);
register_subalias("10", m_2.m_I[1]);
register_subalias("8", m_2->m_Q[0]);
register_subalias("9", m_2->m_I[0]);
register_subalias("10", m_2->m_I[1]);
register_subalias("12", m_2.m_I[2]);
register_subalias("13", m_2.m_I[3]);
register_subalias("12", m_2->m_I[2]);
register_subalias("13", m_2->m_I[3]);
}
NETLIB_UPDATE(7420_dip)
{
/* only called during startup */
m_1.update_dev();
m_2.update_dev();
m_1->update_dev();
m_2->update_dev();
}
NETLIB_RESET(7420_dip)
{
m_1.do_reset();
m_2.do_reset();
m_1->do_reset();
m_2->do_reset();
}
NETLIB_NAMESPACE_DEVICES_END()

4
src/lib/netlist/devices/nld_7420.h
View File

@ -57,8 +57,8 @@ NETLIB_SIGNAL(7420, 4, 0, 0);
NETLIB_DEVICE(7420_dip,
NETLIB_NAME(7420) m_1;
NETLIB_NAME(7420) m_2;
NETLIB_SUB(7420) m_1;
NETLIB_SUB(7420) m_2;
);
NETLIB_NAMESPACE_DEVICES_END()

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

@ -14,37 +14,37 @@ NETLIB_START(7425_dip)
register_sub("1", m_1);
register_sub("2", m_2);
register_subalias("1", m_1.m_I[0]);
register_subalias("2", m_1.m_I[1]);
register_subalias("1", m_1->m_I[0]);
register_subalias("2", m_1->m_I[1]);
//register_subalias("3", ); X1 ==> NC
register_subalias("4", m_1.m_I[2]);
register_subalias("5", m_1.m_I[3]);
register_subalias("6", m_1.m_Q[0]);
register_subalias("4", m_1->m_I[2]);
register_subalias("5", m_1->m_I[3]);
register_subalias("6", m_1->m_Q[0]);
register_subalias("8", m_2.m_Q[0]);
register_subalias("9", m_2.m_I[0]);
register_subalias("10", m_2.m_I[1]);
register_subalias("8", m_2->m_Q[0]);
register_subalias("9", m_2->m_I[0]);
register_subalias("10", m_2->m_I[1]);
//register_subalias("11", ); X2 ==> NC
register_subalias("12", m_2.m_I[2]);
register_subalias("13", m_2.m_I[3]);
register_subalias("12", m_2->m_I[2]);
register_subalias("13", m_2->m_I[3]);
}
NETLIB_UPDATE(7425_dip)
{
/* only called during startup */
m_1.update_dev();
m_2.update_dev();
m_1->update_dev();
m_2->update_dev();
}
NETLIB_RESET(7425_dip)
{
m_1.do_reset();
m_2.do_reset();
m_1->do_reset();
m_2->do_reset();
}
NETLIB_NAMESPACE_DEVICES_END()

4
src/lib/netlist/devices/nld_7425.h
View File

@ -54,8 +54,8 @@ NETLIB_SIGNAL(7425, 4, 1, 0);
NETLIB_DEVICE(7425_dip,
NETLIB_NAME(7425) m_1;
NETLIB_NAME(7425) m_2;
NETLIB_SUB(7425) m_1;
NETLIB_SUB(7425) m_2;
);
NETLIB_NAMESPACE_DEVICES_END()

36
src/lib/netlist/devices/nld_7427.cpp
View File

@ -29,35 +29,35 @@ NETLIB_START(7427_dip)
register_sub("2", m_2);
register_sub("3", m_3);
register_subalias("1", m_1.m_I[0]);
register_subalias("2", m_1.m_I[1]);
register_subalias("3", m_2.m_I[0]);
register_subalias("4", m_2.m_I[1]);
register_subalias("5", m_2.m_I[2]);
register_subalias("6", m_2.m_Q[0]);
register_subalias("1", m_1->m_I[0]);
register_subalias("2", m_1->m_I[1]);
register_subalias("3", m_2->m_I[0]);
register_subalias("4", m_2->m_I[1]);
register_subalias("5", m_2->m_I[2]);
register_subalias("6", m_2->m_Q[0]);
register_subalias("8", m_3.m_Q[0]);
register_subalias("9", m_3.m_I[0]);
register_subalias("10", m_3.m_I[1]);
register_subalias("11", m_3.m_I[2]);
register_subalias("8", m_3->m_Q[0]);
register_subalias("9", m_3->m_I[0]);
register_subalias("10", m_3->m_I[1]);
register_subalias("11", m_3->m_I[2]);
register_subalias("12", m_1.m_Q[0]);
register_subalias("13", m_1.m_I[2]);
register_subalias("12", m_1->m_Q[0]);
register_subalias("13", m_1->m_I[2]);
}
NETLIB_UPDATE(7427_dip)
{
/* only called during startup */
m_1.update_dev();
m_2.update_dev();
m_3.update_dev();
m_1->update_dev();
m_2->update_dev();
m_3->update_dev();
}
NETLIB_RESET(7427_dip)
{
m_1.do_reset();
m_2.do_reset();
m_3.do_reset();
m_1->do_reset();
m_2->do_reset();
m_3->do_reset();
}
NETLIB_NAMESPACE_DEVICES_END()

6
src/lib/netlist/devices/nld_7427.h
View File

@ -54,9 +54,9 @@ NETLIB_SIGNAL(7427, 3, 1, 0);
NETLIB_DEVICE(7427_dip,
NETLIB_NAME(7427) m_1;
NETLIB_NAME(7427) m_2;
NETLIB_NAME(7427) m_3;
NETLIB_SUB(7427) m_1;
NETLIB_SUB(7427) m_2;
NETLIB_SUB(7427) m_3;
);
NETLIB_NAMESPACE_DEVICES_END()

44
src/lib/netlist/devices/nld_74279.cpp
View File

@ -127,40 +127,40 @@ NETLIB_START(74279_dip)
register_sub("3", m_3);
register_sub("4", m_4);
register_subalias("1", m_1.m_I[2]); //R
register_subalias("2", m_1.m_I[0]);
register_subalias("3", m_1.m_I[1]);
register_subalias("4", m_1.m_Q[0]);
register_subalias("1", m_1->m_I[2]); //R
register_subalias("2", m_1->m_I[0]);
register_subalias("3", m_1->m_I[1]);
register_subalias("4", m_1->m_Q[0]);
register_subalias("5", m_2.m_I[1]); //R
register_subalias("6", m_2.m_I[0]);
register_subalias("7", m_2.m_Q[0]);
register_subalias("5", m_2->m_I[1]); //R
register_subalias("6", m_2->m_I[0]);
register_subalias("7", m_2->m_Q[0]);
register_subalias("9", m_3.m_Q[0]);
register_subalias("10", m_3.m_I[2]); //R
register_subalias("11", m_3.m_I[0]);
register_subalias("12", m_3.m_I[1]);
register_subalias("9", m_3->m_Q[0]);
register_subalias("10", m_3->m_I[2]); //R
register_subalias("11", m_3->m_I[0]);
register_subalias("12", m_3->m_I[1]);
register_subalias("13", m_4.m_Q[0]);
register_subalias("14", m_4.m_I[1]); //R
register_subalias("15", m_4.m_I[0]);
register_subalias("13", m_4->m_Q[0]);
register_subalias("14", m_4->m_I[1]); //R
register_subalias("15", m_4->m_I[0]);
}
NETLIB_UPDATE(74279_dip)
{
/* only called during startup */
m_1.update_dev();
m_2.update_dev();
m_3.update_dev();
m_4.update_dev();
m_1->update_dev();
m_2->update_dev();
m_3->update_dev();
m_4->update_dev();
}
NETLIB_RESET(74279_dip)
{
m_1.do_reset();
m_2.do_reset();
m_3.do_reset();
m_4.do_reset();
m_1->do_reset();
m_2->do_reset();
m_3->do_reset();
m_4->do_reset();
}
NETLIB_NAMESPACE_DEVICES_END()

8
src/lib/netlist/devices/nld_74279.h
View File

@ -55,10 +55,10 @@ NETLIB_TRUTHTABLE(74279B, 4, 1, 0);
NETLIB_DEVICE(74279_dip,
NETLIB_NAME(74279B) m_1;
NETLIB_NAME(74279A) m_2;
NETLIB_NAME(74279B) m_3;
NETLIB_NAME(74279A) m_4;
NETLIB_SUB(74279B) m_1;
NETLIB_SUB(74279A) m_2;
NETLIB_SUB(74279B) m_3;
NETLIB_SUB(74279A) m_4;
);
NETLIB_NAMESPACE_DEVICES_END()

22
src/lib/netlist/devices/nld_7430.cpp
View File

@ -32,28 +32,28 @@ NETLIB_START(7430_dip)
{
register_sub("1", m_1);
register_subalias("1", m_1.m_I[0]);
register_subalias("2", m_1.m_I[1]);
register_subalias("3", m_1.m_I[2]);
register_subalias("4", m_1.m_I[3]);
register_subalias("5", m_1.m_I[4]);
register_subalias("6", m_1.m_I[5]);
register_subalias("1", m_1->m_I[0]);
register_subalias("2", m_1->m_I[1]);
register_subalias("3", m_1->m_I[2]);
register_subalias("4", m_1->m_I[3]);
register_subalias("5", m_1->m_I[4]);
register_subalias("6", m_1->m_I[5]);
register_subalias("8", m_1.m_Q[0]);
register_subalias("8", m_1->m_Q[0]);
register_subalias("11", m_1.m_I[6]);
register_subalias("12", m_1.m_I[7]);
register_subalias("11", m_1->m_I[6]);
register_subalias("12", m_1->m_I[7]);
}
NETLIB_UPDATE(7430_dip)
{
/* only called during startup */
m_1.update_dev();
m_1->update_dev();
}
NETLIB_RESET(7430_dip)
{
m_1.do_reset();
m_1->do_reset();
}
NETLIB_NAMESPACE_DEVICES_END()

2
src/lib/netlist/devices/nld_7430.h
View File

@ -66,7 +66,7 @@ NETLIB_SIGNAL(7430, 8, 0, 0);
NETLIB_DEVICE(7430_dip,
NETLIB_NAME(7430) m_1;
NETLIB_SUB(7430) m_1;
);
NETLIB_NAMESPACE_DEVICES_END()

40
src/lib/netlist/devices/nld_7432.cpp
View File

@ -28,38 +28,38 @@ NETLIB_START(7432_dip)
register_sub("3", m_3);
register_sub("4", m_4);
register_subalias("3", m_1.m_Q[0]);
register_subalias("1", m_1.m_I[0]);
register_subalias("2", m_1.m_I[1]);
register_subalias("3", m_1->m_Q[0]);
register_subalias("1", m_1->m_I[0]);
register_subalias("2", m_1->m_I[1]);
register_subalias("6", m_2.m_Q[0]);
register_subalias("4", m_2.m_I[0]);
register_subalias("5", m_2.m_I[1]);
register_subalias("6", m_2->m_Q[0]);
register_subalias("4", m_2->m_I[0]);
register_subalias("5", m_2->m_I[1]);
register_subalias("9", m_3.m_I[0]);
register_subalias("10", m_3.m_I[1]);
register_subalias("8", m_3.m_Q[0]);
register_subalias("9", m_3->m_I[0]);
register_subalias("10", m_3->m_I[1]);
register_subalias("8", m_3->m_Q[0]);
register_subalias("12", m_4.m_I[0]);
register_subalias("13", m_4.m_I[1]);
register_subalias("11", m_4.m_Q[0]);
register_subalias("12", m_4->m_I[0]);
register_subalias("13", m_4->m_I[1]);
register_subalias("11", m_4->m_Q[0]);
}
NETLIB_UPDATE(7432_dip)
{
/* only called during startup */
m_1.update_dev();
m_2.update_dev();
m_3.update_dev();
m_4.update_dev();
m_1->update_dev();
m_2->update_dev();
m_3->update_dev();
m_4->update_dev();
}
NETLIB_RESET(7432_dip)
{
m_1.do_reset();
m_2.do_reset();
m_3.do_reset();
m_4.do_reset();
m_1->do_reset();
m_2->do_reset();
m_3->do_reset();
m_4->do_reset();
}
NETLIB_NAMESPACE_DEVICES_END()

8
src/lib/netlist/devices/nld_7432.h
View File

@ -53,10 +53,10 @@ NETLIB_SIGNAL(7432, 2, 1, 1);
NETLIB_DEVICE(7432_dip,
NETLIB_NAME(7432) m_1;
NETLIB_NAME(7432) m_2;
NETLIB_NAME(7432) m_3;
NETLIB_NAME(7432) m_4;
NETLIB_SUB(7432) m_1;
NETLIB_SUB(7432) m_2;
NETLIB_SUB(7432) m_3;
NETLIB_SUB(7432) m_4;
);
NETLIB_NAMESPACE_DEVICES_END()

40
src/lib/netlist/devices/nld_7437.cpp
View File

@ -28,38 +28,38 @@ NETLIB_START(7437_dip)
register_sub("3", m_3);
register_sub("4", m_4);
register_subalias("1", m_1.m_I[0]);
register_subalias("2", m_1.m_I[1]);
register_subalias("3", m_1.m_Q[0]);
register_subalias("1", m_1->m_I[0]);
register_subalias("2", m_1->m_I[1]);
register_subalias("3", m_1->m_Q[0]);
register_subalias("4", m_2.m_I[0]);
register_subalias("5", m_2.m_I[1]);
register_subalias("6", m_2.m_Q[0]);
register_subalias("4", m_2->m_I[0]);
register_subalias("5", m_2->m_I[1]);
register_subalias("6", m_2->m_Q[0]);
register_subalias("9", m_3.m_I[0]);
register_subalias("10", m_3.m_I[1]);
register_subalias("8", m_3.m_Q[0]);
register_subalias("9", m_3->m_I[0]);
register_subalias("10", m_3->m_I[1]);
register_subalias("8", m_3->m_Q[0]);
register_subalias("12", m_4.m_I[0]);
register_subalias("13", m_4.m_I[1]);
register_subalias("11", m_4.m_Q[0]);
register_subalias("12", m_4->m_I[0]);
register_subalias("13", m_4->m_I[1]);
register_subalias("11", m_4->m_Q[0]);
}
NETLIB_UPDATE(7437_dip)
{
/* only called during startup */
m_1.update_dev();
m_2.update_dev();
m_3.update_dev();
m_4.update_dev();
m_1->update_dev();
m_2->update_dev();
m_3->update_dev();
m_4->update_dev();
}
NETLIB_RESET(7437_dip)
{
m_1.do_reset();
m_2.do_reset();
m_3.do_reset();
m_4.do_reset();
m_1->do_reset();
m_2->do_reset();
m_3->do_reset();
m_4->do_reset();
}
NETLIB_NAMESPACE_DEVICES_END()

8
src/lib/netlist/devices/nld_7437.h
View File

@ -56,10 +56,10 @@ NETLIB_SIGNAL(7437, 2, 0, 0);
NETLIB_DEVICE(7437_dip,
NETLIB_NAME(7437) m_1;
NETLIB_NAME(7437) m_2;
NETLIB_NAME(7437) m_3;
NETLIB_NAME(7437) m_4;
NETLIB_SUB(7437) m_1;
NETLIB_SUB(7437) m_2;
NETLIB_SUB(7437) m_3;
NETLIB_SUB(7437) m_4;
);
NETLIB_NAMESPACE_DEVICES_END()

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

@ -67,55 +67,55 @@ NETLIB_START(7448)
{
register_sub("sub", sub);
register_subalias("A", sub.m_A);
register_subalias("B", sub.m_B);
register_subalias("C", sub.m_C);
register_subalias("D", sub.m_D);
register_subalias("A", sub->m_A);
register_subalias("B", sub->m_B);
register_subalias("C", sub->m_C);
register_subalias("D", sub->m_D);
register_input("LTQ", m_LTQ);
register_input("BIQ", m_BIQ);
register_subalias("RBIQ",sub.m_RBIQ);
register_subalias("RBIQ",sub->m_RBIQ);
register_subalias("a", sub.m_Q[0]);
register_subalias("b", sub.m_Q[1]);
register_subalias("c", sub.m_Q[2]);
register_subalias("d", sub.m_Q[3]);
register_subalias("e", sub.m_Q[4]);
register_subalias("f", sub.m_Q[5]);
register_subalias("g", sub.m_Q[6]);
register_subalias("a", sub->m_Q[0]);
register_subalias("b", sub->m_Q[1]);
register_subalias("c", sub->m_Q[2]);
register_subalias("d", sub->m_Q[3]);
register_subalias("e", sub->m_Q[4]);
register_subalias("f", sub->m_Q[5]);
register_subalias("g", sub->m_Q[6]);
}
NETLIB_RESET(7448)
{
sub.do_reset();
sub->do_reset();
}
NETLIB_UPDATE(7448)
{
if (INPLOGIC(m_BIQ) && !INPLOGIC(m_LTQ))
{
sub.update_outputs(8);
sub->update_outputs(8);
}
else if (!INPLOGIC(m_BIQ))
{
sub.update_outputs(15);
sub->update_outputs(15);
}
if (!INPLOGIC(m_BIQ) || (INPLOGIC(m_BIQ) && !INPLOGIC(m_LTQ)))
{
sub.m_A.inactivate();
sub.m_B.inactivate();
sub.m_C.inactivate();
sub.m_D.inactivate();
sub.m_RBIQ.inactivate();
sub->m_A.inactivate();
sub->m_B.inactivate();
sub->m_C.inactivate();
sub->m_D.inactivate();
sub->m_RBIQ.inactivate();
} else {
sub.m_RBIQ.activate();
sub.m_D.activate();
sub.m_C.activate();
sub.m_B.activate();
sub.m_A.activate();
sub.update();
sub->m_RBIQ.activate();
sub->m_D.activate();
sub->m_C.activate();
sub->m_B.activate();
sub->m_A.activate();
sub->update();
}
}
@ -191,21 +191,21 @@ NETLIB_START(7448_dip)
{
NETLIB_NAME(7448)::start();
register_subalias("1", sub.m_B);
register_subalias("2", sub.m_C);
register_subalias("1", sub->m_B);
register_subalias("2", sub->m_C);
register_subalias("3", m_LTQ);
register_subalias("4", m_BIQ);
register_subalias("5",sub.m_RBIQ);
register_subalias("6", sub.m_D);
register_subalias("7", sub.m_A);
register_subalias("5",sub->m_RBIQ);
register_subalias("6", sub->m_D);
register_subalias("7", sub->m_A);
register_subalias("9", sub.m_Q[4]); // e
register_subalias("10", sub.m_Q[3]); // d
register_subalias("11", sub.m_Q[2]); // c
register_subalias("12", sub.m_Q[1]); // b
register_subalias("13", sub.m_Q[0]); // a
register_subalias("14", sub.m_Q[6]); // g
register_subalias("15", sub.m_Q[5]); // f
register_subalias("9", sub->m_Q[4]); // e
register_subalias("10", sub->m_Q[3]); // d
register_subalias("11", sub->m_Q[2]); // c
register_subalias("12", sub->m_Q[1]); // b
register_subalias("13", sub->m_Q[0]); // a
register_subalias("14", sub->m_Q[6]); // g
register_subalias("15", sub->m_Q[5]); // f
}
#endif

2
src/lib/netlist/devices/nld_7448.h
View File

@ -68,7 +68,7 @@ NETLIB_SUBDEVICE(7448_sub,
NETLIB_DEVICE(7448,
public:
NETLIB_NAME(7448_sub) sub;
NETLIB_SUB(7448_sub) sub;
logic_input_t m_LTQ;
logic_input_t m_BIQ;

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

@ -61,34 +61,34 @@ NETLIB_START(7450_dip)
register_sub("1", m_1);
register_sub("2", m_2);
register_subalias("1", m_1.m_A);
register_subalias("2", m_2.m_A);
register_subalias("3", m_2.m_B);
register_subalias("4", m_2.m_C);
register_subalias("5", m_2.m_D);
register_subalias("6", m_2.m_Q);
register_subalias("1", m_1->m_A);
register_subalias("2", m_2->m_A);
register_subalias("3", m_2->m_B);
register_subalias("4", m_2->m_C);
register_subalias("5", m_2->m_D);
register_subalias("6", m_2->m_Q);
//register_subalias("7",); GND
register_subalias("8", m_1.m_Q);
register_subalias("9", m_1.m_C);
register_subalias("10", m_1.m_D);
//register_subalias("11", m_1.m_X1);
//register_subalias("12", m_1.m_X1Q);
register_subalias("13", m_1.m_B);
register_subalias("8", m_1->m_Q);
register_subalias("9", m_1->m_C);
register_subalias("10", m_1->m_D);
//register_subalias("11", m_1->m_X1);
//register_subalias("12", m_1->m_X1Q);
register_subalias("13", m_1->m_B);
//register_subalias("14",); VCC
}
NETLIB_UPDATE(7450_dip)
{
/* only called during startup */
m_1.update_dev();
m_2.update_dev();
m_1->update_dev();
m_2->update_dev();
}
NETLIB_RESET(7450_dip)
{
m_1.do_reset();
m_2.do_reset();
m_1->do_reset();
m_2->do_reset();
}
NETLIB_NAMESPACE_DEVICES_END()

4
src/lib/netlist/devices/nld_7450.h
View File

@ -49,8 +49,8 @@ public:
NETLIB_DEVICE(7450_dip,
NETLIB_NAME(7450) m_1;
NETLIB_NAME(7450) m_2;
NETLIB_SUB(7450) m_1;
NETLIB_SUB(7450) m_2;
);
NETLIB_NAMESPACE_DEVICES_END()

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

@ -31,25 +31,25 @@ NETLIB_UPDATE(7474)
if (INPLOGIC(m_PREQ) && INPLOGIC(m_CLRQ))
{
m_D.activate();
sub.m_nextD = INPLOGIC(m_D);
sub.m_CLK.activate_lh();
sub->m_nextD = INPLOGIC(m_D);
sub->m_CLK.activate_lh();
}
else if (!INPLOGIC(m_PREQ))
{
sub.newstate(1, 0);
sub.m_CLK.inactivate();
sub->newstate(1, 0);
sub->m_CLK.inactivate();
m_D.inactivate();
}
else if (!INPLOGIC(m_CLRQ))
{
sub.newstate(0, 1);
sub.m_CLK.inactivate();
sub->newstate(0, 1);
sub->m_CLK.inactivate();
m_D.inactivate();
}
else
{
sub.newstate(1, 1);
sub.m_CLK.inactivate();
sub->newstate(1, 1);
sub->m_CLK.inactivate();
m_D.inactivate();
}
}
@ -58,19 +58,19 @@ NETLIB_START(7474)
{
register_sub("sub", sub);
register_subalias("CLK", sub.m_CLK);
register_subalias("CLK", sub->m_CLK);
register_input("D", m_D);
register_input("CLRQ", m_CLRQ);
register_input("PREQ", m_PREQ);
register_subalias("Q", sub.m_Q);
register_subalias("QQ", sub.m_QQ);
register_subalias("Q", sub->m_Q);
register_subalias("QQ", sub->m_QQ);
}
NETLIB_RESET(7474)
{
sub.do_reset();
sub->do_reset();
}
NETLIB_START(7474sub)
@ -95,33 +95,33 @@ NETLIB_START(7474_dip)
register_sub("1", m_1);
register_sub("2", m_2);
register_subalias("1", m_1.m_CLRQ);
register_subalias("2", m_1.m_D);
register_subalias("3", m_1.sub.m_CLK);
register_subalias("4", m_1.m_PREQ);
register_subalias("5", m_1.sub.m_Q);
register_subalias("6", m_1.sub.m_QQ);
register_subalias("1", m_1->m_CLRQ);
register_subalias("2", m_1->m_D);
register_subalias("3", m_1->sub->m_CLK);
register_subalias("4", m_1->m_PREQ);
register_subalias("5", m_1->sub->m_Q);
register_subalias("6", m_1->sub->m_QQ);
// register_subalias("7", ); ==> GND
register_subalias("8", m_2.sub.m_QQ);
register_subalias("9", m_2.sub.m_Q);
register_subalias("10", m_2.m_PREQ);
register_subalias("11", m_2.sub.m_CLK);
register_subalias("12", m_2.m_D);
register_subalias("13", m_2.m_CLRQ);
register_subalias("8", m_2->sub->m_QQ);
register_subalias("9", m_2->sub->m_Q);
register_subalias("10", m_2->m_PREQ);
register_subalias("11", m_2->sub->m_CLK);
register_subalias("12", m_2->m_D);
register_subalias("13", m_2->m_CLRQ);
// register_subalias("14", ); ==> VCC
}
NETLIB_RESET(7474_dip)
{
m_1.do_reset();
m_2.do_reset();
m_1->do_reset();
m_2->do_reset();
}
NETLIB_UPDATE(7474_dip)
{
m_1.update_dev();
m_2.update_dev();
m_1->update_dev();
m_2->update_dev();
}
NETLIB_NAMESPACE_DEVICES_END()

6
src/lib/netlist/devices/nld_7474.h
View File

@ -68,7 +68,7 @@ NETLIB_SUBDEVICE(7474sub,
NETLIB_DEVICE(7474,
public:
NETLIB_NAME(7474sub) sub;
NETLIB_SUB(7474sub) sub;
logic_input_t m_D;
logic_input_t m_CLRQ;
@ -77,8 +77,8 @@ public:
NETLIB_DEVICE(7474_dip,
NETLIB_NAME(7474) m_1;
NETLIB_NAME(7474) m_2;
NETLIB_SUB(7474) m_1;
NETLIB_SUB(7474) m_2;
);
NETLIB_NAMESPACE_DEVICES_END()

40
src/lib/netlist/devices/nld_7486.cpp
View File

@ -80,38 +80,38 @@ NETLIB_START(7486_dip)
register_sub("3", m_3);
register_sub("4", m_4);
register_subalias("1", m_1.m_I[0]);
register_subalias("2", m_1.m_I[1]);
register_subalias("3", m_1.m_Q[0]);
register_subalias("1", m_1->m_I[0]);
register_subalias("2", m_1->m_I[1]);
register_subalias("3", m_1->m_Q[0]);
register_subalias("4", m_2.m_I[0]);
register_subalias("5", m_2.m_I[1]);
register_subalias("6", m_2.m_Q[0]);
register_subalias("4", m_2->m_I[0]);
register_subalias("5", m_2->m_I[1]);
register_subalias("6", m_2->m_Q[0]);
register_subalias("9", m_3.m_I[0]);
register_subalias("10", m_3.m_I[1]);
register_subalias("8", m_3.m_Q[0]);
register_subalias("9", m_3->m_I[0]);
register_subalias("10", m_3->m_I[1]);
register_subalias("8", m_3->m_Q[0]);
register_subalias("12", m_4.m_I[0]);
register_subalias("13", m_4.m_I[1]);
register_subalias("11", m_4.m_Q[0]);
register_subalias("12", m_4->m_I[0]);
register_subalias("13", m_4->m_I[1]);
register_subalias("11", m_4->m_Q[0]);
}
NETLIB_UPDATE(7486_dip)
{
/* only called during startup */
m_1.update_dev();
m_2.update_dev();
m_3.update_dev();
m_4.update_dev();
m_1->update_dev();
m_2->update_dev();
m_3->update_dev();
m_4->update_dev();
}
NETLIB_RESET(7486_dip)
{
m_1.do_reset();
m_2.do_reset();
m_3.do_reset();
m_4.do_reset();
m_1->do_reset();
m_2->do_reset();
m_3->do_reset();
m_4->do_reset();
}
NETLIB_NAMESPACE_DEVICES_END()

8
src/lib/netlist/devices/nld_7486.h
View File

@ -62,10 +62,10 @@ public:
NETLIB_DEVICE(7486_dip,
NETLIB_NAME(7486) m_1;
NETLIB_NAME(7486) m_2;
NETLIB_NAME(7486) m_3;
NETLIB_NAME(7486) m_4;
NETLIB_SUB(7486) m_1;
NETLIB_SUB(7486) m_2;
NETLIB_SUB(7486) m_3;
NETLIB_SUB(7486) m_4;
);
NETLIB_NAMESPACE_DEVICES_END()

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

@ -17,26 +17,26 @@ NETLIB_START(7493)
register_sub("C", C);
register_sub("D", D);
register_subalias("CLKA", A.m_I);
register_subalias("CLKB", B.m_I);
register_subalias("CLKA", A->m_I);
register_subalias("CLKB", B->m_I);
register_input("R1", m_R1);
register_input("R2", m_R2);
register_subalias("QA", A.m_Q);
register_subalias("QB", B.m_Q);
register_subalias("QC", C.m_Q);
register_subalias("QD", D.m_Q);
register_subalias("QA", A->m_Q);
register_subalias("QB", B->m_Q);
register_subalias("QC", C->m_Q);
register_subalias("QD", D->m_Q);
connect_late(C.m_I, B.m_Q);
connect_late(D.m_I, C.m_Q);
connect_late(C->m_I, B->m_Q);
connect_late(D->m_I, C->m_Q);
}
NETLIB_RESET(7493)
{
A.do_reset();
B.do_reset();
C.do_reset();
D.do_reset();
A->do_reset();
B->do_reset();
C->do_reset();
D->do_reset();
}
NETLIB_START(7493ff)
@ -71,20 +71,20 @@ NETLIB_UPDATE(7493)
if (r)
{
A.m_I.inactivate();
B.m_I.inactivate();
OUTLOGIC(A.m_Q, 0, NLTIME_FROM_NS(40));
OUTLOGIC(B.m_Q, 0, NLTIME_FROM_NS(40));
OUTLOGIC(C.m_Q, 0, NLTIME_FROM_NS(40));
OUTLOGIC(D.m_Q, 0, NLTIME_FROM_NS(40));
A.m_reset = B.m_reset = C.m_reset = D.m_reset = 0;
A.m_state = B.m_state = C.m_state = D.m_state = 0;
A->m_I.inactivate();
B->m_I.inactivate();
OUTLOGIC(A->m_Q, 0, NLTIME_FROM_NS(40));
OUTLOGIC(B->m_Q, 0, NLTIME_FROM_NS(40));
OUTLOGIC(C->m_Q, 0, NLTIME_FROM_NS(40));
OUTLOGIC(D->m_Q, 0, NLTIME_FROM_NS(40));
A->m_reset = B->m_reset = C->m_reset = D->m_reset = 0;
A->m_state = B->m_state = C->m_state = D->m_state = 0;
}
else
{
A.m_I.activate_hl();
B.m_I.activate_hl();
A.m_reset = B.m_reset = C.m_reset = D.m_reset = 1;
A->m_I.activate_hl();
B->m_I.activate_hl();
A->m_reset = B->m_reset = C->m_reset = D->m_reset = 1;
}
}
@ -92,7 +92,7 @@ NETLIB_START(7493_dip)
{
NETLIB_NAME(7493)::start();
register_subalias("1", B.m_I);
register_subalias("1", B->m_I);
register_subalias("2", m_R1);
register_subalias("3", m_R2);
@ -101,13 +101,13 @@ NETLIB_START(7493_dip)
// register_subalias("6", ); --> NC
// register_subalias("7", ); --> NC
register_subalias("8", C.m_Q);
register_subalias("9", B.m_Q);
register_subalias("8", C->m_Q);
register_subalias("9", B->m_Q);
// register_subalias("10", ); --> GND
register_subalias("11", D.m_Q);
register_subalias("12", A.m_Q);
register_subalias("11", D->m_Q);
register_subalias("12", A->m_Q);
// register_subalias("13", ); --> NC
register_subalias("14", A.m_I);
register_subalias("14", A->m_I);
}

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

@ -83,10 +83,10 @@ NETLIB_DEVICE(7493,
logic_input_t m_R1;
logic_input_t m_R2;
NETLIB_NAME(7493ff) A;
NETLIB_NAME(7493ff) B;
NETLIB_NAME(7493ff) C;
NETLIB_NAME(7493ff) D;
NETLIB_SUB(7493ff) A;
NETLIB_SUB(7493ff) B;
NETLIB_SUB(7493ff) C;
NETLIB_SUB(7493ff) D;
);
NETLIB_DEVICE_DERIVED_PURE(7493_dip, 7493);

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

@ -87,21 +87,21 @@ NETLIB_START(SN74LS629)
register_input("ENQ", m_ENQ);
register_input("RNG", m_RNG);
register_input("FC", m_FC);
register_subalias("GND", m_R_FC.m_N);
register_subalias("GND", m_R_FC->m_N);
connect_late(m_FC, m_R_FC.m_P);
connect_late(m_RNG, m_R_RNG.m_P);
connect_late(m_R_FC.m_N, m_R_RNG.m_N);
connect_late(m_FC, m_R_FC->m_P);
connect_late(m_RNG, m_R_RNG->m_P);
connect_late(m_R_FC->m_N, m_R_RNG->m_N);
register_subalias("Y", m_clock.m_Y);
register_subalias("Y", m_clock->m_Y);
register_param("CAP", m_CAP, 1e-6);
}
NETLIB_RESET(SN74LS629)
{
m_R_FC.set_R(90000.0);
m_R_RNG.set_R(90000.0);
m_clock.reset();
m_R_FC->set_R(90000.0);
m_R_RNG->set_R(90000.0);
m_clock->reset();
}
NETLIB_UPDATE(SN74LS629)
@ -147,23 +147,23 @@ NETLIB_UPDATE(SN74LS629)
// FIXME: we need a possibility to remove entries from queue ...
// or an exact model ...
m_clock.m_inc = netlist_time::from_double(0.5 / (double) freq);
m_clock->m_inc = netlist_time::from_double(0.5 / (double) freq);
//m_clock.update();
//NL_VERBOSE_OUT(("{1} {2} {3} {4}\n", name(), v_freq, v_rng, freq));
}
if (!m_clock.m_enableq && INPLOGIC(m_ENQ))
if (!m_clock->m_enableq && INPLOGIC(m_ENQ))
{
m_clock.m_enableq = 1;
m_clock.m_out = m_clock.m_out ^ 1;
OUTLOGIC(m_clock.m_Y, m_clock.m_out, netlist_time::from_nsec(1));
m_clock->m_enableq = 1;
m_clock->m_out = m_clock->m_out ^ 1;
OUTLOGIC(m_clock->m_Y, m_clock->m_out, netlist_time::from_nsec(1));
}
else if (m_clock.m_enableq && !INPLOGIC(m_ENQ))
else if (m_clock->m_enableq && !INPLOGIC(m_ENQ))
{
m_clock.m_enableq = 0;
m_clock.m_out = m_clock.m_out ^ 1;
OUTLOGIC(m_clock.m_Y, m_clock.m_out, netlist_time::from_nsec(1));
m_clock->m_enableq = 0;
m_clock->m_out = m_clock->m_out ^ 1;
OUTLOGIC(m_clock->m_Y, m_clock->m_out, netlist_time::from_nsec(1));
}
}
@ -179,21 +179,21 @@ NETLIB_START(SN74LS629_dip)
register_sub("1", m_1);
register_sub("2", m_2);
register_subalias("1", m_2.m_FC);
register_subalias("2", m_1.m_FC);
register_subalias("3", m_1.m_RNG);
register_subalias("1", m_2->m_FC);
register_subalias("2", m_1->m_FC);
register_subalias("3", m_1->m_RNG);
register_subalias("6", m_1.m_ENQ);
register_subalias("7", m_1.m_clock.m_Y);
register_subalias("6", m_1->m_ENQ);
register_subalias("7", m_1->m_clock->m_Y);
register_subalias("8", m_1.m_R_FC.m_N);
register_subalias("9", m_1.m_R_FC.m_N);
connect_late(m_1.m_R_FC.m_N, m_2.m_R_FC.m_N);
register_subalias("8", m_1->m_R_FC->m_N);
register_subalias("9", m_1->m_R_FC->m_N);
connect_late(m_1->m_R_FC->m_N, m_2->m_R_FC->m_N);
register_subalias("10", m_2.m_clock.m_Y);
register_subalias("10", m_2->m_clock->m_Y);
register_subalias("11", m_2.m_ENQ);
register_subalias("14", m_2.m_RNG);
register_subalias("11", m_2->m_ENQ);
register_subalias("14", m_2->m_RNG);
}
@ -203,8 +203,8 @@ NETLIB_UPDATE(SN74LS629_dip)
NETLIB_RESET(SN74LS629_dip)
{
m_1.do_reset();
m_2.do_reset();
m_1->do_reset();
m_2->do_reset();
}
NETLIB_NAMESPACE_DEVICES_END()

10
src/lib/netlist/devices/nld_74ls629.h
View File

@ -48,9 +48,9 @@ NETLIB_SUBDEVICE(SN74LS629clk,
NETLIB_DEVICE_WITH_PARAMS(SN74LS629,
public:
NETLIB_NAME(SN74LS629clk) m_clock;
NETLIB_NAME(R_base) m_R_FC;
NETLIB_NAME(R_base) m_R_RNG;
NETLIB_SUB(SN74LS629clk) m_clock;
NETLIB_SUB(R_base) m_R_FC;
NETLIB_SUB(R_base) m_R_RNG;
logic_input_t m_ENQ;
analog_input_t m_RNG;
@ -65,8 +65,8 @@ public:
NETDEV_PARAMI(_name, 2.CAP, _cap2)
NETLIB_DEVICE(SN74LS629_dip,
NETLIB_NAME(SN74LS629) m_1;
NETLIB_NAME(SN74LS629) m_2;
NETLIB_SUB(SN74LS629) m_1;
NETLIB_SUB(SN74LS629) m_2;
);
NETLIB_NAMESPACE_DEVICES_END()

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

@ -14,33 +14,33 @@ NETLIB_NAMESPACE_DEVICES_START()
NETLIB_START(9310)
{
register_sub("subABCD", subABCD);
sub.m_ABCD = &subABCD;
register_sub("sub", sub);
sub->m_ABCD = &(*subABCD);
register_subalias("CLK", sub.m_CLK);
register_subalias("CLK", sub->m_CLK);
register_input("ENP", m_ENP);
register_input("ENT", m_ENT);
register_input("CLRQ", m_CLRQ);
register_input("LOADQ", m_LOADQ);
register_subalias("A", subABCD.m_A);
register_subalias("B", subABCD.m_B);
register_subalias("C", subABCD.m_C);
register_subalias("D", subABCD.m_D);
register_subalias("A", subABCD->m_A);
register_subalias("B", subABCD->m_B);
register_subalias("C", subABCD->m_C);
register_subalias("D", subABCD->m_D);
register_subalias("QA", sub.m_QA);
register_subalias("QB", sub.m_QB);
register_subalias("QC", sub.m_QC);
register_subalias("QD", sub.m_QD);
register_subalias("RC", sub.m_RC);
register_subalias("QA", sub->m_QA);
register_subalias("QB", sub->m_QB);
register_subalias("QC", sub->m_QC);
register_subalias("QD", sub->m_QD);
register_subalias("RC", sub->m_RC);
}
NETLIB_RESET(9310)
{
sub.do_reset();
subABCD.do_reset();
sub->do_reset();
subABCD->do_reset();
}
NETLIB_START(9310_subABCD)
@ -126,25 +126,25 @@ NETLIB_UPDATE(9310_sub)
NETLIB_UPDATE(9310)
{
sub.m_loadq = INPLOGIC(m_LOADQ);
sub.m_ent = INPLOGIC(m_ENT);
sub->m_loadq = INPLOGIC(m_LOADQ);
sub->m_ent = INPLOGIC(m_ENT);
const netlist_sig_t clrq = INPLOGIC(m_CLRQ);
if ((!sub.m_loadq || (sub.m_ent & INPLOGIC(m_ENP))) && clrq)
if ((!sub->m_loadq || (sub->m_ent & INPLOGIC(m_ENP))) && clrq)
{
sub.m_CLK.activate_lh();
OUTLOGIC(sub.m_RC, sub.m_ent & (sub.m_cnt == MAXCNT), NLTIME_FROM_NS(27));
sub->m_CLK.activate_lh();
OUTLOGIC(sub->m_RC, sub->m_ent & (sub->m_cnt == MAXCNT), NLTIME_FROM_NS(27));
}
else
{
sub.m_CLK.inactivate();
if (!clrq && (sub.m_cnt>0))
sub->m_CLK.inactivate();
if (!clrq && (sub->m_cnt>0))
{
sub.update_outputs_all(0, NLTIME_FROM_NS(36));
sub.m_cnt = 0;
sub->update_outputs_all(0, NLTIME_FROM_NS(36));
sub->m_cnt = 0;
//return;
}
OUTLOGIC(sub.m_RC, sub.m_ent & (sub.m_cnt == MAXCNT), NLTIME_FROM_NS(27));
OUTLOGIC(sub->m_RC, sub->m_ent & (sub->m_cnt == MAXCNT), NLTIME_FROM_NS(27));
}
}
@ -206,21 +206,21 @@ NETLIB_START(9310_dip)
NETLIB_NAME(9310)::start();
register_subalias("1", m_CLRQ);
register_subalias("2", sub.m_CLK);
register_subalias("3", subABCD.m_A);
register_subalias("4", subABCD.m_B);
register_subalias("5", subABCD.m_C);
register_subalias("6", subABCD.m_D);
register_subalias("2", sub->m_CLK);
register_subalias("3", subABCD->m_A);
register_subalias("4", subABCD->m_B);
register_subalias("5", subABCD->m_C);
register_subalias("6", subABCD->m_D);
register_subalias("7", m_ENP);
// register_subalias("8", ); --> GND
register_subalias("9", m_LOADQ);
register_subalias("10", m_ENT);
register_subalias("11", sub.m_QD);
register_subalias("12", sub.m_QC);
register_subalias("13", sub.m_QB);
register_subalias("14", sub.m_QA);
register_subalias("15", sub.m_RC);
register_subalias("11", sub->m_QD);
register_subalias("12", sub->m_QC);
register_subalias("13", sub->m_QB);
register_subalias("14", sub->m_QA);
register_subalias("15", sub->m_RC);
// register_subalias("16", ); --> VCC
}

4
src/lib/netlist/devices/nld_9310.h
View File

@ -96,8 +96,8 @@ NETLIB_SUBDEVICE(9310_sub,
);
NETLIB_DEVICE(9310,
NETLIB_NAME(9310_sub) sub;
NETLIB_NAME(9310_subABCD) subABCD;
NETLIB_SUB(9310_sub) sub;
NETLIB_SUB(9310_subABCD) subABCD;
logic_input_t m_ENP;
logic_input_t m_ENT;
logic_input_t m_CLRQ;

60
src/lib/netlist/devices/nld_9312.cpp
View File

@ -130,41 +130,41 @@ NETLIB_START(9312_dip)
#if (1 && USE_TRUTHTABLE)
register_subalias("13", m_sub.m_I[0]);
register_subalias("12", m_sub.m_I[1]);
register_subalias("11", m_sub.m_I[2]);
register_subalias("10", m_sub.m_I[3]);
register_subalias("13", m_sub->m_I[0]);
register_subalias("12", m_sub->m_I[1]);
register_subalias("11", m_sub->m_I[2]);
register_subalias("10", m_sub->m_I[3]);
register_subalias("1", m_sub.m_I[4]);
register_subalias("2", m_sub.m_I[5]);
register_subalias("3", m_sub.m_I[6]);
register_subalias("4", m_sub.m_I[7]);
register_subalias("5", m_sub.m_I[8]);
register_subalias("6", m_sub.m_I[9]);
register_subalias("7", m_sub.m_I[10]);
register_subalias("9", m_sub.m_I[11]);
register_subalias("1", m_sub->m_I[4]);
register_subalias("2", m_sub->m_I[5]);
register_subalias("3", m_sub->m_I[6]);
register_subalias("4", m_sub->m_I[7]);
register_subalias("5", m_sub->m_I[8]);
register_subalias("6", m_sub->m_I[9]);
register_subalias("7", m_sub->m_I[10]);
register_subalias("9", m_sub->m_I[11]);
register_subalias("15", m_sub.m_Q[0]); // Y
register_subalias("14", m_sub.m_Q[1]); // YQ
register_subalias("15", m_sub->m_Q[0]); // Y
register_subalias("14", m_sub->m_Q[1]); // YQ
#else
register_subalias("13", m_sub.m_C);
register_subalias("12", m_sub.m_B);
register_subalias("11", m_sub.m_A);
register_subalias("10", m_sub.m_G);
register_subalias("13", m_sub->m_C);
register_subalias("12", m_sub->m_B);
register_subalias("11", m_sub->m_A);
register_subalias("10", m_sub->m_G);
register_subalias("1", m_sub.m_D[0]);
register_subalias("2", m_sub.m_D[1]);
register_subalias("3", m_sub.m_D[2]);
register_subalias("4", m_sub.m_D[3]);
register_subalias("5", m_sub.m_D[4]);
register_subalias("6", m_sub.m_D[5]);
register_subalias("7", m_sub.m_D[6]);
register_subalias("9", m_sub.m_D[7]);
register_subalias("1", m_sub->m_D[0]);
register_subalias("2", m_sub->m_D[1]);
register_subalias("3", m_sub->m_D[2]);
register_subalias("4", m_sub->m_D[3]);
register_subalias("5", m_sub->m_D[4]);
register_subalias("6", m_sub->m_D[5]);
register_subalias("7", m_sub->m_D[6]);
register_subalias("9", m_sub->m_D[7]);
register_subalias("15", m_sub.m_Y); // Y
register_subalias("14", m_sub.m_YQ); // YQ
register_subalias("15", m_sub->m_Y); // Y
register_subalias("14", m_sub->m_YQ); // YQ
#endif
}
@ -172,11 +172,11 @@ NETLIB_START(9312_dip)
NETLIB_UPDATE(9312_dip)
{
/* only called during startup */
m_sub.update_dev();
m_sub->update_dev();
}
NETLIB_RESET(9312_dip)
{
m_sub.do_reset();
m_sub->do_reset();
}
NETLIB_NAMESPACE_DEVICES_END()

2
src/lib/netlist/devices/nld_9312.h
View File

@ -73,7 +73,7 @@ public:
#endif
NETLIB_DEVICE(9312_dip,
NETLIB_NAME(9312) m_sub;
NETLIB_SUB(9312) m_sub;
);
NETLIB_NAMESPACE_DEVICES_END()

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

@ -13,34 +13,34 @@ NETLIB_NAMESPACE_DEVICES_START()
NETLIB_START(9316)
{
register_sub("subABCD", subABCD);
sub.m_ABCD = &subABCD;
register_sub("sub", sub);
register_sub("subABCD", subABCD);
sub->m_ABCD = &(*subABCD);
register_subalias("CLK", sub.m_CLK);
register_subalias("CLK", sub->m_CLK);
register_input("ENP", m_ENP);
register_input("ENT", m_ENT);
register_input("CLRQ", m_CLRQ);
register_input("LOADQ", m_LOADQ);
register_subalias("A", subABCD.m_A);
register_subalias("B", subABCD.m_B);
register_subalias("C", subABCD.m_C);
register_subalias("D", subABCD.m_D);
register_subalias("A", subABCD->m_A);
register_subalias("B", subABCD->m_B);
register_subalias("C", subABCD->m_C);
register_subalias("D", subABCD->m_D);
register_subalias("QA", sub.m_QA);
register_subalias("QB", sub.m_QB);
register_subalias("QC", sub.m_QC);
register_subalias("QD", sub.m_QD);
register_subalias("RC", sub.m_RC);
register_subalias("QA", sub->m_QA);
register_subalias("QB", sub->m_QB);
register_subalias("QC", sub->m_QC);
register_subalias("QD", sub->m_QD);
register_subalias("RC", sub->m_RC);
}
NETLIB_RESET(9316)
{
sub.do_reset();
subABCD.do_reset();
sub->do_reset();
subABCD->do_reset();
}
NETLIB_START(9316_subABCD)
@ -121,25 +121,25 @@ NETLIB_UPDATE(9316_sub)
NETLIB_UPDATE(9316)
{
sub.m_loadq = INPLOGIC(m_LOADQ);
sub.m_ent = INPLOGIC(m_ENT);
sub->m_loadq = INPLOGIC(m_LOADQ);
sub->m_ent = INPLOGIC(m_ENT);
const netlist_sig_t clrq = INPLOGIC(m_CLRQ);
if (((sub.m_loadq ^ 1) | (sub.m_ent & INPLOGIC(m_ENP))) & clrq)
if (((sub->m_loadq ^ 1) | (sub->m_ent & INPLOGIC(m_ENP))) & clrq)
{
sub.m_CLK.activate_lh();
OUTLOGIC(sub.m_RC, sub.m_ent & (sub.m_cnt == MAXCNT), NLTIME_FROM_NS(27));
sub->m_CLK.activate_lh();
OUTLOGIC(sub->m_RC, sub->m_ent & (sub->m_cnt == MAXCNT), NLTIME_FROM_NS(27));
}
else
{
sub.m_CLK.inactivate();
if (!clrq && (sub.m_cnt>0))
sub->m_CLK.inactivate();
if (!clrq && (sub->m_cnt>0))
{
sub.update_outputs_all(0, NLTIME_FROM_NS(36));
sub.m_cnt = 0;
sub->update_outputs_all(0, NLTIME_FROM_NS(36));
sub->m_cnt = 0;
//return;
}
OUTLOGIC(sub.m_RC, sub.m_ent & (sub.m_cnt == MAXCNT), NLTIME_FROM_NS(27));
OUTLOGIC(sub->m_RC, sub->m_ent & (sub->m_cnt == MAXCNT), NLTIME_FROM_NS(27));
}
}
@ -201,21 +201,21 @@ NETLIB_START(9316_dip)
NETLIB_NAME(9316)::start();
register_subalias("1", m_CLRQ);
register_subalias("2", sub.m_CLK);
register_subalias("3", subABCD.m_A);
register_subalias("4", subABCD.m_B);
register_subalias("5", subABCD.m_C);
register_subalias("6", subABCD.m_D);
register_subalias("2", sub->m_CLK);
register_subalias("3", subABCD->m_A);
register_subalias("4", subABCD->m_B);
register_subalias("5", subABCD->m_C);
register_subalias("6", subABCD->m_D);
register_subalias("7", m_ENP);
// register_subalias("8", ); --> GND
register_subalias("9", m_LOADQ);
register_subalias("10", m_ENT);
register_subalias("11", sub.m_QD);
register_subalias("12", sub.m_QC);
register_subalias("13", sub.m_QB);
register_subalias("14", sub.m_QA);
register_subalias("15", sub.m_RC);
register_subalias("11", sub->m_QD);
register_subalias("12", sub->m_QC);
register_subalias("13", sub->m_QB);
register_subalias("14", sub->m_QA);
register_subalias("15", sub->m_RC);
// register_subalias("16", ); --> VCC
}

4
src/lib/netlist/devices/nld_9316.h
View File

@ -101,8 +101,8 @@ NETLIB_SUBDEVICE(9316_sub,
);
NETLIB_DEVICE(9316,
NETLIB_NAME(9316_sub) sub;
NETLIB_NAME(9316_subABCD) subABCD;
NETLIB_SUB(9316_sub) sub;
NETLIB_SUB(9316_subABCD) subABCD;
logic_input_t m_ENP;
logic_input_t m_ENT;
logic_input_t m_CLRQ;

4
src/lib/netlist/devices/nld_cmos.h
View File

@ -16,8 +16,8 @@ NETLIB_NAMESPACE_DEVICES_START()
class nld_vdd_vss : public device_t
{
public:
nld_vdd_vss ()
: device_t()
nld_vdd_vss (netlist_t &anetlist, const pstring &name)
: device_t(anetlist, name)
{ }
analog_input_t m_vdd;

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

@ -24,15 +24,15 @@ NETLIB_START(MM5837_dip)
/* output */
register_sub("RV", m_RV);
register_terminal("_RV1", m_RV.m_P);
register_terminal("_RV2", m_RV.m_N);
register_terminal("_RV1", m_RV->m_P);
register_terminal("_RV2", m_RV->m_N);
register_output("_Q", m_V0);
connect_late(m_RV.m_N, m_V0);
connect_late(m_RV->m_N, m_V0);
/* device */
register_input("1", m_VDD);
register_input("2", m_VGG);
register_subalias("3", m_RV.m_P);
register_subalias("3", m_RV->m_P);
register_input("4", m_VSS);
save(NLNAME(m_shift));
@ -41,11 +41,11 @@ NETLIB_START(MM5837_dip)
NETLIB_RESET(MM5837_dip)
{
m_V0.initial(0.0);
m_RV.do_reset();
m_RV.set(NL_FCONST(1.0) / R_LOW, 0.0, 0.0);
m_RV->do_reset();
m_RV->set(NL_FCONST(1.0) / R_LOW, 0.0, 0.0);
m_shift = 0x1ffff;
m_is_timestep = m_RV.m_P.net().solver()->is_timestep();
m_is_timestep = m_RV->m_P.net().solver()->is_timestep();
}
NETLIB_UPDATE(MM5837_dip)
@ -70,9 +70,9 @@ NETLIB_UPDATE(MM5837_dip)
// We only need to update the net first if this is a time stepping net
if (m_is_timestep)
m_RV.update_dev();
m_RV.set(NL_FCONST(1.0) / R, V, 0.0);
m_RV.m_P.schedule_after(NLTIME_FROM_NS(1));
m_RV->update_dev();
m_RV->set(NL_FCONST(1.0) / R, V, 0.0);
m_RV->m_P.schedule_after(NLTIME_FROM_NS(1));
}
}

2
src/lib/netlist/devices/nld_mm5837.h
View File

@ -34,7 +34,7 @@ NETLIB_DEVICE(MM5837_dip,
analog_input_t m_VSS;
/* output stage */
nld_twoterm m_RV;
std::unique_ptr<nld_twoterm> m_RV;
analog_output_t m_V0; /* could be gnd as well */
/* clock stage */

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

@ -17,7 +17,7 @@ NETLIB_NAMESPACE_DEVICES_START()
inline nl_double NETLIB_NAME(NE555)::clamp(const nl_double v, const nl_double a, const nl_double b)
{
nl_double ret = v;
nl_double vcc = TERMANALOG(m_R1.m_P);
nl_double vcc = TERMANALOG(m_R1->m_P);
if (ret > vcc - a)
ret = vcc - a;
@ -33,18 +33,18 @@ NETLIB_START(NE555)
register_sub("R3", m_R3);
register_sub("RDIS", m_RDIS);
register_subalias("GND", m_R3.m_N); // Pin 1
register_subalias("GND", m_R3->m_N); // Pin 1
register_input("TRIG", m_TRIG); // Pin 2
register_output("OUT", m_OUT); // Pin 3
register_input("RESET", m_RESET); // Pin 4
register_subalias("CONT", m_R1.m_N); // Pin 5
register_subalias("CONT", m_R1->m_N); // Pin 5
register_input("THRESH", m_THRES); // Pin 6
register_subalias("DISCH", m_RDIS.m_P); // Pin 7
register_subalias("VCC", m_R1.m_P); // Pin 8
register_subalias("DISCH", m_RDIS->m_P); // Pin 7
register_subalias("VCC", m_R1->m_P); // Pin 8
connect_late(m_R1.m_N, m_R2.m_P);
connect_late(m_R2.m_N, m_R3.m_P);
connect_late(m_RDIS.m_N, m_R3.m_N);
connect_late(m_R1->m_N, m_R2->m_P);
connect_late(m_R2->m_N, m_R3->m_P);
connect_late(m_RDIS->m_N, m_R3->m_N);
save(NLNAME(m_last_out));
save(NLNAME(m_ff));
@ -52,15 +52,15 @@ NETLIB_START(NE555)
NETLIB_RESET(NE555)
{
m_R1.do_reset();
m_R2.do_reset();
m_R3.do_reset();
m_RDIS.do_reset();
m_R1->do_reset();
m_R2->do_reset();
m_R3->do_reset();
m_RDIS->do_reset();
m_R1.set_R(5000);
m_R2.set_R(5000);
m_R3.set_R(5000);
m_RDIS.set_R(R_OFF);
m_R1->set_R(5000);
m_R2->set_R(5000);
m_R3->set_R(5000);
m_RDIS->set_R(R_OFF);
m_last_out = true;
}
@ -69,9 +69,9 @@ NETLIB_UPDATE(NE555)
{
// FIXME: assumes GND is connected to 0V.
nl_double vt = clamp(TERMANALOG(m_R2.m_P), 0.7, 1.4);
nl_double vt = clamp(TERMANALOG(m_R2->m_P), 0.7, 1.4);
bool bthresh = (INPANALOG(m_THRES) > vt);
bool btrig = (INPANALOG(m_TRIG) > clamp(TERMANALOG(m_R2.m_N), 0.7, 1.4));
bool btrig = (INPANALOG(m_TRIG) > clamp(TERMANALOG(m_R2->m_N), 0.7, 1.4));
if (!btrig)
{
@ -86,16 +86,16 @@ NETLIB_UPDATE(NE555)
if (m_last_out && !out)
{
m_RDIS.update_dev();
OUTANALOG(m_OUT, TERMANALOG(m_R3.m_N));
m_RDIS.set_R(R_ON);
m_RDIS->update_dev();
OUTANALOG(m_OUT, TERMANALOG(m_R3->m_N));
m_RDIS->set_R(R_ON);
}
else if (!m_last_out && out)
{
m_RDIS.update_dev();
m_RDIS->update_dev();
// FIXME: Should be delayed by 100ns
OUTANALOG(m_OUT, TERMANALOG(m_R1.m_P));
m_RDIS.set_R(R_OFF);
OUTANALOG(m_OUT, TERMANALOG(m_R1->m_P));
m_RDIS->set_R(R_OFF);
}
m_last_out = out;
}
@ -105,14 +105,14 @@ NETLIB_START(NE555_dip)
{
NETLIB_NAME(NE555)::start();
register_subalias("1", m_R3.m_N); // Pin 1
register_subalias("1", m_R3->m_N); // Pin 1
register_subalias("2", m_TRIG); // Pin 2
register_subalias("3", m_OUT); // Pin 3
register_subalias("4", m_RESET); // Pin 4
register_subalias("5", m_R1.m_N); // Pin 5
register_subalias("5", m_R1->m_N); // Pin 5
register_subalias("6", m_THRES); // Pin 6
register_subalias("7", m_RDIS.m_P); // Pin 7
register_subalias("8", m_R1.m_P); // Pin 8
register_subalias("7", m_RDIS->m_P); // Pin 7
register_subalias("8", m_R1->m_P); // Pin 8
}

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

@ -28,10 +28,10 @@
NETLIB_NAMESPACE_DEVICES_START()
NETLIB_DEVICE(NE555,
NETLIB_NAME(R) m_R1;
NETLIB_NAME(R) m_R2;
NETLIB_NAME(R) m_R3;
NETLIB_NAME(R) m_RDIS;
NETLIB_SUB(R) m_R1;
NETLIB_SUB(R) m_R2;
NETLIB_SUB(R) m_R3;
NETLIB_SUB(R) m_RDIS;
logic_input_t m_RESET;
analog_input_t m_THRES;

8
src/lib/netlist/devices/nld_signal.h
View File

@ -18,8 +18,8 @@
class NETLIB_NAME(_name) : public net_signal_t<_num_input, _check, _invert> \
{ \
public: \
NETLIB_NAME(_name) () \
: net_signal_t<_num_input, _check, _invert>() { } \
NETLIB_NAME(_name) (netlist_t &anetlist, const pstring &name) \
: net_signal_t<_num_input, _check, _invert>(anetlist, name) { } \
}
NETLIB_NAMESPACE_DEVICES_START()
@ -32,8 +32,8 @@ template <int _numdev, int _check, int _invert>
class net_signal_t : public device_t
{
public:
net_signal_t()
: device_t(), m_active(1)
net_signal_t(netlist_t &anetlist, const pstring &name)
: device_t(anetlist, name), m_active(1)
{
}

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

@ -196,7 +196,7 @@ void nld_d_to_a_proxy::start()
{
nld_base_d_to_a_proxy::start();
register_sub("RV", m_RV);
register_sub(m_RV);
register_terminal("1", m_RV.m_P);
register_terminal("2", m_RV.m_N);
@ -248,8 +248,8 @@ NETLIB_START(res_sw)
register_param("RON", m_RON, 1.0);
register_param("ROFF", m_ROFF, 1.0E20);
register_subalias("1", m_R.m_P);
register_subalias("2", m_R.m_N);
register_subalias("1", m_R->m_P);
register_subalias("2", m_R->m_N);
save(NLNAME(m_last_state));
}
@ -257,7 +257,7 @@ NETLIB_START(res_sw)
NETLIB_RESET(res_sw)
{
m_last_state = 0;
m_R.set_R(m_ROFF.Value());
m_R->set_R(m_ROFF.Value());
}
NETLIB_UPDATE(res_sw)
@ -269,17 +269,17 @@ NETLIB_UPDATE(res_sw)
const nl_double R = state ? m_RON.Value() : m_ROFF.Value();
// We only need to update the net first if this is a time stepping net
if (0) // m_R.m_P.net().as_analog().solver()->is_timestep())
if (0) // m_R->m_P.net().as_analog().solver()->is_timestep())
{
m_R.update_dev();
m_R.set_R(R);
m_R.m_P.schedule_after(NLTIME_FROM_NS(1));
m_R->update_dev();
m_R->set_R(R);
m_R->m_P.schedule_after(NLTIME_FROM_NS(1));
}
else
{
m_R.set_R(R);
m_R.m_P.schedule_after(NLTIME_FROM_NS(1));
//m_R.update_dev();
m_R->set_R(R);
m_R->m_P.schedule_after(NLTIME_FROM_NS(1));
//m_R->update_dev();
}
}
}

56
src/lib/netlist/devices/nld_system.h
View File

@ -156,8 +156,8 @@ NETLIB_DEVICE_WITH_PARAMS(analog_input,
class NETLIB_NAME(gnd) : public device_t
{
public:
NETLIB_NAME(gnd)()
: device_t(GND) { }
NETLIB_NAME(gnd)(netlist_t &anetlist, const pstring &name)
: device_t(GND, anetlist, name) { }
virtual ~NETLIB_NAME(gnd)() {}
@ -189,8 +189,8 @@ private:
class NETLIB_NAME(dummy_input) : public device_t
{
public:
NETLIB_NAME(dummy_input)()
: device_t(DUMMY) { }
NETLIB_NAME(dummy_input)(netlist_t &anetlist, const pstring &name)
: device_t(DUMMY, anetlist, name) { }
virtual ~NETLIB_NAME(dummy_input)() {}
@ -221,8 +221,11 @@ private:
class NETLIB_NAME(frontier) : public device_t
{
public:
NETLIB_NAME(frontier)()
: device_t(DUMMY) { }
NETLIB_NAME(frontier)(netlist_t &anetlist, const pstring &name)
: device_t(DUMMY, anetlist, name),
m_RIN(netlist(), "m_RIN"),
m_ROUT(netlist(), "m_ROUT")
{ }
virtual ~NETLIB_NAME(frontier)() {}
@ -274,8 +277,8 @@ private:
class NETLIB_NAME(function) : public device_t
{
public:
NETLIB_NAME(function)()
: device_t() { }
NETLIB_NAME(function)(netlist_t &anetlist, const pstring &name)
: device_t(anetlist, name) { }
virtual ~NETLIB_NAME(function)() {}
@ -319,15 +322,15 @@ private:
class NETLIB_NAME(res_sw) : public device_t
{
public:
NETLIB_NAME(res_sw)()
: device_t() { }
NETLIB_NAME(res_sw)(netlist_t &anetlist, const pstring &name)
: device_t(anetlist, name) { }
virtual ~NETLIB_NAME(res_sw)() {}
param_double_t m_RON;
param_double_t m_ROFF;
logic_input_t m_I;
NETLIB_NAME(R) m_R;
NETLIB_SUB(R) m_R;
protected:
@ -347,8 +350,8 @@ private:
class nld_base_proxy : public device_t
{
public:
nld_base_proxy(logic_t *inout_proxied, core_terminal_t *proxy_inout)
: device_t()
nld_base_proxy(netlist_t &anetlist, const pstring &name, logic_t *inout_proxied, core_terminal_t *proxy_inout)
: device_t(anetlist, name)
{
m_logic_family = inout_proxied->logic_family();
m_term_proxied = inout_proxied;
@ -380,8 +383,8 @@ private:
class nld_a_to_d_proxy : public nld_base_proxy
{
public:
nld_a_to_d_proxy(logic_input_t *in_proxied)
: nld_base_proxy(in_proxied, &m_I)
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)
{
}
@ -427,8 +430,8 @@ public:
virtual logic_input_t &in() { return m_I; }
protected:
nld_base_d_to_a_proxy(logic_output_t *out_proxied, core_terminal_t &proxy_out)
: nld_base_proxy(out_proxied, &proxy_out)
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)
{
}
@ -445,9 +448,9 @@ private:
class nld_d_to_a_proxy : public nld_base_d_to_a_proxy
{
public:
nld_d_to_a_proxy(logic_output_t *out_proxied)
: nld_base_d_to_a_proxy(out_proxied, m_RV.m_P)
, m_RV(TWOTERM)
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_RV(TWOTERM, anetlist,"RV")
, m_last_state(-1)
, m_is_timestep(false)
{
@ -482,14 +485,14 @@ public:
class wrapper : public device_t
{
public:
wrapper(const pstring &dev_name) : device_t(), m_dev_name(dev_name) { }
protected:
virtual void init(netlist_t &anetlist, const pstring &aname) override
wrapper(const pstring &dev_name, netlist_t &anetlist, const pstring &name)
: device_t(anetlist, name), m_dev_name(dev_name)
{
anetlist.setup().namespace_push(aname);
anetlist.setup().namespace_push(name);
anetlist.setup().include(m_dev_name);
anetlist.setup().namespace_pop();
}
protected:
void start() override { }
void reset() override { }
void update() override { }
@ -497,10 +500,9 @@ public:
pstring m_dev_name;
};
ATTR_COLD device_t *Create() override
ATTR_COLD device_t *Create(netlist_t &anetlist, const pstring &name) override
{
device_t *r = palloc(wrapper(this->name()));
return r;
return palloc(wrapper(this->name(), anetlist, name));
}
private:

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

@ -17,8 +17,8 @@
class NETLIB_NAME(_name) : public nld_truthtable_t<_nIN, _nOUT, _state> \
{ \
public: \
NETLIB_NAME(_name)() \
: nld_truthtable_t<_nIN, _nOUT, _state>(&m_ttbl, m_desc) { } \
NETLIB_NAME(_name)(netlist_t &anetlist, const pstring &name) \
: nld_truthtable_t<_nIN, _nOUT, _state>(anetlist, name, &m_ttbl, m_desc) { }\
private: \
static truthtable_t m_ttbl; \
static const char *m_desc[]; \
@ -100,8 +100,10 @@ public:
struct truthtable_t
{
truthtable_t() : m_initialized(false),
m_desc(m_NO, m_NI, has_state, &m_initialized, m_outs, m_timing, m_timing_nt) {}
truthtable_t()
: m_initialized(false),
m_desc(m_NO, m_NI, has_state,
&m_initialized, m_outs, m_timing, m_timing_nt) {}
bool m_initialized;
UINT32 m_outs[m_size];
UINT8 m_timing[m_size * m_NO];
@ -109,8 +111,8 @@ public:
truthtable_desc_t m_desc;
};
nld_truthtable_t(truthtable_t *ttbl, const char *desc[])
: device_t(), m_last_state(0), m_ign(0), m_active(1), m_ttp(ttbl)
nld_truthtable_t(netlist_t &anetlist, const pstring &name, truthtable_t *ttbl, const char *desc[])
: device_t(anetlist, name), m_last_state(0), m_ign(0), m_active(1), m_ttp(ttbl)
{
while (*desc != nullptr && **desc != 0 )
{
@ -120,8 +122,8 @@ public:
}
nld_truthtable_t(truthtable_t *ttbl, const pstring_vector_t &desc)
: device_t(), m_last_state(0), m_ign(0), m_active(1), m_ttp(ttbl)
nld_truthtable_t(netlist_t &anetlist, const pstring &name, truthtable_t *ttbl, const pstring_vector_t &desc)
: device_t(anetlist, name), m_last_state(0), m_ign(0), m_active(1), m_ttp(ttbl)
{
m_desc = desc;
}
@ -321,10 +323,10 @@ public:
const pstring &def_param)
: netlist_base_factory_truthtable_t(name, classname, def_param) { }
device_t *Create() override
device_t *Create(netlist_t &anetlist, const pstring &name) override
{
typedef nld_truthtable_t<m_NI, m_NO, has_state> tt_type;
device_t *r = palloc(tt_type(&m_ttbl, m_desc));
device_t *r = palloc(tt_type(anetlist, name, &m_ttbl, m_desc));
r->set_logic_family(m_family);
//r->init(setup, name);
return r;

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

@ -38,9 +38,9 @@ public:
m_R_high = 130.0;
m_is_static = true;
}
virtual devices::nld_base_d_to_a_proxy *create_d_a_proxy(logic_output_t *proxied) const override
virtual devices::nld_base_d_to_a_proxy *create_d_a_proxy(netlist_t &anetlist, const pstring &name, logic_output_t *proxied) const override
{
return palloc(devices::nld_d_to_a_proxy(proxied));
return palloc(devices::nld_d_to_a_proxy(anetlist, name, proxied));
}
};
@ -59,9 +59,9 @@ public:
m_R_high = 10.0;
m_is_static = true;
}
virtual devices::nld_base_d_to_a_proxy *create_d_a_proxy(logic_output_t *proxied) const override
virtual devices::nld_base_d_to_a_proxy *create_d_a_proxy(netlist_t &anetlist, const pstring &name, logic_output_t *proxied) const override
{
return palloc(devices::nld_d_to_a_proxy(proxied));
return palloc(devices::nld_d_to_a_proxy(anetlist, name, proxied));
}
};
@ -389,31 +389,17 @@ ATTR_HOT void netlist_t::process_queue(const netlist_time &delta)
// net_core_device_t
// ----------------------------------------------------------------------------------------
ATTR_COLD core_device_t::core_device_t(const family_t afamily)
ATTR_COLD core_device_t::core_device_t(const family_t afamily, netlist_t &anetlist, const pstring &name)
: object_t(DEVICE, afamily), logic_family_t()
#if (NL_KEEP_STATISTICS)
, stat_total_time(0)
, stat_update_count(0)
, stat_call_count(0)
#endif
{
}
ATTR_COLD void core_device_t::init(netlist_t &anetlist, const pstring &name)
{
if (logic_family() == nullptr)
set_logic_family(this->default_logic_family());
init_object(anetlist, name);
#if (NL_PMF_TYPE == NL_PMF_TYPE_GNUC_PMF)
void (core_device_t::* pFunc)() = &core_device_t::update;
m_static_update = pFunc;
#elif (NL_PMF_TYPE == NL_PMF_TYPE_GNUC_PMF_CONV)
void (core_device_t::* pFunc)() = &core_device_t::update;
m_static_update = reinterpret_cast<net_update_delegate>((this->*pFunc));
#elif (NL_PMF_TYPE == NL_PMF_TYPE_INTERNAL)
m_static_update = pmfp::get_mfp<net_update_delegate>(&core_device_t::update, this);
#endif
}
ATTR_COLD core_device_t::~core_device_t()
@ -424,6 +410,15 @@ ATTR_COLD void core_device_t::start_dev()
{
#if (NL_KEEP_STATISTICS)
netlist().m_started_devices.add(this, false);
#endif
#if (NL_PMF_TYPE == NL_PMF_TYPE_GNUC_PMF)
void (core_device_t::* pFunc)() = &core_device_t::update;
m_static_update = pFunc;
#elif (NL_PMF_TYPE == NL_PMF_TYPE_GNUC_PMF_CONV)
void (core_device_t::* pFunc)() = &core_device_t::update;
m_static_update = reinterpret_cast<net_update_delegate>((this->*pFunc));
#elif (NL_PMF_TYPE == NL_PMF_TYPE_INTERNAL)
m_static_update = pmfp::get_mfp<net_update_delegate>(&core_device_t::update, this);
#endif
start();
}
@ -453,14 +448,14 @@ ATTR_HOT netlist_sig_t core_device_t::INPLOGIC_PASSIVE(logic_input_t &inp)
// device_t
// ----------------------------------------------------------------------------------------
device_t::device_t()
: core_device_t(GENERIC),
device_t::device_t(netlist_t &anetlist, const pstring &name)
: core_device_t(GENERIC, anetlist, name),
m_terminals()
{
}
device_t::device_t(const family_t afamily)
: core_device_t(afamily),
device_t::device_t(const family_t afamily, netlist_t &anetlist, const pstring &name)
: core_device_t(afamily, anetlist, name),
m_terminals()
{
}
@ -475,15 +470,8 @@ ATTR_COLD setup_t &device_t::setup()
return netlist().setup();
}
ATTR_COLD void device_t::init(netlist_t &anetlist, const pstring &name)
ATTR_COLD void device_t::register_sub_p(device_t &dev)
{
core_device_t::init(anetlist, name);
}
ATTR_COLD void device_t::register_sub(const pstring &name, device_t &dev)
{
dev.init(netlist(), this->name() + "." + name);
// subdevices always first inherit the logic family of the parent
dev.set_logic_family(this->logic_family());
dev.start_dev();

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

@ -185,6 +185,7 @@ typedef unsigned int netlist_sig_t;
#define NETLIB_NAMESPACE_DEVICES_END() }}
#define NETLIB_NAME(_chip) nld_ ## _chip
#define NETLIB_SUB(_chip) std::unique_ptr< nld_ ## _chip >
#define NETLIB_NAME_STR_S(_s) # _s
#define NETLIB_NAME_STR(_chip) NETLIB_NAME_STR_S(nld_ ## _chip)
@ -207,8 +208,8 @@ typedef unsigned int netlist_sig_t;
class _name : public _pclass \
{ \
public: \
_name() \
: _pclass() { } \
_name(netlist_t &anetlist, const pstring &name) \
: _pclass(anetlist, name) { } \
protected: \
_extra \
ATTR_HOT void update() override; \
@ -230,8 +231,8 @@ typedef unsigned int netlist_sig_t;
class NETLIB_NAME(_name) : public device_t \
{ \
public: \
NETLIB_NAME(_name) () \
: device_t() \
NETLIB_NAME(_name) (netlist_t &anetlist, const pstring &name) \
: device_t(anetlist, name) \
{ } \
/*protected:*/ \
ATTR_HOT void update() override; \
@ -326,7 +327,8 @@ namespace netlist
public:
logic_family_desc_t() : m_is_static(false) {}
virtual ~logic_family_desc_t() {}
virtual devices::nld_base_d_to_a_proxy *create_d_a_proxy(logic_output_t *proxied) const = 0;
virtual devices::nld_base_d_to_a_proxy *create_d_a_proxy(netlist_t &anetlist, const pstring &name,
logic_output_t *proxied) const = 0;
nl_double m_low_thresh_V;
nl_double m_high_thresh_V;
@ -1025,11 +1027,10 @@ namespace netlist
typedef pvector_t<core_device_t *> list_t;
ATTR_COLD core_device_t(const family_t afamily);
ATTR_COLD core_device_t(const family_t afamily, netlist_t &anetlist, const pstring &name);
virtual ~core_device_t();
virtual void init(netlist_t &anetlist, const pstring &name);
ATTR_HOT virtual void update_param() {}
ATTR_HOT void update_dev()
@ -1117,16 +1118,28 @@ namespace netlist
P_PREVENT_COPYING(device_t)
public:
ATTR_COLD device_t();
ATTR_COLD device_t(const family_t afamily);
ATTR_COLD device_t(netlist_t &anetlist, const pstring &name);
ATTR_COLD device_t(const family_t afamily, netlist_t &anetlist, const pstring &name);
virtual ~device_t();
virtual void init(netlist_t &anetlist, const pstring &name) override;
ATTR_COLD setup_t &setup();
ATTR_COLD void register_sub(const pstring &name, device_t &dev);
template<class C>
void register_sub(const pstring &name, std::unique_ptr<C> &dev)
{
dev.reset(new C(this->netlist(), this->name() + "." + name));
register_sub_p(*dev);
}
#if 1
void register_sub(device_t &dev)
{
register_sub_p(dev);
}
#endif
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 register_terminal(const pstring &name, terminal_t &port);
@ -1151,6 +1164,7 @@ namespace netlist
ATTR_COLD void register_param(const pstring &sname, C &param, const T initialVal);
private:
ATTR_COLD void register_sub_p(device_t &dev);
};

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

@ -71,19 +71,19 @@ void factory_list_t::error(const pstring &s)
m_setup.log().fatal("{1}", s);
}
device_t *factory_list_t::new_device_by_name(const pstring &name)
device_t *factory_list_t::new_device_by_name(const pstring &devname, netlist_t &anetlist, const pstring &name)
{
base_factory_t *f = factory_by_name(name);
return f->Create();
base_factory_t *f = factory_by_name(devname);
return f->Create(anetlist, name);
}
base_factory_t * factory_list_t::factory_by_name(const pstring &name)
base_factory_t * factory_list_t::factory_by_name(const pstring &devname)
{
if (contains(name))
return (*this)[name];
if (contains(devname))
return (*this)[devname];
else
{
m_setup.log().fatal("Class {1} not found!\n", name);
m_setup.log().fatal("Class {1} not found!\n", devname);
return nullptr; // appease code analysis
}
}

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

@ -31,7 +31,7 @@ namespace netlist
virtual ~base_factory_t() {}
virtual device_t *Create() = 0;
virtual device_t *Create(netlist_t &anetlist, const pstring &name) = 0;
ATTR_COLD const pstring &name() const { return m_name; }
ATTR_COLD const pstring &classname() const { return m_classname; }
@ -54,10 +54,9 @@ namespace netlist
const pstring &def_param)
: base_factory_t(name, classname, def_param) { }
ATTR_COLD device_t *Create() override
ATTR_COLD device_t *Create(netlist_t &anetlist, const pstring &name) override
{
device_t *r = palloc(_device_class);
//r->init(setup, name);
device_t *r = palloc(_device_class(anetlist, name));
return r;
}
};
@ -83,8 +82,9 @@ namespace netlist
}
//ATTR_COLD device_t *new_device_by_classname(const pstring &classname) const;
ATTR_COLD device_t *new_device_by_name(const pstring &name);
ATTR_COLD base_factory_t * factory_by_name(const pstring &name);
// FIXME: legacy, should use factory_by_name
ATTR_COLD device_t *new_device_by_name(const pstring &devname, netlist_t &anetlist, const pstring &name);
ATTR_COLD base_factory_t * factory_by_name(const pstring &devname);
private:
void error(const pstring &s);

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

@ -360,8 +360,8 @@ void parser_t::device(const pstring &dev_type)
pstring devname = get_identifier();
dev = f->Create();
m_setup.register_dev(dev, devname);
dev = f->Create(m_setup.netlist(), m_setup.build_fqn(devname));
m_setup.register_dev(dev);
m_setup.log().debug("Parser: IC: {1}\n", devname);

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

@ -103,15 +103,11 @@ void setup_t::namespace_pop()
}
device_t *setup_t::register_dev(device_t *dev, const pstring &name)
device_t *setup_t::register_dev(device_t *dev)
{
pstring fqn = build_fqn(name);
dev->init(netlist(), fqn);
for (auto & d : netlist().m_devices)
if (d->name() == dev->name())
log().fatal("Error adding {1} to device list. Duplicate name \n", name);
log().fatal("Error adding {1} to device list. Duplicate name \n", d->name());
netlist().m_devices.push_back(dev);
return dev;
@ -136,11 +132,11 @@ device_t *setup_t::register_dev(const pstring &classname, const pstring &name)
}
else
{
device_t *dev = factory().new_device_by_name(classname);
device_t *dev = factory().new_device_by_name(classname, netlist(), build_fqn(name));
//device_t *dev = factory().new_device_by_classname(classname);
if (dev == nullptr)
log().fatal("Class {1} not found!\n", classname);
return register_dev(dev, name);
return register_dev(dev);
}
}
@ -477,11 +473,12 @@ devices::nld_base_proxy *setup_t::get_d_a_proxy(core_terminal_t &out)
if (proxy == nullptr)
{
// create a new one ...
devices::nld_base_d_to_a_proxy *new_proxy = out_cast.logic_family()->create_d_a_proxy(&out_cast);
pstring x = pfmt("proxy_da_{1}_{2}")(out.name())(m_proxy_cnt);
devices::nld_base_d_to_a_proxy *new_proxy =
out_cast.logic_family()->create_d_a_proxy(netlist(), x, &out_cast);
m_proxy_cnt++;
register_dev(new_proxy, x);
register_dev(new_proxy);
new_proxy->start_dev();
/* connect all existing terminals to new net */
@ -506,12 +503,12 @@ void setup_t::connect_input_output(core_terminal_t &in, core_terminal_t &out)
if (out.isFamily(terminal_t::ANALOG) && in.isFamily(terminal_t::LOGIC))
{
logic_input_t &incast = dynamic_cast<logic_input_t &>(in);
devices::nld_a_to_d_proxy *proxy = palloc(devices::nld_a_to_d_proxy(&incast));
incast.set_proxy(proxy);
pstring x = pfmt("proxy_ad_{1}_{2}")(in.name())( m_proxy_cnt);
devices::nld_a_to_d_proxy *proxy = palloc(devices::nld_a_to_d_proxy(netlist(), x, &incast));
incast.set_proxy(proxy);
m_proxy_cnt++;
register_dev(proxy, x);
register_dev(proxy);
proxy->start_dev();
proxy->m_Q.net().register_con(in);
@ -545,12 +542,12 @@ void setup_t::connect_terminal_input(terminal_t &term, core_terminal_t &inp)
{
logic_input_t &incast = dynamic_cast<logic_input_t &>(inp);
log().debug("connect_terminal_input: connecting proxy\n");
devices::nld_a_to_d_proxy *proxy = palloc(devices::nld_a_to_d_proxy(&incast));
incast.set_proxy(proxy);
pstring x = pfmt("proxy_ad_{1}_{2}")(inp.name())(m_proxy_cnt);
devices::nld_a_to_d_proxy *proxy = palloc(devices::nld_a_to_d_proxy(netlist(), x, &incast));
incast.set_proxy(proxy);
m_proxy_cnt++;
register_dev(proxy, x);
register_dev(proxy);
proxy->start_dev();
connect_terminals(term, proxy->m_I);
@ -829,9 +826,9 @@ void setup_t::start_devices()
pstring_vector_t loglist(env, ":");
for (pstring ll : loglist)
{
device_t *nc = factory().new_device_by_name("LOG");
pstring name = "log_" + ll;
register_dev(nc, name);
device_t *nc = factory().new_device_by_name("LOG", netlist(), name);
register_dev(nc);
register_link(name + ".I", ll);
log().debug(" dynamic link {1}: <{2}>\n",ll, name);
}
@ -863,9 +860,10 @@ class logic_family_std_proxy_t : public logic_family_desc_t
{
public:
logic_family_std_proxy_t() { }
virtual devices::nld_base_d_to_a_proxy *create_d_a_proxy(logic_output_t *proxied) const override
virtual devices::nld_base_d_to_a_proxy *create_d_a_proxy(netlist_t &anetlist,
const pstring &name, logic_output_t *proxied) const override
{
return palloc(devices::nld_d_to_a_proxy(proxied));
return palloc(devices::nld_d_to_a_proxy(anetlist, name, proxied));
}
};

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

@ -137,7 +137,7 @@ namespace netlist
pstring build_fqn(const pstring &obj_name) const;
device_t *register_dev(device_t *dev, const pstring &name);
device_t *register_dev(device_t *dev);
device_t *register_dev(const pstring &classname, const pstring &name);
void remove_dev(const pstring &name);

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

@ -304,8 +304,7 @@ static void listdevices()
pstring out = pfmt("{1} {2}(<id>")(f->classname(),"-20")(f->name());
pstring terms("");
netlist::device_t *d = f->Create();
d->init(nt, pfmt("dummy{1}")(i));
netlist::device_t *d = f->Create(nt.setup().netlist(), pfmt("dummy{1}")(i));
d->start_dev();
// get the list of terminals ...

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

@ -84,7 +84,8 @@ public:
DESCENDING
};
matrix_solver_t(const eSortType sort, const solver_parameters_t *params);
matrix_solver_t(netlist_t &anetlist, const pstring &name,
const eSortType sort, const solver_parameters_t *params);
virtual ~matrix_solver_t();
void setup(analog_net_t::list_t &nets) { vsetup(nets); }

14
src/lib/netlist/solver/nld_ms_direct.h
View File

@ -121,8 +121,8 @@ class matrix_solver_direct_t: public matrix_solver_t
friend class matrix_solver_t;
public:
matrix_solver_direct_t(const solver_parameters_t *params, const int size);
matrix_solver_direct_t(const eSortType sort, const solver_parameters_t *params, const int size);
matrix_solver_direct_t(netlist_t &anetlist, const pstring &name, const solver_parameters_t *params, const int size);
matrix_solver_direct_t(netlist_t &anetlist, const pstring &name, const eSortType sort, const solver_parameters_t *params, const int size);
virtual ~matrix_solver_direct_t();
@ -415,8 +415,9 @@ inline int matrix_solver_direct_t<m_N, _storage_N>::vsolve_non_dynamic(const boo
}
template <unsigned m_N, unsigned _storage_N>
matrix_solver_direct_t<m_N, _storage_N>::matrix_solver_direct_t(const solver_parameters_t *params, const int size)
: matrix_solver_t(ASCENDING, params)
matrix_solver_direct_t<m_N, _storage_N>::matrix_solver_direct_t(netlist_t &anetlist, const pstring &name,
const solver_parameters_t *params, const int size)
: matrix_solver_t(anetlist, name, ASCENDING, params)
, m_dim(size)
{
#if (NL_USE_DYNAMIC_ALLOCATION)
@ -432,8 +433,9 @@ matrix_solver_direct_t<m_N, _storage_N>::matrix_solver_direct_t(const solver_par
}
template <unsigned m_N, unsigned _storage_N>
matrix_solver_direct_t<m_N, _storage_N>::matrix_solver_direct_t(const eSortType sort, const solver_parameters_t *params, const int size)
: matrix_solver_t(sort, params)
matrix_solver_direct_t<m_N, _storage_N>::matrix_solver_direct_t(netlist_t &anetlist, const pstring &name,
const eSortType sort, const solver_parameters_t *params, const int size)
: matrix_solver_t(anetlist, name, sort, params)
, m_dim(size)
{
#if (NL_USE_DYNAMIC_ALLOCATION)

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

@ -17,8 +17,8 @@ class matrix_solver_direct1_t: public matrix_solver_direct_t<1,1>
{
public:
matrix_solver_direct1_t(const solver_parameters_t *params)
: matrix_solver_direct_t<1, 1>(params, 1)
matrix_solver_direct1_t(netlist_t &anetlist, const pstring &name, const solver_parameters_t *params)
: matrix_solver_direct_t<1, 1>(anetlist, name, params, 1)
{}
virtual int vsolve_non_dynamic(const bool newton_raphson) override;

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

@ -17,8 +17,8 @@ class matrix_solver_direct2_t: public matrix_solver_direct_t<2,2>
{
public:
matrix_solver_direct2_t(const solver_parameters_t *params)
: matrix_solver_direct_t<2, 2>(params, 2)
matrix_solver_direct2_t(netlist_t &anetlist, const pstring &name, const solver_parameters_t *params)
: matrix_solver_direct_t<2, 2>(anetlist, name, params, 2)
{}
virtual int vsolve_non_dynamic(const bool newton_raphson) override;

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

@ -30,8 +30,9 @@ class matrix_solver_GCR_t: public matrix_solver_t
{
public:
matrix_solver_GCR_t(const solver_parameters_t *params, int size)
: matrix_solver_t(matrix_solver_t::ASCENDING, params)
matrix_solver_GCR_t(netlist_t &anetlist, const pstring &name,
const solver_parameters_t *params, int size)
: matrix_solver_t(anetlist, name, matrix_solver_t::ASCENDING, params)
, m_dim(size)
, m_proc(nullptr)
{

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

@ -26,8 +26,8 @@ class matrix_solver_GMRES_t: public matrix_solver_direct_t<m_N, _storage_N>
{
public:
matrix_solver_GMRES_t(const solver_parameters_t *params, int size)
: matrix_solver_direct_t<m_N, _storage_N>(matrix_solver_t::ASCENDING, params, size)
matrix_solver_GMRES_t(netlist_t &anetlist, const pstring &name, const solver_parameters_t *params, int size)
: matrix_solver_direct_t<m_N, _storage_N>(anetlist, name, matrix_solver_t::ASCENDING, params, size)
, m_use_iLU_preconditioning(true)
, m_use_more_precise_stop_condition(false)
, m_accuracy_mult(1.0)

8
src/lib/netlist/solver/nld_ms_sm.h
View File

@ -52,7 +52,8 @@ class matrix_solver_sm_t: public matrix_solver_t
public:
matrix_solver_sm_t(const solver_parameters_t *params, const int size);
matrix_solver_sm_t(netlist_t &anetlist, const pstring &name,
const solver_parameters_t *params, const int size);
virtual ~matrix_solver_sm_t();
@ -324,8 +325,9 @@ inline int matrix_solver_sm_t<m_N, _storage_N>::vsolve_non_dynamic(const bool ne
}
template <unsigned m_N, unsigned _storage_N>
matrix_solver_sm_t<m_N, _storage_N>::matrix_solver_sm_t(const solver_parameters_t *params, const int size)
: matrix_solver_t(NOSORT, params)
matrix_solver_sm_t<m_N, _storage_N>::matrix_solver_sm_t(netlist_t &anetlist, const pstring &name,
const solver_parameters_t *params, const int size)
: matrix_solver_t(anetlist, name, NOSORT, params)
, m_dim(size)
{
#if (NL_USE_DYNAMIC_ALLOCATION)

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

@ -24,8 +24,8 @@ class matrix_solver_SOR_t: public matrix_solver_direct_t<m_N, _storage_N>
{
public:
matrix_solver_SOR_t(const solver_parameters_t *params, int size)
: matrix_solver_direct_t<m_N, _storage_N>(matrix_solver_t::ASCENDING, params, size)
matrix_solver_SOR_t(netlist_t &anetlist, const pstring &name, const solver_parameters_t *params, int size)
: matrix_solver_direct_t<m_N, _storage_N>(anetlist, name, matrix_solver_t::ASCENDING, params, size)
, m_lp_fact(0)
{
}

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

@ -27,8 +27,8 @@ class matrix_solver_SOR_mat_t: public matrix_solver_direct_t<m_N, _storage_N>
public:
matrix_solver_SOR_mat_t(const solver_parameters_t *params, int size)
: matrix_solver_direct_t<m_N, _storage_N>(matrix_solver_t::DESCENDING, params, size)
matrix_solver_SOR_mat_t(netlist_t &anetlist, const pstring &name, const solver_parameters_t *params, int size)
: matrix_solver_direct_t<m_N, _storage_N>(anetlist, name, matrix_solver_t::DESCENDING, params, size)
, m_omega(params->m_sor)
, m_lp_fact(0)
, m_gs_fail(0)

7
src/lib/netlist/solver/nld_ms_w.h
View File

@ -58,7 +58,7 @@ class matrix_solver_w_t: public matrix_solver_t
friend class matrix_solver_t;
public:
matrix_solver_w_t(const solver_parameters_t *params, const int size);
matrix_solver_w_t(netlist_t &anetlist, const pstring &name, const solver_parameters_t *params, const int size);
virtual ~matrix_solver_w_t();
@ -389,8 +389,9 @@ inline int matrix_solver_w_t<m_N, _storage_N>::vsolve_non_dynamic(const bool new
}
template <unsigned m_N, unsigned _storage_N>
matrix_solver_w_t<m_N, _storage_N>::matrix_solver_w_t(const solver_parameters_t *params, const int size)
: matrix_solver_t(NOSORT, params)
matrix_solver_w_t<m_N, _storage_N>::matrix_solver_w_t(netlist_t &anetlist, const pstring &name,
const solver_parameters_t *params, const int size)
: matrix_solver_t(anetlist, name, NOSORT, params)
,m_cnt(0)
, m_dim(size)
{

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

@ -94,8 +94,10 @@ ATTR_COLD void terms_t::set_pointers()
// matrix_solver
// ----------------------------------------------------------------------------------------
ATTR_COLD matrix_solver_t::matrix_solver_t(const eSortType sort, const solver_parameters_t *params)
: m_stat_calculations(0),
ATTR_COLD matrix_solver_t::matrix_solver_t(netlist_t &anetlist, const pstring &name,
const eSortType sort, const solver_parameters_t *params)
: device_t(anetlist, name),
m_stat_calculations(0),
m_stat_newton_raphson(0),
m_stat_vsolver_calls(0),
m_iterative_fail(0),
@ -707,10 +709,11 @@ NETLIB_UPDATE(solver)
template <int m_N, int _storage_N>
matrix_solver_t * NETLIB_NAME(solver)::create_solver(int size, const bool use_specific)
{
pstring solvername = pfmt("Solver_{1}")(m_mat_solvers.size());
if (use_specific && m_N == 1)
return palloc(matrix_solver_direct1_t(&m_params));
return palloc(matrix_solver_direct1_t(netlist(), solvername, &m_params));
else if (use_specific && m_N == 2)
return palloc(matrix_solver_direct2_t(&m_params));
return palloc(matrix_solver_direct2_t(netlist(), solvername, &m_params));
else
{
if (size >= m_gs_threshold)
@ -718,39 +721,39 @@ matrix_solver_t * NETLIB_NAME(solver)::create_solver(int size, const bool use_sp
if (pstring("SOR_MAT").equals(m_iterative_solver))
{
typedef matrix_solver_SOR_mat_t<m_N,_storage_N> solver_sor_mat;
return palloc(solver_sor_mat(&m_params, size));
return palloc(solver_sor_mat(netlist(), solvername, &m_params, size));
}
else if (pstring("MAT_CR").equals(m_iterative_solver))
{
typedef matrix_solver_GCR_t<m_N,_storage_N> solver_mat;
return palloc(solver_mat(&m_params, size));
return palloc(solver_mat(netlist(), solvername, &m_params, size));
}
else if (pstring("MAT").equals(m_iterative_solver))
{
typedef matrix_solver_direct_t<m_N,_storage_N> solver_mat;
return palloc(solver_mat(&m_params, size));
return palloc(solver_mat(netlist(), solvername, &m_params, size));
}
else if (pstring("SM").equals(m_iterative_solver))
{
/* Sherman-Morrison Formula */
typedef matrix_solver_sm_t<m_N,_storage_N> solver_mat;
return palloc(solver_mat(&m_params, size));
return palloc(solver_mat(netlist(), solvername, &m_params, size));
}
else if (pstring("W").equals(m_iterative_solver))
{
/* Woodbury Formula */
typedef matrix_solver_w_t<m_N,_storage_N> solver_mat;
return palloc(solver_mat(&m_params, size));
return palloc(solver_mat(netlist(), solvername, &m_params, size));
}
else if (pstring("SOR").equals(m_iterative_solver))
{
typedef matrix_solver_SOR_t<m_N,_storage_N> solver_GS;
return palloc(solver_GS(&m_params, size));
return palloc(solver_GS(netlist(), solvername, &m_params, size));
}
else if (pstring("GMRES").equals(m_iterative_solver))
{
typedef matrix_solver_GMRES_t<m_N,_storage_N> solver_GMRES;
return palloc(solver_GMRES(&m_params, size));
return palloc(solver_GMRES(netlist(), solvername, &m_params, size));
}
else
{
@ -761,7 +764,7 @@ matrix_solver_t * NETLIB_NAME(solver)::create_solver(int size, const bool use_sp
else
{
typedef matrix_solver_direct_t<m_N,_storage_N> solver_D;
return palloc(solver_D(&m_params, size));
return palloc(solver_D(netlist(), solvername, &m_params, size));
}
}
}
@ -900,7 +903,7 @@ ATTR_COLD void NETLIB_NAME(solver)::post_start()
break;
}
register_sub(pfmt("Solver_{1}")(m_mat_solvers.size()), *ms);
register_sub(*ms);
ms->setup(grp);

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

@ -54,8 +54,8 @@ class matrix_solver_t;
class NETLIB_NAME(solver) : public device_t
{
public:
NETLIB_NAME(solver)()
: device_t() { }
NETLIB_NAME(solver)(netlist_t &anetlist, const pstring &name)
: device_t(anetlist, name) { }
virtual ~NETLIB_NAME(solver)();