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

Converted more devices to new layout. Improved memory handling in

Browse Source 
factories. (nw)
This commit is contained in:
couriersud 2016-05-16 22:36:46 +02:00
parent 17d85d78d1
commit d200744fbf
29 changed files with 513 additions and 421 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

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

@ -100,9 +100,9 @@ void netlist_mame_analog_output_t::custom_netlist_additions(netlist::setup_t &se
pstring dname = "OUT_" + m_in;
m_delegate.bind_relative_to(owner()->machine().root_device());
auto dev = std::make_shared<NETLIB_NAME(analog_callback)>(setup.netlist(), setup.build_fqn(dname));
setup.register_dev(dev);
dev->register_callback(m_delegate);
powned_ptr<netlist::device_t> dev = powned_ptr<netlist::device_t>::Create<NETLIB_NAME(analog_callback)>(setup.netlist(), setup.build_fqn(dname));
static_cast<NETLIB_NAME(analog_callback) *>(dev.get())->register_callback(m_delegate);
setup.register_dev(std::move(dev));
setup.register_link(dname + ".IN", m_in);
}

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

@ -74,7 +74,7 @@ private:
};
#define MEMREGION_SOURCE(_name) \
setup.register_source(palloc(netlist_source_memregion_t(_name)));
setup.register_source(std::make_shared<netlist_source_memregion_t>(_name));
#define NETDEV_ANALOG_CALLBACK_MEMBER(_name) \
void _name(const double data, const attotime &time)

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

@ -9,61 +9,6 @@
NETLIB_NAMESPACE_DEVICES_START()
NETLIB_START(CD4020)
{
set_logic_family(family_CD4XXX);
register_sub("sub", sub);
register_sub("supply", m_supply);
enregister("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);
}
NETLIB_RESET(CD4020)
{
sub->do_reset();
}
NETLIB_START(CD4020_sub)
{
enregister("IP", m_IP);
enregister("Q1", m_Q[0]);
enregister("Q4", m_Q[3]);
enregister("Q5", m_Q[4]);
enregister("Q6", m_Q[5]);
enregister("Q7", m_Q[6]);
enregister("Q8", m_Q[7]);
enregister("Q9", m_Q[8]);
enregister("Q10", m_Q[9]);
enregister("Q11", m_Q[10]);
enregister("Q12", m_Q[11]);
enregister("Q13", m_Q[12]);
enregister("Q14", m_Q[13]);
save(NLNAME(m_cnt));
}
NETLIB_RESET(CD4020_sub)
{
m_IP.set_state(logic_t::STATE_INP_HL);
m_cnt = 0;
}
NETLIB_UPDATE(CD4020_sub)
{
@ -77,15 +22,15 @@ NETLIB_UPDATE(CD4020)
{
if (INPLOGIC(m_RESET))
{
sub->m_cnt = 0;
sub->m_IP.inactivate();
m_sub.m_cnt = 0;
m_sub.m_IP.inactivate();
/* static */ const netlist_time reset_time = netlist_time::from_nsec(140);
OUTLOGIC(sub->m_Q[0], 0, reset_time);
OUTLOGIC(m_sub.m_Q[0], 0, reset_time);
for (int i=3; i<14; i++)
OUTLOGIC(sub->m_Q[i], 0, reset_time);
OUTLOGIC(m_sub.m_Q[i], 0, reset_time);
}
else
sub->m_IP.activate_hl();
m_sub.m_IP.activate_hl();
}
inline NETLIB_FUNC_VOID(CD4020_sub, update_outputs, (const UINT16 cnt))

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

@ -43,22 +43,83 @@
NETLIB_NAMESPACE_DEVICES_START()
NETLIB_SUBDEVICE(CD4020_sub,
NETLIB_OBJECT(CD4020_sub)
{
NETLIB_CONSTRUCTOR(CD4020_sub)
NETLIB_FAMILY("CD4XXX")
, m_cnt(0)
{
enregister("IP", m_IP);
enregister("Q1", m_Q[0]);
enregister("Q4", m_Q[3]);
enregister("Q5", m_Q[4]);
enregister("Q6", m_Q[5]);
enregister("Q7", m_Q[6]);
enregister("Q8", m_Q[7]);
enregister("Q9", m_Q[8]);
enregister("Q10", m_Q[9]);
enregister("Q11", m_Q[10]);
enregister("Q12", m_Q[11]);
enregister("Q13", m_Q[12]);
enregister("Q14", m_Q[13]);
save(NLNAME(m_cnt));
}
NETLIB_RESETI()
{
m_IP.set_state(logic_t::STATE_INP_HL);
m_cnt = 0;
}
NETLIB_UPDATEI();
public:
ATTR_HOT void update_outputs(const UINT16 cnt);
logic_input_t m_IP;
logic_output_t m_Q[14];
UINT16 m_cnt;
};
logic_output_t m_Q[14];
);
NETLIB_OBJECT(CD4020)
{
NETLIB_CONSTRUCTOR(CD4020)
NETLIB_FAMILY("CD4XXX")
, m_sub(*this, "sub")
, m_supply(*this, "supply")
{
NETLIB_DEVICE(CD4020,
NETLIB_SUBXX(CD4020_sub) sub;
NETLIB_SUBXX(vdd_vss) m_supply;
enregister("RESET", m_RESET);
register_subalias("IP", m_sub.m_IP);
register_subalias("Q1", m_sub.m_Q[0]);
register_subalias("Q4", m_sub.m_Q[3]);
register_subalias("Q5", m_sub.m_Q[4]);
register_subalias("Q6", m_sub.m_Q[5]);
register_subalias("Q7", m_sub.m_Q[6]);
register_subalias("Q8", m_sub.m_Q[7]);
register_subalias("Q9", m_sub.m_Q[8]);
register_subalias("Q10", m_sub.m_Q[9]);
register_subalias("Q11", m_sub.m_Q[10]);
register_subalias("Q12", m_sub.m_Q[11]);
register_subalias("Q13", m_sub.m_Q[12]);
register_subalias("Q14", m_sub.m_Q[13]);
register_subalias("VDD", m_supply.m_vdd);
register_subalias("VSS", m_supply.m_vss);
}
NETLIB_RESETI()
{
m_sub.do_reset();
}
NETLIB_UPDATEI();
private:
NETLIB_SUB(CD4020_sub) m_sub;
NETLIB_SUB(vdd_vss) m_supply;
logic_input_t m_RESET;
);
};
NETLIB_NAMESPACE_DEVICES_END()

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

@ -9,26 +9,12 @@
NETLIB_NAMESPACE_DEVICES_START()
NETLIB_START(CD4066_GATE)
{
set_logic_family(family_CD4XXX);
enregister("CTL", m_control);
register_sub("PS", m_supply);
register_sub("R", m_R);
register_param("BASER", m_base_r, 270.0);
}
NETLIB_RESET(CD4066_GATE)
{
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;
@ -43,16 +29,16 @@ NETLIB_UPDATE(CD4066_GATE)
if (R > NL_FCONST(0.0))
{
// 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())
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();
}
}
}

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

@ -32,15 +32,30 @@
NETLIB_NAMESPACE_DEVICES_START()
NETLIB_DEVICE(CD4066_GATE,
NETLIB_OBJECT(CD4066_GATE)
{
NETLIB_CONSTRUCTOR(CD4066_GATE)
NETLIB_FAMILY("CD4XXX")
, m_supply(*this, "PS")
, m_R(*this, "R")
{
register_param("BASER", m_base_r, 270.0);
enregister("CTL", m_control);
}
NETLIB_RESETI()
{
m_R.do_reset();
}
NETLIB_UPDATEI();
public:
NETLIB_SUB(vdd_vss) m_supply;
NETLIB_SUB(R) m_R;
analog_input_t m_control;
NETLIB_SUBXX(R) m_R;
NETLIB_SUBXX(vdd_vss) m_supply;
param_double_t m_base_r;
);
};
NETLIB_NAMESPACE_DEVICES_END()

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

@ -226,7 +226,7 @@ NETLIB_RESET(9602_dip)
NETLIB_START(4538_dip)
{
set_logic_family(family_CD4XXX);
set_logic_family(family_CD4XXX());
register_sub("1", m_1);
register_sub("2", m_2);

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

@ -63,87 +63,36 @@ NETLIB_START(7448_dip)
}
#else
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);
enregister("LTQ", m_LTQ);
enregister("BIQ", m_BIQ);
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]);
}
NETLIB_RESET(7448)
{
sub->do_reset();
}
NETLIB_UPDATE(7448)
{
if (INPLOGIC(m_BIQ) && !INPLOGIC(m_LTQ))
{
sub->update_outputs(8);
m_sub.update_outputs(8);
}
else if (!INPLOGIC(m_BIQ))
{
sub->update_outputs(15);
m_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();
m_sub.m_A.inactivate();
m_sub.m_B.inactivate();
m_sub.m_C.inactivate();
m_sub.m_D.inactivate();
m_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();
m_sub.m_RBIQ.activate();
m_sub.m_D.activate();
m_sub.m_C.activate();
m_sub.m_B.activate();
m_sub.m_A.activate();
m_sub.do_update();
}
}
NETLIB_START(7448_sub)
{
enregister("A0", m_A);
enregister("A1", m_B);
enregister("A2", m_C);
enregister("A3", m_D);
enregister("RBIQ", m_RBIQ);
enregister("a", m_Q[0]);
enregister("b", m_Q[1]);
enregister("c", m_Q[2]);
enregister("d", m_Q[3]);
enregister("e", m_Q[4]);
enregister("f", m_Q[5]);
enregister("g", m_Q[6]);
save(NLNAME(m_state));
}
NETLIB_RESET(7448_sub)
{
m_state = 0;
}
NETLIB_UPDATE(7448_sub)
{
UINT8 v;
@ -191,21 +140,21 @@ NETLIB_START(7448_dip)
{
NETLIB_NAME(7448)::start();
register_subalias("1", sub->m_B);
register_subalias("2", sub->m_C);
register_subalias("1", m_sub.m_B);
register_subalias("2", m_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",m_sub.m_RBIQ);
register_subalias("6", m_sub.m_D);
register_subalias("7", m_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", m_sub.m_Q[4]); // e
register_subalias("10", m_sub.m_Q[3]); // d
register_subalias("11", m_sub.m_Q[2]); // c
register_subalias("12", m_sub.m_Q[1]); // b
register_subalias("13", m_sub.m_Q[0]); // a
register_subalias("14", m_sub.m_Q[6]); // g
register_subalias("15", m_sub.m_Q[5]); // f
}
#endif

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

@ -54,7 +54,32 @@ NETLIB_TRUTHTABLE(7448, 7, 7, 0);
#else
NETLIB_SUBDEVICE(7448_sub,
NETLIB_OBJECT(7448_sub)
{
NETLIB_CONSTRUCTOR(7448_sub)
, m_state(0)
{
enregister("A0", m_A);
enregister("A1", m_B);
enregister("A2", m_C);
enregister("A3", m_D);
enregister("RBIQ", m_RBIQ);
enregister("a", m_Q[0]);
enregister("b", m_Q[1]);
enregister("c", m_Q[2]);
enregister("d", m_Q[3]);
enregister("e", m_Q[4]);
enregister("f", m_Q[5]);
enregister("g", m_Q[6]);
save(NLNAME(m_state));
}
NETLIB_RESETI() { m_state = 0; }
NETLIB_UPDATEI();
public:
ATTR_HOT void update_outputs(UINT8 v);
static const UINT8 tab7448[16][7];
@ -68,15 +93,40 @@ NETLIB_SUBDEVICE(7448_sub,
logic_output_t m_Q[7]; /* a .. g */
);
};
NETLIB_OBJECT(7448)
{
NETLIB_CONSTRUCTOR(7448)
, m_sub(*this, "sub")
{
register_subalias("A", m_sub.m_A);
register_subalias("B", m_sub.m_B);
register_subalias("C", m_sub.m_C);
register_subalias("D", m_sub.m_D);
enregister("LTQ", m_LTQ);
enregister("BIQ", m_BIQ);
register_subalias("RBIQ",m_sub.m_RBIQ);
register_subalias("a", m_sub.m_Q[0]);
register_subalias("b", m_sub.m_Q[1]);
register_subalias("c", m_sub.m_Q[2]);
register_subalias("d", m_sub.m_Q[3]);
register_subalias("e", m_sub.m_Q[4]);
register_subalias("f", m_sub.m_Q[5]);
register_subalias("g", m_sub.m_Q[6]);
}
NETLIB_RESETI() { m_sub.do_reset(); }
NETLIB_UPDATEI();
NETLIB_DEVICE(7448,
public:
NETLIB_SUBXX(7448_sub) sub;
NETLIB_SUB(7448_sub) m_sub;
logic_input_t m_LTQ;
logic_input_t m_BIQ;
);
};
#endif
NETLIB_DEVICE_DERIVED_PURE(7448_dip, 7448);

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

@ -72,6 +72,7 @@ NETLIB_OBJECT(7474sub)
NETLIB_RESETI();
NETLIB_UPDATEI();
public:
logic_input_t m_CLK;
logic_output_t m_Q;
logic_output_t m_QQ;

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

@ -85,6 +85,7 @@ NETLIB_OBJECT(7493ff)
NETLIB_RESETI();
NETLIB_UPDATEI();
public:
logic_input_t m_I;
logic_output_t m_Q;

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

@ -44,27 +44,6 @@
NETLIB_NAMESPACE_DEVICES_START()
NETLIB_START(SN74LS629clk)
{
enregister("FB", m_FB);
enregister("Y", m_Y);
connect_late(m_FB, m_Y);
reset();
save(NLNAME(m_enableq));
save(NLNAME(m_inc));
save(NLNAME(m_out));
}
NETLIB_RESET(SN74LS629clk)
{
m_enableq = 1;
m_out = 0;
m_inc = netlist_time::zero;
}
NETLIB_UPDATE(SN74LS629clk)
{
if (!m_enableq)
@ -78,32 +57,6 @@ NETLIB_UPDATE(SN74LS629clk)
}
}
NETLIB_START(SN74LS629)
{
register_sub("OSC", m_clock);
register_sub("R_FC", m_R_FC);
register_sub("R_RNG", m_R_RNG);
enregister("ENQ", m_ENQ);
enregister("RNG", m_RNG);
enregister("FC", m_FC);
register_subalias("GND", m_R_FC->m_N);
connect_late(m_FC, m_R_FC->m_P);
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_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();
}
NETLIB_UPDATE(SN74LS629)
{
{
@ -147,64 +100,24 @@ 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));
}
}
NETLIB_UPDATE_PARAM(SN74LS629)
{
update_dev();
}
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("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("10", m_2->m_clock->m_Y);
register_subalias("11", m_2->m_ENQ);
register_subalias("14", m_2->m_RNG);
}
NETLIB_UPDATE(SN74LS629_dip)
{
}
NETLIB_RESET(SN74LS629_dip)
{
m_1->do_reset();
m_2->do_reset();
}
NETLIB_NAMESPACE_DEVICES_END()

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

@ -35,39 +35,125 @@
NET_REGISTER_DEV(SN74LS629, _name) \
NETDEV_PARAMI(_name, CAP, _cap)
#define SN74LS629_DIP(_name, _cap1, _cap2) \
NET_REGISTER_DEV(SN74LS629_DIP, _name) \
NETDEV_PARAMI(_name, 1.CAP, _cap1) \
NETDEV_PARAMI(_name, 2.CAP, _cap2)
NETLIB_NAMESPACE_DEVICES_START()
NETLIB_SUBDEVICE(SN74LS629clk,
NETLIB_OBJECT(SN74LS629clk)
{
NETLIB_CONSTRUCTOR(SN74LS629clk)
, m_enableq(1)
, m_out(0)
, m_inc(netlist_time::zero)
{
enregister("FB", m_FB);
enregister("Y", m_Y);
connect_late(m_FB, m_Y);
save(NLNAME(m_enableq));
save(NLNAME(m_inc));
save(NLNAME(m_out));
}
NETLIB_RESETI()
{
m_enableq = 1;
m_out = 0;
m_inc = netlist_time::zero;
}
NETLIB_UPDATEI();
public:
logic_input_t m_FB;
logic_output_t m_Y;
netlist_time m_inc;
netlist_sig_t m_enableq;
netlist_sig_t m_out;
);
netlist_time m_inc;
};
NETLIB_OBJECT(SN74LS629)
{
NETLIB_CONSTRUCTOR(SN74LS629)
, m_clock(*this, "OSC")
, m_R_FC(*this, "R_FC")
, m_R_RNG(*this, "R_RNG")
{
enregister("ENQ", m_ENQ);
enregister("RNG", m_RNG);
enregister("FC", m_FC);
register_subalias("GND", m_R_FC.m_N);
connect_late(m_FC, m_R_FC.m_P);
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_param("CAP", m_CAP, 1e-6);
}
NETLIB_RESETI()
{
m_R_FC.set_R(90000.0);
m_R_RNG.set_R(90000.0);
m_clock.do_reset();
}
NETLIB_UPDATEI();
NETLIB_UPDATE_PARAMI() { update_dev(); }
NETLIB_DEVICE_WITH_PARAMS(SN74LS629,
public:
NETLIB_SUBXX(SN74LS629clk) m_clock;
NETLIB_SUBXX(R_base) m_R_FC;
NETLIB_SUBXX(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;
analog_input_t m_FC;
param_double_t m_CAP;
);
};
#define SN74LS629_DIP(_name, _cap1, _cap2) \
NET_REGISTER_DEV(SN74LS629_DIP, _name) \
NETDEV_PARAMI(_name, 1.CAP, _cap1) \
NETDEV_PARAMI(_name, 2.CAP, _cap2)
NETLIB_OBJECT(SN74LS629_dip)
{
NETLIB_CONSTRUCTOR(SN74LS629_dip)
, m_1(*this, "1")
, m_2(*this, "2")
{
register_subalias("1", m_2.m_FC);
register_subalias("2", m_1.m_FC);
register_subalias("3", m_1.m_RNG);
NETLIB_DEVICE(SN74LS629_dip,
NETLIB_SUBXX(SN74LS629) m_1;
NETLIB_SUBXX(SN74LS629) m_2;
);
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("10", m_2.m_clock.m_Y);
register_subalias("11", m_2.m_ENQ);
register_subalias("14", m_2.m_RNG);
}
NETLIB_UPDATEI() { }
NETLIB_RESETI()
{
m_1.do_reset();
m_2.do_reset();
}
private:
NETLIB_SUB(SN74LS629) m_1;
NETLIB_SUB(SN74LS629) m_2;
};
NETLIB_NAMESPACE_DEVICES_END()

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

@ -13,26 +13,23 @@
NETLIB_NAMESPACE_DEVICES_START()
class NETLIB_NAME(vdd_vss) : public device_t
NETLIB_OBJECT(vdd_vss)
{
public:
NETLIB_CONSTRUCTOR(vdd_vss) { }
NETLIB_CONSTRUCTOR(vdd_vss)
{
enregister("VDD", m_vdd);
enregister("VSS", m_vss);
}
analog_input_t m_vdd;
analog_input_t m_vss;
protected:
ATTR_HOT void update() override {};
ATTR_HOT void start() override
{
enregister("VDD", m_vdd);
enregister("VSS", m_vss);
};
ATTR_HOT void reset() override {};
NETLIB_UPDATEI() {};
NETLIB_RESETI() {};
public:
ATTR_HOT inline nl_double vdd() { return INPANALOG(m_vdd); }
ATTR_HOT inline nl_double vss() { return INPANALOG(m_vss); }
analog_input_t m_vdd;
analog_input_t m_vss;
};
NETLIB_NAMESPACE_DEVICES_END()

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

@ -17,7 +17,7 @@ NETLIB_START(log)
enregister("I", m_I);
pstring filename = pfmt("{1}.log")(name());
m_strm = palloc(pofilestream(filename));
m_strm = std::make_unique<pofilestream>(filename);
}
NETLIB_RESET(log)
@ -33,7 +33,6 @@ NETLIB_UPDATE(log)
NETLIB_NAME(log)::~NETLIB_NAME(log)()
{
m_strm->close();
pfree(m_strm);
}
NETLIB_START(logD)

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

@ -31,7 +31,7 @@ NETLIB_DEVICE(log,
~NETLIB_NAME(log)();
analog_input_t m_I;
protected:
pofilestream *m_strm;
std::unique_ptr<pofilestream> m_strm;
);
#define LOGD(_name, _I, _I2) \

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

@ -500,9 +500,9 @@ public:
pstring m_dev_name;
};
device_t *Create(netlist_t &anetlist, const pstring &name) override
powned_ptr<device_t> Create(netlist_t &anetlist, const pstring &name) override
{
return palloc(wrapper(this->name(), anetlist, name));
return powned_ptr<device_t>::Create<wrapper>(this->name(), anetlist, name);
}
private:

6
src/lib/netlist/devices/nld_truthtable.cpp
View File

@ -243,13 +243,13 @@ void truthtable_desc_t::setup(const pstring_vector_t &truthtable, UINT32 disable
#define ENTRYX(_n,_m,_h) case (_n * 1000 + _m * 10 + _h): \
{ using xtype = netlist_factory_truthtable_t<_n,_m,_h>; \
return palloc(xtype(name,classname,def_param)); } break
return powned_ptr<netlist_base_factory_truthtable_t>::Create<xtype>(name,classname,def_param); } break
#define ENTRYY(_n,_m) ENTRYX(_n,_m,0); ENTRYX(_n,_m,1)
#define ENTRY(_n) ENTRYY(_n, 1); ENTRYY(_n, 2); ENTRYY(_n, 3); ENTRYY(_n, 4); ENTRYY(_n, 5); ENTRYY(_n, 6)
netlist_base_factory_truthtable_t *nl_tt_factory_create(const unsigned ni, const unsigned no,
powned_ptr<netlist_base_factory_truthtable_t> nl_tt_factory_create(const unsigned ni, const unsigned no,
const unsigned has_state,
const pstring &name, const pstring &classname,
const pstring &def_param)
@ -270,7 +270,7 @@ netlist_base_factory_truthtable_t *nl_tt_factory_create(const unsigned ni, const
pstring msg = pfmt("unable to create truthtable<{1},{2},{3}>")(ni)(no)(has_state);
nl_assert_always(false, msg);
}
return nullptr;
//return nullptr;
}
NETLIB_NAMESPACE_DEVICES_END()

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

@ -27,7 +27,7 @@
#define TRUTHTABLE_START(_name, _in, _out, _has_state, _def_params) \
{ \
netlist::devices::netlist_base_factory_truthtable_t *ttd = netlist::devices::nl_tt_factory_create(_in, _out, _has_state, \
auto ttd = netlist::devices::nl_tt_factory_create(_in, _out, _has_state, \
# _name, # _name, "+" _def_params);
#define TT_HEAD(_x) \
@ -40,7 +40,7 @@
ttd->m_family = setup.family_from_model(_x);
#define TRUTHTABLE_END() \
setup.factory().register_device(ttd); \
setup.factory().register_device(std::move(ttd)); \
}
NETLIB_NAMESPACE_DEVICES_START()
@ -114,7 +114,7 @@ public:
};
template <class C>
nld_truthtable_t(C &owner, const pstring &name, logic_family_desc_t *fam,
nld_truthtable_t(C &owner, const pstring &name, const logic_family_desc_t *fam,
truthtable_t *ttbl, const char *desc[])
: device_t(owner, name)
, m_fam(*this, fam)
@ -132,7 +132,7 @@ public:
}
template <class C>
nld_truthtable_t(C &owner, const pstring &name, logic_family_desc_t *fam,
nld_truthtable_t(C &owner, const pstring &name, const logic_family_desc_t *fam,
truthtable_t *ttbl, const pstring_vector_t &desc)
: device_t(owner, name)
, m_fam(*this, fam)
@ -316,7 +316,7 @@ class netlist_base_factory_truthtable_t : public base_factory_t
public:
netlist_base_factory_truthtable_t(const pstring &name, const pstring &classname,
const pstring &def_param)
: base_factory_t(name, classname, def_param), m_family(family_TTL)
: base_factory_t(name, classname, def_param), m_family(family_TTL())
{}
virtual ~netlist_base_factory_truthtable_t()
@ -326,7 +326,7 @@ public:
}
pstring_vector_t m_desc;
logic_family_desc_t *m_family;
const logic_family_desc_t *m_family;
};
@ -339,18 +339,16 @@ public:
const pstring &def_param)
: netlist_base_factory_truthtable_t(name, classname, def_param) { }
device_t *Create(netlist_t &anetlist, const pstring &name) override
powned_ptr<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(anetlist, name, m_family, &m_ttbl, m_desc));
//r->init(setup, name);
return r;
return powned_ptr<device_t>::Create<tt_type>(anetlist, name, m_family, &m_ttbl, m_desc);
}
private:
typename nld_truthtable_t<m_NI, m_NO, has_state>::truthtable_t m_ttbl;
};
netlist_base_factory_truthtable_t *nl_tt_factory_create(const unsigned ni, const unsigned no,
powned_ptr<netlist_base_factory_truthtable_t> nl_tt_factory_create(const unsigned ni, const unsigned no,
const unsigned has_state,
const pstring &name, const pstring &classname,
const pstring &def_param);

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

@ -16,7 +16,7 @@
#include "devices/nld_system.h"
#include "nl_util.h"
const netlist::netlist_time netlist::netlist_time::zero = netlist::netlist_time::from_raw(0);
const netlist::netlist_time netlist::netlist_time::zero = netlist::netlist_time(0);
namespace netlist
{
@ -38,9 +38,9 @@ public:
m_R_high = 130.0;
m_is_static = true;
}
virtual std::shared_ptr<devices::nld_base_d_to_a_proxy> create_d_a_proxy(netlist_t &anetlist, const pstring &name, logic_output_t *proxied) const override
virtual powned_ptr<devices::nld_base_d_to_a_proxy> create_d_a_proxy(netlist_t &anetlist, const pstring &name, logic_output_t *proxied) const override
{
return std::make_shared<devices::nld_d_to_a_proxy>(anetlist, name, proxied);
return powned_ptr<devices::nld_base_d_to_a_proxy>::Create<devices::nld_d_to_a_proxy>(anetlist, name, proxied);
}
};
@ -59,14 +59,22 @@ public:
m_R_high = 10.0;
m_is_static = true;
}
virtual std::shared_ptr<devices::nld_base_d_to_a_proxy> create_d_a_proxy(netlist_t &anetlist, const pstring &name, logic_output_t *proxied) const override
virtual powned_ptr<devices::nld_base_d_to_a_proxy> create_d_a_proxy(netlist_t &anetlist, const pstring &name, logic_output_t *proxied) const override
{
return std::make_shared<devices::nld_d_to_a_proxy>(anetlist, name, proxied);
return powned_ptr<devices::nld_base_d_to_a_proxy>::Create<devices::nld_d_to_a_proxy>(anetlist, name, proxied);
}
};
logic_family_desc_t *family_TTL = palloc(logic_family_ttl_t);
logic_family_desc_t *family_CD4XXX = palloc(logic_family_cd4xxx_t);
const logic_family_desc_t *family_TTL()
{
static logic_family_ttl_t obj;
return &obj;
}
const logic_family_desc_t *family_CD4XXX()
{
static logic_family_cd4xxx_t obj;
return &obj;
}
// ----------------------------------------------------------------------------------------
// queue_t
@ -237,8 +245,8 @@ ATTR_COLD void netlist_t::start()
|| setup().factory().is_class<devices::NETLIB_NAME(gnd)>(e.second)
|| setup().factory().is_class<devices::NETLIB_NAME(netlistparams)>(e.second))
{
auto dev = std::shared_ptr<device_t>(e.second->Create(*this, e.first));
setup().register_dev_s(dev);
auto dev = powned_ptr<device_t>(e.second->Create(*this, e.first));
setup().register_dev_s(std::move(dev));
}
}
@ -268,8 +276,8 @@ ATTR_COLD void netlist_t::start()
&& !setup().factory().is_class<devices::NETLIB_NAME(gnd)>(e.second)
&& !setup().factory().is_class<devices::NETLIB_NAME(netlistparams)>(e.second))
{
auto dev = std::shared_ptr<device_t>(e.second->Create(*this, e.first));
setup().register_dev_s(dev);
auto dev = powned_ptr<device_t>(e.second->Create(*this, e.first));
setup().register_dev_s(std::move(dev));
}
}
@ -426,7 +434,7 @@ ATTR_COLD core_device_t::core_device_t(netlist_t &owner, const pstring &name)
#endif
{
if (logic_family() == nullptr)
set_logic_family(family_TTL);
set_logic_family(family_TTL());
init_object(owner, name);
}
@ -440,7 +448,7 @@ ATTR_COLD core_device_t::core_device_t(core_device_t &owner, const pstring &name
{
set_logic_family(owner.logic_family());
if (logic_family() == nullptr)
set_logic_family(family_TTL);
set_logic_family(family_TTL());
init_object(owner.netlist(), owner.name() +"." + name);
}
@ -582,7 +590,7 @@ family_setter_t::family_setter_t(core_device_t &dev, const char *desc)
dev.set_logic_family(dev.netlist().setup().family_from_model(desc));
}
family_setter_t::family_setter_t(core_device_t &dev, logic_family_desc_t *desc)
family_setter_t::family_setter_t(core_device_t &dev, const logic_family_desc_t *desc)
{
dev.set_logic_family(desc);
}

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

@ -197,18 +197,18 @@ class NETLIB_NAME(_name) : public device_t
: device_t(owner, name)
#define NETLIB_DYNAMIC() \
ATTR_HOT virtual bool is_dynamic1() const override { return true; }
ATTR_HOT public: virtual bool is_dynamic1() const override { return true; }
#define NETLIB_TIMESTEP() \
ATTR_HOT virtual bool is_timestep() const override { return true; } \
ATTR_HOT void step_time(const nl_double step) override
ATTR_HOT public: virtual bool is_timestep() const override { return true; } \
ATTR_HOT public: void step_time(const nl_double step) override
#define NETLIB_FAMILY(_family) m_famsetter(*this, _family)
#define NETLIB_FAMILY(_family) , m_famsetter(*this, _family)
#define NETLIB_UPDATE_TERMINALSI() ATTR_HOT virtual void update_terminals(void) override
#define NETLIB_UPDATEI() ATTR_HOT virtual void update(void) override
#define NETLIB_UPDATE_PARAMI() ATTR_HOT virtual void update_param(void) override
#define NETLIB_RESETI() ATTR_COLD virtual void reset(void) override
#define NETLIB_UPDATE_TERMINALSI() public: ATTR_HOT virtual void update_terminals(void) override
#define NETLIB_UPDATEI() protected: ATTR_HOT virtual void update(void) override
#define NETLIB_UPDATE_PARAMI() public: ATTR_HOT virtual void update_param(void) override
#define NETLIB_RESETI() protected: ATTR_COLD virtual void reset(void) override
#define NETLIB_SUB(_chip) nld_ ## _chip
@ -354,7 +354,7 @@ namespace netlist
public:
logic_family_desc_t() : m_is_static(false) {}
virtual ~logic_family_desc_t() {}
virtual std::shared_ptr<devices::nld_base_d_to_a_proxy> create_d_a_proxy(netlist_t &anetlist, const pstring &name,
virtual powned_ptr<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;
@ -374,11 +374,11 @@ namespace netlist
logic_family_t() : m_logic_family(nullptr) {}
~logic_family_t() { }
ATTR_HOT logic_family_desc_t *logic_family() const { return m_logic_family; }
ATTR_COLD void set_logic_family(logic_family_desc_t *fam) { m_logic_family = fam; }
ATTR_HOT const logic_family_desc_t *logic_family() const { return m_logic_family; }
ATTR_COLD void set_logic_family(const logic_family_desc_t *fam) { m_logic_family = fam; }
protected:
logic_family_desc_t *m_logic_family;
const logic_family_desc_t *m_logic_family;
};
/* Terminals inherit the family description from the device
@ -389,8 +389,8 @@ namespace netlist
*/
extern logic_family_desc_t *family_TTL;
extern logic_family_desc_t *family_CD4XXX;
const logic_family_desc_t *family_TTL();
const logic_family_desc_t *family_CD4XXX();
// -----------------------------------------------------------------------------
@ -1048,16 +1048,21 @@ namespace netlist
{
begin_timing(stat_total_time);
inc_stat(stat_update_count);
#if (NL_PMF_TYPE == NL_PMF_TYPE_GNUC_PMF)
(this->*m_static_update)();
#elif ((NL_PMF_TYPE == NL_PMF_TYPE_GNUC_PMF_CONV) || (NL_PMF_TYPE == NL_PMF_TYPE_INTERNAL))
m_static_update(this);
#else
update();
#endif
do_update();
end_timing(stat_total_time);
}
ATTR_HOT void do_update()
{
#if (NL_PMF_TYPE == NL_PMF_TYPE_GNUC_PMF)
(this->*m_static_update)();
#elif ((NL_PMF_TYPE == NL_PMF_TYPE_GNUC_PMF_CONV) || (NL_PMF_TYPE == NL_PMF_TYPE_INTERNAL))
m_static_update(this);
#else
update();
#endif
}
ATTR_COLD void start_dev();
ATTR_COLD void stop_dev();
@ -1187,7 +1192,7 @@ namespace netlist
{
family_setter_t() { }
family_setter_t(core_device_t &dev, const char *desc);
family_setter_t(core_device_t &dev, logic_family_desc_t *desc);
family_setter_t(core_device_t &dev, const logic_family_desc_t *desc);
};
// -----------------------------------------------------------------------------
@ -1310,7 +1315,7 @@ namespace netlist
void print_stats() const;
pvector_t<std::shared_ptr<device_t>> m_devices;
pvector_t<powned_ptr<device_t>> m_devices;
net_t::list_t m_nets;
protected:

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

@ -41,11 +41,6 @@ factory_list_t::factory_list_t( setup_t &setup)
factory_list_t::~factory_list_t()
{
for (std::size_t i=0; i < size(); i++)
{
base_factory_t *p = value_at(i);
pfree(p);
}
clear();
}
@ -71,21 +66,20 @@ void factory_list_t::error(const pstring &s)
m_setup.log().fatal("{1}", s);
}
std::shared_ptr<device_t> factory_list_t::new_device_by_name(const pstring &devname, netlist_t &anetlist, const pstring &name)
powned_ptr<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(devname);
return std::shared_ptr<device_t>(f->Create(anetlist, name));
return f->Create(anetlist, name);
}
base_factory_t * factory_list_t::factory_by_name(const pstring &devname)
{
if (contains(devname))
return (*this)[devname];
else
{
m_setup.log().fatal("Class {1} not found!\n", devname);
return nullptr; // appease code analysis
}
for (auto & e : *this)
if (e->name() == devname)
return e.get();
m_setup.log().fatal("Class {1} not found!\n", devname);
return nullptr; // appease code analysis
}
}

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

@ -12,7 +12,6 @@
#include <type_traits>
#include "nl_config.h"
#include "plib/palloc.h"
#include "plib/plists.h"
#include "nl_base.h"
@ -33,7 +32,7 @@ namespace netlist
virtual ~base_factory_t() {}
virtual device_t *Create(netlist_t &anetlist, const pstring &name) = 0;
virtual powned_ptr<device_t> Create(netlist_t &anetlist, const pstring &name) = 0;
const pstring &name() const { return m_name; }
const pstring &classname() const { return m_classname; }
@ -56,15 +55,14 @@ namespace netlist
const pstring &def_param)
: base_factory_t(name, classname, def_param) { }
device_t *Create(netlist_t &anetlist, const pstring &name) override
powned_ptr<device_t> Create(netlist_t &anetlist, const pstring &name) override
{
device_t *r = palloc(_device_class(anetlist, name));
return r;
return powned_ptr<device_t>::Create<_device_class>(anetlist, name);
}
};
class factory_list_t : public phashmap_t<pstring, base_factory_t *>
class factory_list_t : public pvector_t<powned_ptr<base_factory_t>>
{
public:
factory_list_t(setup_t &m_setup);
@ -74,19 +72,20 @@ namespace netlist
void register_device(const pstring &name, const pstring &classname,
const pstring &def_param)
{
if (!add(name, palloc(factory_t< _device_class >(name, classname, def_param))))
error("factory already contains " + name);
register_device(powned_ptr<base_factory_t>::Create<factory_t<_device_class>>(name, classname, def_param));
}
void register_device(base_factory_t *factory)
void register_device(powned_ptr<base_factory_t> factory)
{
if (!add(factory->name(), factory))
error("factory already contains " + factory->name());
for (auto & e : *this)
if (e->name() == factory->name())
error("factory already contains " + factory->name());
push_back(std::move(factory));
}
//ATTR_COLD device_t *new_device_by_classname(const pstring &classname) const;
// FIXME: legacy, should use factory_by_name
std::shared_ptr<device_t> new_device_by_name(const pstring &devname, netlist_t &anetlist, const pstring &name);
powned_ptr<device_t> new_device_by_name(const pstring &devname, netlist_t &anetlist, const pstring &name);
base_factory_t * factory_by_name(const pstring &devname);
template <class _class>

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

@ -158,7 +158,7 @@ void parser_t::net_truthtable_start()
pstring def_param = get_string();
require_token(m_tok_param_right);
netlist::devices::netlist_base_factory_truthtable_t *ttd = netlist::devices::nl_tt_factory_create(ni, no, hs,
powned_ptr<netlist::devices::netlist_base_factory_truthtable_t> ttd = netlist::devices::nl_tt_factory_create(ni, no, hs,
name, name, "+" + def_param);
while (true)
@ -188,7 +188,7 @@ void parser_t::net_truthtable_start()
require_token(token, m_tok_TRUTHTABLE_END);
require_token(m_tok_param_left);
require_token(m_tok_param_right);
m_setup.factory().register_device(ttd);
m_setup.factory().register_device(std::move(ttd));
return;
}
}

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

@ -71,7 +71,7 @@ setup_t::~setup_t()
m_param_values.clear();
netlist().set_setup(nullptr);
m_sources.clear_and_free();
m_sources.clear();
pstring::resetmem();
}
@ -100,13 +100,13 @@ void setup_t::namespace_pop()
}
void setup_t::register_dev(std::shared_ptr<device_t> dev)
void setup_t::register_dev(powned_ptr<device_t> dev)
{
for (auto & d : netlist().m_devices)
if (d->name() == dev->name())
log().fatal("Error adding {1} to device list. Duplicate name \n", d->name());
netlist().m_devices.push_back(dev);
netlist().m_devices.push_back(std::move(dev));
}
void setup_t::register_lib_entry(const pstring &name)
@ -501,7 +501,7 @@ devices::nld_base_proxy *setup_t::get_d_a_proxy(core_terminal_t &out)
out_cast.logic_family()->create_d_a_proxy(netlist(), x, &out_cast);
m_proxy_cnt++;
register_dev_s(new_proxy);
proxy = new_proxy.get();
new_proxy->start_dev();
/* connect all existing terminals to new net */
@ -516,7 +516,9 @@ devices::nld_base_proxy *setup_t::get_d_a_proxy(core_terminal_t &out)
out.net().register_con(new_proxy->in());
out_cast.set_proxy(new_proxy.get());
proxy = new_proxy.get();
register_dev_s(std::move(new_proxy));
}
return proxy;
}
@ -527,16 +529,17 @@ void setup_t::connect_input_output(core_terminal_t &in, core_terminal_t &out)
{
logic_input_t &incast = dynamic_cast<logic_input_t &>(in);
pstring x = pfmt("proxy_ad_{1}_{2}")(in.name())( m_proxy_cnt);
auto proxy = std::make_shared<devices::nld_a_to_d_proxy>(netlist(), x, &incast);
auto proxy = powned_ptr<devices::nld_a_to_d_proxy>::Create(netlist(), x, &incast);
incast.set_proxy(proxy.get());
m_proxy_cnt++;
register_dev_s(proxy);
proxy->start_dev();
proxy->m_Q.net().register_con(in);
out.net().register_con(proxy->m_I);
register_dev_s(std::move(proxy));
}
else if (out.is_logic() && in.is_analog())
{
@ -566,13 +569,11 @@ 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");
pstring x = pfmt("proxy_ad_{1}_{2}")(inp.name())(m_proxy_cnt);
auto proxy = std::make_shared<devices::nld_a_to_d_proxy>(netlist(), x, &incast);
auto proxy = powned_ptr<devices::nld_a_to_d_proxy>::Create(netlist(), x, &incast);
incast.set_proxy(proxy.get());
m_proxy_cnt++;
register_dev_s(proxy);
proxy->start_dev();
connect_terminals(term, proxy->m_I);
if (inp.has_net())
@ -580,6 +581,8 @@ void setup_t::connect_terminal_input(terminal_t &term, core_terminal_t &inp)
proxy->m_Q.net().merge_net(&inp.net());
else
proxy->m_Q.net().register_con(inp);
register_dev_s(std::move(proxy));
}
else
{
@ -848,9 +851,9 @@ void setup_t::start_devices()
{
pstring name = "log_" + ll;
auto nc = factory().new_device_by_name("LOG", netlist(), name);
register_dev_s(nc);
register_link(name + ".I", ll);
log().debug(" dynamic link {1}: <{2}>\n",ll, name);
register_dev_s(std::move(nc));
}
}
@ -866,22 +869,22 @@ class logic_family_std_proxy_t : public logic_family_desc_t
{
public:
logic_family_std_proxy_t() { }
virtual std::shared_ptr<devices::nld_base_d_to_a_proxy> create_d_a_proxy(netlist_t &anetlist,
virtual powned_ptr<devices::nld_base_d_to_a_proxy> create_d_a_proxy(netlist_t &anetlist,
const pstring &name, logic_output_t *proxied) const override
{
return std::make_shared<devices::nld_d_to_a_proxy>(anetlist, name, proxied);
return powned_ptr<devices::nld_base_d_to_a_proxy>::Create<devices::nld_d_to_a_proxy>(anetlist, name, proxied);
}
};
logic_family_desc_t *setup_t::family_from_model(const pstring &model)
const logic_family_desc_t *setup_t::family_from_model(const pstring &model)
{
model_map_t map;
model_parse(model, map);
if (setup_t::model_value_str(map, "TYPE") == "TTL")
return family_TTL;
return family_TTL();
if (setup_t::model_value_str(map, "TYPE") == "CD4XXX")
return family_CD4XXX;
return family_CD4XXX();
logic_family_std_proxy_t *ret = palloc(logic_family_std_proxy_t);
@ -993,7 +996,7 @@ nl_double setup_t::model_value(model_map_t &map, const pstring &entity)
void setup_t::include(const pstring &netlist_name)
{
for (source_t *source : m_sources)
for (auto source : m_sources)
{
if (source->parse(*this, netlist_name))
return;

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

@ -54,7 +54,7 @@ ATTR_COLD void NETLIST_NAME(_name)(netlist::setup_t &setup) \
#define NETLIST_END() }
#define LOCAL_SOURCE(_name) \
setup.register_source(palloc(netlist::source_proc_t(# _name, &NETLIST_NAME(_name))));
setup.register_source(std::make_shared<netlist::source_proc_t>(# _name, &NETLIST_NAME(_name)));
#define LOCAL_LIB_ENTRY(_name) \
LOCAL_SOURCE(_name) \
@ -90,7 +90,7 @@ namespace netlist
class source_t
{
public:
using list_t = pvector_t<source_t *>;
using list_t = pvector_t<std::shared_ptr<source_t>>;
source_t()
{}
@ -113,14 +113,14 @@ namespace netlist
void register_object(device_t &dev, const pstring &name, object_t &obj);
template<class C>
void register_dev_s(std::shared_ptr<C> dev)
template<class _X>
void register_dev_s(powned_ptr<_X> dev)
{
register_dev(std::static_pointer_cast<device_t>(dev));
register_dev(std::move(dev));
}
void register_dev(std::shared_ptr<device_t> dev);
void register_dev(powned_ptr<device_t> dev);
void register_dev(const pstring &classname, const pstring &name);
void register_lib_entry(const pstring &name);
@ -162,7 +162,11 @@ namespace netlist
/* register a source */
void register_source(source_t *src) { m_sources.push_back(src); }
template <class C>
void register_source(std::shared_ptr<C> src)
{
m_sources.push_back(std::static_pointer_cast<source_t>(src));
}
factory_list_t &factory() { return m_factory; }
const factory_list_t &factory() const { return m_factory; }
@ -171,7 +175,7 @@ namespace netlist
/* model / family related */
logic_family_desc_t *family_from_model(const pstring &model);
const logic_family_desc_t *family_from_model(const pstring &model);
const pstring model_value_str(model_map_t &map, const pstring &entity);
nl_double model_value(model_map_t &map, const pstring &entity);

77
src/lib/netlist/nl_util.h
View File

@ -123,4 +123,81 @@ public:
};
template <typename _SC>
class powned_ptr
{
private:
powned_ptr()
: m_ptr(nullptr), m_is_owned(true) { }
public:
powned_ptr(_SC *p, bool owned)
: m_ptr(p), m_is_owned(owned)
{ }
powned_ptr(const powned_ptr &r) = delete;
powned_ptr & operator =(const powned_ptr &r) = delete;
powned_ptr(powned_ptr &&r)
{
m_is_owned = r.m_is_owned;
m_ptr = r.m_ptr;
r.m_is_owned = false;
r.m_ptr = nullptr;
}
template<typename _DC>
powned_ptr(powned_ptr<_DC> &&r)
{
_SC *dest_ptr = &dynamic_cast<_SC &>(*r.get());
bool o = r.is_owned();
r.release();
m_is_owned = o;
m_ptr = dest_ptr;
}
~powned_ptr()
{
if (m_is_owned)
delete m_ptr;
}
template<typename _DC, typename... _Args>
static powned_ptr Create(_Args&&... __args)
{
powned_ptr a;
_DC *x = new _DC(std::forward<_Args>(__args)...);
a.m_ptr = static_cast<_SC *>(x);
return a;
}
template<typename... _Args>
static powned_ptr Create(_Args&&... __args)
{
powned_ptr a;
a.m_ptr = new _SC(std::forward<_Args>(__args)...);
return a;
}
void release()
{
m_is_owned = false;
m_ptr = nullptr;
}
bool is_owned() const { return m_is_owned; }
powned_ptr & operator =(powned_ptr &r)
{
m_is_owned = r.m_is_owned;
m_ptr = r.m_ptr;
r.m_is_owned = false;
r.m_ptr = nullptr;
return *this;
}
_SC * operator ->() { return m_ptr; }
_SC & operator *() { return *m_ptr; }
_SC * get() const { return m_ptr; }
private:
_SC *m_ptr;
bool m_is_owned;
};
#endif /* NL_UTIL_H_ */

3
src/lib/netlist/plib/pdynlib.cpp
View File

@ -34,7 +34,7 @@ pdynlib::pdynlib(const pstring libname)
if (m_lib != nullptr)
m_isLoaded = true;
//else
// printf("library <%s> not found!\n", libname.cstr());
// printf("library <%s> not found: %s\n", libname.cstr(), dlerror());
#endif
}
@ -75,6 +75,7 @@ pdynlib::~pdynlib()
#ifdef _WIN32
#else
dlclose(m_lib);
//printf("Closed %s\n", dlerror());
#endif
}
}

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

@ -110,7 +110,7 @@ public:
{
// read the netlist ...
m_setup->register_source(palloc(netlist::source_file_t(filename)));
m_setup->register_source(std::make_shared<netlist::source_file_t>(filename));
m_setup->include(name);
log_setup();
@ -289,9 +289,9 @@ static void listdevices()
{
netlist_tool_t nt("netlist");
nt.init();
const netlist::factory_list_t &list = nt.setup().factory();
netlist::factory_list_t &list = nt.setup().factory();
nt.setup().register_source(palloc(netlist::source_proc_t("dummy", &netlist_dummy)));
nt.setup().register_source(std::make_shared<netlist::source_proc_t>("dummy", &netlist_dummy));
nt.setup().include("dummy");
nt.setup().start_devices();
@ -299,11 +299,11 @@ static void listdevices()
for (unsigned i=0; i < list.size(); i++)
{
netlist::base_factory_t *f = list.value_at(i);
auto &f = list[i];
pstring out = pfmt("{1} {2}(<id>")(f->classname(),"-20")(f->name());
pstring terms("");
netlist::device_t *d = f->Create(nt.setup().netlist(), pfmt("dummy{1}")(i));
auto d = f->Create(nt.setup().netlist(), pfmt("dummy{1}")(i));
d->start_dev();
// get the list of terminals ...