Sprinter/mame
2
0
Fork 0
mirror of https://github.com/holub/mame synced 2025-10-07 01:16:22 +03:00
Code Issues Actions 3 Packages Projects Releases Wiki Activity

Rename netlist::netlist_<somename> to just netlist::<somename>. (nw)

Browse Source
This commit is contained in:
couriersud 2015-06-13 01:18:45 +02:00
parent f59da94e11
commit 6e9a796ffc
58 changed files with 792 additions and 792 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

8
src/emu/machine/netlist.c
View File

@ -467,14 +467,14 @@ void netlist_mame_cpu_device_t::device_start()
for (int i=0; i < netlist().m_nets.size(); i++) for (int i=0; i < netlist().m_nets.size(); i++)
{ {
netlist::netlist_net_t *n = netlist().m_nets[i]; netlist::net_t *n = netlist().m_nets[i];
if (n->isFamily(netlist::netlist_object_t::LOGIC)) if (n->isFamily(netlist::object_t::LOGIC))
{ {
state_add(i*2, n->name(), downcast<netlist::netlist_logic_net_t *>(n)->Q_state_ptr()); state_add(i*2, n->name(), downcast<netlist::logic_net_t *>(n)->Q_state_ptr());
} }
else else
{ {
state_add(i*2+1, n->name(), downcast<netlist::netlist_analog_net_t *>(n)->Q_Analog_state_ptr()).formatstr("%20s"); state_add(i*2+1, n->name(), downcast<netlist::analog_net_t *>(n)->Q_Analog_state_ptr()).formatstr("%20s");
} }
} }

24
src/emu/machine/netlist.h
View File

@ -81,12 +81,12 @@ private:
class netlist_mame_device_t; class netlist_mame_device_t;
class netlist_mame_t : public netlist::netlist_base_t class netlist_mame_t : public netlist::netlist_t
{ {
public: public:
netlist_mame_t(netlist_mame_device_t &parent) netlist_mame_t(netlist_mame_device_t &parent)
: netlist::netlist_base_t(), : netlist::netlist_t(),
m_parent(parent) m_parent(parent)
{} {}
virtual ~netlist_mame_t() { }; virtual ~netlist_mame_t() { };
@ -506,11 +506,11 @@ private:
// netdev_callback // netdev_callback
// ---------------------------------------------------------------------------------------- // ----------------------------------------------------------------------------------------
class NETLIB_NAME(analog_callback) : public netlist::netlist_device_t class NETLIB_NAME(analog_callback) : public netlist::device_t
{ {
public: public:
NETLIB_NAME(analog_callback)() NETLIB_NAME(analog_callback)()
: netlist_device_t(), m_cpu_device(NULL), m_last(0) { } : device_t(), m_cpu_device(NULL), m_last(0) { }
ATTR_COLD void start() ATTR_COLD void start()
{ {
@ -545,7 +545,7 @@ public:
} }
private: private:
netlist::netlist_analog_input_t m_in; netlist::analog_input_t m_in;
netlist_analog_output_delegate m_callback; netlist_analog_output_delegate m_callback;
netlist_mame_cpu_device_t *m_cpu_device; netlist_mame_cpu_device_t *m_cpu_device;
nl_double m_last; nl_double m_last;
@ -555,11 +555,11 @@ private:
// sound_out // sound_out
// ---------------------------------------------------------------------------------------- // ----------------------------------------------------------------------------------------
class NETLIB_NAME(sound_out) : public netlist::netlist_device_t class NETLIB_NAME(sound_out) : public netlist::device_t
{ {
public: public:
NETLIB_NAME(sound_out)() NETLIB_NAME(sound_out)()
: netlist::netlist_device_t() { } : netlist::device_t() { }
static const int BUFSIZE = 2048; static const int BUFSIZE = 2048;
@ -611,7 +611,7 @@ public:
netlist_time m_sample; netlist_time m_sample;
private: private:
netlist::netlist_analog_input_t m_in; netlist::analog_input_t m_in;
stream_sample_t m_cur; stream_sample_t m_cur;
int m_last_pos; int m_last_pos;
netlist_time m_last_buffer; netlist_time m_last_buffer;
@ -621,11 +621,11 @@ private:
// sound_in // sound_in
// ---------------------------------------------------------------------------------------- // ----------------------------------------------------------------------------------------
class NETLIB_NAME(sound_in) : public netlist::netlist_device_t class NETLIB_NAME(sound_in) : public netlist::device_t
{ {
public: public:
NETLIB_NAME(sound_in)() NETLIB_NAME(sound_in)()
: netlist::netlist_device_t() { } : netlist::device_t() { }
static const int MAX_INPUT_CHANNELS = 10; static const int MAX_INPUT_CHANNELS = 10;
@ -697,8 +697,8 @@ public:
netlist_time m_inc; netlist_time m_inc;
private: private:
netlist::netlist_logic_input_t m_feedback; netlist::logic_input_t m_feedback;
netlist::netlist_logic_output_t m_Q; netlist::logic_output_t m_Q;
int m_pos; int m_pos;
int m_num_channel; int m_num_channel;

2
src/emu/netlist/analog/nld_bjt.c
View File

@ -45,7 +45,7 @@ private:
// ---------------------------------------------------------------------------------------- // ----------------------------------------------------------------------------------------
NETLIB_NAME(Q)::NETLIB_NAME(Q)(const family_t afamily) NETLIB_NAME(Q)::NETLIB_NAME(Q)(const family_t afamily)
: netlist_device_t(afamily) : device_t(afamily)
, m_qtype(BJT_NPN) { } , m_qtype(BJT_NPN) { }
NETLIB_NAME(Q)::~NETLIB_NAME(Q)() NETLIB_NAME(Q)::~NETLIB_NAME(Q)()

14
src/emu/netlist/analog/nld_bjt.h
View File

@ -32,7 +32,7 @@ NETLIB_NAMESPACE_DEVICES_START()
// Have a common start for transistors // Have a common start for transistors
class NETLIB_NAME(Q) : public netlist_device_t class NETLIB_NAME(Q) : public device_t
{ {
public: public:
enum q_type { enum q_type {
@ -96,9 +96,9 @@ class NETLIB_NAME(QBJT_switch) : public NETLIB_NAME(QBJT)
public: public:
ATTR_COLD NETLIB_NAME(QBJT_switch)() ATTR_COLD NETLIB_NAME(QBJT_switch)()
: NETLIB_NAME(QBJT)(BJT_SWITCH), : NETLIB_NAME(QBJT)(BJT_SWITCH),
m_RB(netlist_object_t::ANALOG), m_RB(object_t::ANALOG),
m_RC(netlist_object_t::ANALOG), m_RC(object_t::ANALOG),
m_BC_dummy(netlist_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) { } m_gB(NETLIST_GMIN_DEFAULT), m_gC(NETLIST_GMIN_DEFAULT), m_V(0.0), m_state_on(0) { }
@ -136,9 +136,9 @@ class NETLIB_NAME(QBJT_EB) : public NETLIB_NAME(QBJT)
public: public:
ATTR_COLD NETLIB_NAME(QBJT_EB)() ATTR_COLD NETLIB_NAME(QBJT_EB)()
: NETLIB_NAME(QBJT)(BJT_EB), : NETLIB_NAME(QBJT)(BJT_EB),
m_D_CB(netlist_object_t::ANALOG), m_D_CB(object_t::ANALOG),
m_D_EB(netlist_object_t::ANALOG), m_D_EB(object_t::ANALOG),
m_D_EC(netlist_object_t::ANALOG), m_D_EC(object_t::ANALOG),
m_alpha_f(0), m_alpha_f(0),
m_alpha_r(0) m_alpha_r(0)
{ } { }

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

@ -49,13 +49,13 @@ NETLIB_NAMESPACE_DEVICES_START()
* *
*/ */
class NETLIB_NAME(VCCS) : public netlist_device_t class NETLIB_NAME(VCCS) : public device_t
{ {
public: public:
ATTR_COLD NETLIB_NAME(VCCS)() ATTR_COLD NETLIB_NAME(VCCS)()
: netlist_device_t(VCCS), m_gfac(1.0) { } : device_t(VCCS), m_gfac(1.0) { }
ATTR_COLD NETLIB_NAME(VCCS)(const family_t afamily) ATTR_COLD NETLIB_NAME(VCCS)(const family_t afamily)
: netlist_device_t(afamily), m_gfac(1.0) { } : device_t(afamily), m_gfac(1.0) { }
protected: protected:
virtual void start(); virtual void start();
@ -65,14 +65,14 @@ protected:
ATTR_COLD void start_internal(const nl_double def_RI); ATTR_COLD void start_internal(const nl_double def_RI);
netlist_terminal_t m_OP; terminal_t m_OP;
netlist_terminal_t m_ON; terminal_t m_ON;
netlist_terminal_t m_IP; terminal_t m_IP;
netlist_terminal_t m_IN; terminal_t m_IN;
netlist_terminal_t m_OP1; terminal_t m_OP1;
netlist_terminal_t m_ON1; terminal_t m_ON1;
netlist_param_double_t m_G; netlist_param_double_t m_G;
netlist_param_double_t m_RI; netlist_param_double_t m_RI;
@ -163,8 +163,8 @@ protected:
virtual void update_param(); virtual void update_param();
//ATTR_HOT void update(); //ATTR_HOT void update();
netlist_terminal_t m_OP2; terminal_t m_OP2;
netlist_terminal_t m_ON2; terminal_t m_ON2;
netlist_param_double_t m_RO; netlist_param_double_t m_RO;
}; };

10
src/emu/netlist/analog/nld_ms_direct.h
View File

@ -24,7 +24,7 @@ public:
virtual ~netlist_matrix_solver_direct_t(); virtual ~netlist_matrix_solver_direct_t();
virtual void vsetup(netlist_analog_net_t::list_t &nets); virtual void vsetup(analog_net_t::list_t &nets);
virtual void reset() { netlist_matrix_solver_t::reset(); } virtual void reset() { netlist_matrix_solver_t::reset(); }
ATTR_HOT inline unsigned N() const { if (m_N == 0) return m_dim; else return m_N; } ATTR_HOT inline unsigned N() const { if (m_N == 0) return m_dim; else return m_N; }
@ -32,7 +32,7 @@ public:
ATTR_HOT inline int vsolve_non_dynamic(const bool newton_raphson); ATTR_HOT inline int vsolve_non_dynamic(const bool newton_raphson);
protected: protected:
virtual void add_term(int net_idx, netlist_terminal_t *term); virtual void add_term(int net_idx, terminal_t *term);
ATTR_HOT virtual nl_double vsolve(); ATTR_HOT virtual nl_double vsolve();
@ -92,7 +92,7 @@ ATTR_HOT nl_double netlist_matrix_solver_direct_t<m_N, _storage_N>::compute_next
*/ */
for (unsigned k = 0, iN=N(); k < iN; k++) for (unsigned k = 0, iN=N(); k < iN; k++)
{ {
netlist_analog_net_t *n = m_nets[k]; analog_net_t *n = m_nets[k];
const nl_double DD_n = (n->m_cur_Analog - m_last_V[k]); const nl_double DD_n = (n->m_cur_Analog - m_last_V[k]);
const nl_double hn = current_timestep(); const nl_double hn = current_timestep();
@ -119,7 +119,7 @@ ATTR_HOT nl_double netlist_matrix_solver_direct_t<m_N, _storage_N>::compute_next
} }
template <unsigned m_N, unsigned _storage_N> template <unsigned m_N, unsigned _storage_N>
ATTR_COLD void netlist_matrix_solver_direct_t<m_N, _storage_N>::add_term(int k, netlist_terminal_t *term) ATTR_COLD void netlist_matrix_solver_direct_t<m_N, _storage_N>::add_term(int k, terminal_t *term)
{ {
if (term->m_otherterm->net().isRailNet()) if (term->m_otherterm->net().isRailNet())
{ {
@ -144,7 +144,7 @@ ATTR_COLD void netlist_matrix_solver_direct_t<m_N, _storage_N>::add_term(int k,
template <unsigned m_N, unsigned _storage_N> template <unsigned m_N, unsigned _storage_N>
ATTR_COLD void netlist_matrix_solver_direct_t<m_N, _storage_N>::vsetup(netlist_analog_net_t::list_t &nets) ATTR_COLD void netlist_matrix_solver_direct_t<m_N, _storage_N>::vsetup(analog_net_t::list_t &nets)
{ {
if (m_dim < nets.size()) if (m_dim < nets.size())
netlist().error("Dimension %d less than %" SIZETFMT, m_dim, nets.size()); netlist().error("Dimension %d less than %" SIZETFMT, m_dim, nets.size());

2
src/emu/netlist/analog/nld_ms_direct1.h
View File

@ -38,7 +38,7 @@ ATTR_HOT nl_double netlist_matrix_solver_direct1_t::vsolve()
ATTR_HOT inline int netlist_matrix_solver_direct1_t::vsolve_non_dynamic(ATTR_UNUSED const bool newton_raphson) ATTR_HOT inline int netlist_matrix_solver_direct1_t::vsolve_non_dynamic(ATTR_UNUSED const bool newton_raphson)
{ {
netlist_analog_net_t *net = m_nets[0]; analog_net_t *net = m_nets[0];
this->build_LE_A(); this->build_LE_A();
this->build_LE_RHS(m_RHS); this->build_LE_RHS(m_RHS);
//NL_VERBOSE_OUT(("%f %f\n", new_val, m_RHS[0] / m_A[0][0]); //NL_VERBOSE_OUT(("%f %f\n", new_val, m_RHS[0] / m_A[0][0]);

4
src/emu/netlist/analog/nld_ms_gmres.h
View File

@ -38,7 +38,7 @@ public:
virtual void log_stats(); virtual void log_stats();
virtual void vsetup(netlist_analog_net_t::list_t &nets); virtual void vsetup(analog_net_t::list_t &nets);
ATTR_HOT virtual int vsolve_non_dynamic(const bool newton_raphson); ATTR_HOT virtual int vsolve_non_dynamic(const bool newton_raphson);
protected: protected:
ATTR_HOT virtual nl_double vsolve(); ATTR_HOT virtual nl_double vsolve();
@ -74,7 +74,7 @@ void netlist_matrix_solver_GMRES_t<m_N, _storage_N>::log_stats()
} }
template <unsigned m_N, unsigned _storage_N> template <unsigned m_N, unsigned _storage_N>
void netlist_matrix_solver_GMRES_t<m_N, _storage_N>::vsetup(netlist_analog_net_t::list_t &nets) void netlist_matrix_solver_GMRES_t<m_N, _storage_N>::vsetup(analog_net_t::list_t &nets)
{ {
netlist_matrix_solver_direct_t<m_N, _storage_N>::vsetup(nets); netlist_matrix_solver_direct_t<m_N, _storage_N>::vsetup(nets);
this->save(NLNAME(m_gs_fail)); this->save(NLNAME(m_gs_fail));

4
src/emu/netlist/analog/nld_ms_sor.h
View File

@ -36,7 +36,7 @@ public:
virtual void log_stats(); virtual void log_stats();
virtual void vsetup(netlist_analog_net_t::list_t &nets); virtual void vsetup(analog_net_t::list_t &nets);
ATTR_HOT virtual int vsolve_non_dynamic(const bool newton_raphson); ATTR_HOT virtual int vsolve_non_dynamic(const bool newton_raphson);
protected: protected:
ATTR_HOT virtual nl_double vsolve(); ATTR_HOT virtual nl_double vsolve();
@ -72,7 +72,7 @@ void netlist_matrix_solver_SOR_t<m_N, _storage_N>::log_stats()
} }
template <unsigned m_N, unsigned _storage_N> template <unsigned m_N, unsigned _storage_N>
void netlist_matrix_solver_SOR_t<m_N, _storage_N>::vsetup(netlist_analog_net_t::list_t &nets) void netlist_matrix_solver_SOR_t<m_N, _storage_N>::vsetup(analog_net_t::list_t &nets)
{ {
netlist_matrix_solver_direct_t<m_N, _storage_N>::vsetup(nets); netlist_matrix_solver_direct_t<m_N, _storage_N>::vsetup(nets);
this->save(NLNAME(m_lp_fact)); this->save(NLNAME(m_lp_fact));

6
src/emu/netlist/analog/nld_ms_sor_mat.h
View File

@ -36,7 +36,7 @@ public:
virtual ~netlist_matrix_solver_SOR_mat_t() {} virtual ~netlist_matrix_solver_SOR_mat_t() {}
virtual void log_stats(); virtual void log_stats();
virtual void vsetup(netlist_analog_net_t::list_t &nets); virtual void vsetup(analog_net_t::list_t &nets);
ATTR_HOT inline int vsolve_non_dynamic(const bool newton_raphson); ATTR_HOT inline int vsolve_non_dynamic(const bool newton_raphson);
protected: protected:
@ -76,7 +76,7 @@ void netlist_matrix_solver_SOR_mat_t<m_N, _storage_N>::log_stats()
} }
template <unsigned m_N, unsigned _storage_N> template <unsigned m_N, unsigned _storage_N>
void netlist_matrix_solver_SOR_mat_t<m_N, _storage_N>::vsetup(netlist_analog_net_t::list_t &nets) void netlist_matrix_solver_SOR_mat_t<m_N, _storage_N>::vsetup(analog_net_t::list_t &nets)
{ {
netlist_matrix_solver_direct_t<m_N, _storage_N>::vsetup(nets); netlist_matrix_solver_direct_t<m_N, _storage_N>::vsetup(nets);
this->save(NLNAME(m_omega)); this->save(NLNAME(m_omega));
@ -115,7 +115,7 @@ ATTR_HOT nl_double netlist_matrix_solver_SOR_mat_t<m_N, _storage_N>::vsolve()
const nl_double rez_cts = 1.0 / this->current_timestep(); const nl_double rez_cts = 1.0 / this->current_timestep();
for (unsigned k = 0; k < this->N(); k++) for (unsigned k = 0; k < this->N(); k++)
{ {
const netlist_analog_net_t *n = this->m_nets[k]; const analog_net_t *n = this->m_nets[k];
const nl_double nv = (n->m_cur_Analog - this->m_last_V[k]) * rez_cts ; const nl_double nv = (n->m_cur_Analog - this->m_last_V[k]) * rez_cts ;
sq += nv * nv; sq += nv * nv;
sqo += this->m_Vdelta[k] * this->m_Vdelta[k]; sqo += this->m_Vdelta[k] * this->m_Vdelta[k];

32
src/emu/netlist/analog/nld_solver.c
View File

@ -42,7 +42,7 @@
NETLIB_NAMESPACE_DEVICES_START() NETLIB_NAMESPACE_DEVICES_START()
ATTR_COLD void terms_t::add(netlist_terminal_t *term, int net_other) ATTR_COLD void terms_t::add(terminal_t *term, int net_other)
{ {
m_term.add(term); m_term.add(term);
m_net_other.add(net_other); m_net_other.add(net_other);
@ -82,7 +82,7 @@ ATTR_COLD netlist_matrix_solver_t::~netlist_matrix_solver_t()
m_inps.clear_and_free(); m_inps.clear_and_free();
} }
ATTR_COLD void netlist_matrix_solver_t::setup(netlist_analog_net_t::list_t &nets) ATTR_COLD void netlist_matrix_solver_t::setup(analog_net_t::list_t &nets)
{ {
NL_VERBOSE_OUT(("New solver setup\n")); NL_VERBOSE_OUT(("New solver setup\n"));
@ -97,27 +97,27 @@ ATTR_COLD void netlist_matrix_solver_t::setup(netlist_analog_net_t::list_t &nets
{ {
NL_VERBOSE_OUT(("setting up net\n")); NL_VERBOSE_OUT(("setting up net\n"));
netlist_analog_net_t *net = nets[k]; analog_net_t *net = nets[k];
net->m_solver = this; net->m_solver = this;
for (std::size_t i = 0; i < net->m_core_terms.size(); i++) for (std::size_t i = 0; i < net->m_core_terms.size(); i++)
{ {
netlist_core_terminal_t *p = net->m_core_terms[i]; core_terminal_t *p = net->m_core_terms[i];
NL_VERBOSE_OUT(("%s %s %d\n", p->name().cstr(), net->name().cstr(), (int) net->isRailNet())); NL_VERBOSE_OUT(("%s %s %d\n", p->name().cstr(), net->name().cstr(), (int) net->isRailNet()));
switch (p->type()) switch (p->type())
{ {
case netlist_terminal_t::TERMINAL: case terminal_t::TERMINAL:
switch (p->netdev().family()) switch (p->netdev().family())
{ {
case netlist_device_t::CAPACITOR: case device_t::CAPACITOR:
if (!m_step_devices.contains(&p->netdev())) if (!m_step_devices.contains(&p->netdev()))
m_step_devices.add(&p->netdev()); m_step_devices.add(&p->netdev());
break; break;
case netlist_device_t::BJT_EB: case device_t::BJT_EB:
case netlist_device_t::DIODE: case device_t::DIODE:
//case netlist_device_t::VCVS: //case netlist_device_t::VCVS:
case netlist_device_t::BJT_SWITCH: case device_t::BJT_SWITCH:
NL_VERBOSE_OUT(("found BJT/Diode\n")); NL_VERBOSE_OUT(("found BJT/Diode\n"));
if (!m_dynamic_devices.contains(&p->netdev())) if (!m_dynamic_devices.contains(&p->netdev()))
m_dynamic_devices.add(&p->netdev()); m_dynamic_devices.add(&p->netdev());
@ -126,12 +126,12 @@ ATTR_COLD void netlist_matrix_solver_t::setup(netlist_analog_net_t::list_t &nets
break; break;
} }
{ {
netlist_terminal_t *pterm = dynamic_cast<netlist_terminal_t *>(p); terminal_t *pterm = dynamic_cast<terminal_t *>(p);
add_term(k, pterm); add_term(k, pterm);
} }
NL_VERBOSE_OUT(("Added terminal\n")); NL_VERBOSE_OUT(("Added terminal\n"));
break; break;
case netlist_terminal_t::INPUT: case terminal_t::INPUT:
{ {
netlist_analog_output_t *net_proxy_output = NULL; netlist_analog_output_t *net_proxy_output = NULL;
for (std::size_t i = 0; i < m_inps.size(); i++) for (std::size_t i = 0; i < m_inps.size(); i++)
@ -275,7 +275,7 @@ ATTR_HOT nl_double netlist_matrix_solver_t::solve()
// netlist_matrix_solver - Direct base // netlist_matrix_solver - Direct base
// ---------------------------------------------------------------------------------------- // ----------------------------------------------------------------------------------------
ATTR_COLD int netlist_matrix_solver_t::get_net_idx(netlist_net_t *net) ATTR_COLD int netlist_matrix_solver_t::get_net_idx(net_t *net)
{ {
for (std::size_t k = 0; k < m_nets.size(); k++) for (std::size_t k = 0; k < m_nets.size(); k++)
if (m_nets[k] == net) if (m_nets[k] == net)
@ -427,7 +427,7 @@ netlist_matrix_solver_t * NETLIB_NAME(solver)::create_solver(int size, const int
ATTR_COLD void NETLIB_NAME(solver)::post_start() ATTR_COLD void NETLIB_NAME(solver)::post_start()
{ {
netlist_analog_net_t::list_t groups[256]; analog_net_t::list_t groups[256];
int cur_group = -1; int cur_group = -1;
const int gs_threshold = m_gs_threshold.Value(); const int gs_threshold = m_gs_threshold.Value();
const bool use_specific = true; const bool use_specific = true;
@ -467,7 +467,7 @@ ATTR_COLD void NETLIB_NAME(solver)::post_start()
if (!netlist().m_nets[i]->isRailNet()) if (!netlist().m_nets[i]->isRailNet())
{ {
SOLVER_VERBOSE_OUT((" ==> not a rail net\n")); SOLVER_VERBOSE_OUT((" ==> not a rail net\n"));
netlist_analog_net_t *n = &netlist().m_nets[i]->as_analog(); analog_net_t *n = &netlist().m_nets[i]->as_analog();
if (!n->already_processed(groups, cur_group)) if (!n->already_processed(groups, cur_group))
{ {
cur_group++; cur_group++;
@ -554,10 +554,10 @@ ATTR_COLD void NETLIB_NAME(solver)::post_start()
for (std::size_t j=0; j<groups[i].size(); j++) for (std::size_t j=0; j<groups[i].size(); j++)
{ {
netlist().log("Net %" SIZETFMT ": %s", j, groups[i][j]->name().cstr()); netlist().log("Net %" SIZETFMT ": %s", j, groups[i][j]->name().cstr());
netlist_net_t *n = groups[i][j]; net_t *n = groups[i][j];
for (std::size_t k = 0; k < n->m_core_terms.size(); k++) for (std::size_t k = 0; k < n->m_core_terms.size(); k++)
{ {
const netlist_core_terminal_t *p = n->m_core_terms[k]; const core_terminal_t *p = n->m_core_terms[k];
netlist().log(" %s", p->name().cstr()); netlist().log(" %s", p->name().cstr());
} }
} }

32
src/emu/netlist/analog/nld_solver.h
View File

@ -68,11 +68,11 @@ class terms_t
m_other_curanalog.clear(); m_other_curanalog.clear();
} }
ATTR_COLD void add(netlist_terminal_t *term, int net_other); ATTR_COLD void add(terminal_t *term, int net_other);
ATTR_HOT inline unsigned count() { return m_term.size(); } ATTR_HOT inline unsigned count() { return m_term.size(); }
ATTR_HOT inline netlist_terminal_t **terms() { return m_term.data(); } ATTR_HOT inline terminal_t **terms() { return m_term.data(); }
ATTR_HOT inline int *net_other() { return m_net_other.data(); } ATTR_HOT inline int *net_other() { return m_net_other.data(); }
ATTR_HOT inline nl_double *gt() { return m_gt.data(); } ATTR_HOT inline nl_double *gt() { return m_gt.data(); }
ATTR_HOT inline nl_double *go() { return m_go.data(); } ATTR_HOT inline nl_double *go() { return m_go.data(); }
@ -86,7 +86,7 @@ class terms_t
plist_t<int> m_nzrd; /* non zero right of the diagonal for elimination */ plist_t<int> m_nzrd; /* non zero right of the diagonal for elimination */
plist_t<int> m_nz; /* all non zero for multiplication */ plist_t<int> m_nz; /* all non zero for multiplication */
private: private:
plist_t<netlist_terminal_t *> m_term; plist_t<terminal_t *> m_term;
plist_t<int> m_net_other; plist_t<int> m_net_other;
plist_t<nl_double> m_go; plist_t<nl_double> m_go;
plist_t<nl_double> m_gt; plist_t<nl_double> m_gt;
@ -94,11 +94,11 @@ private:
plist_t<nl_double *> m_other_curanalog; plist_t<nl_double *> m_other_curanalog;
}; };
class netlist_matrix_solver_t : public netlist_device_t class netlist_matrix_solver_t : public device_t
{ {
public: public:
typedef plist_t<netlist_matrix_solver_t *> list_t; typedef plist_t<netlist_matrix_solver_t *> list_t;
typedef netlist_core_device_t::list_t dev_list_t; typedef core_device_t::list_t dev_list_t;
enum eSolverType enum eSolverType
{ {
@ -109,7 +109,7 @@ public:
ATTR_COLD netlist_matrix_solver_t(const eSolverType type, const netlist_solver_parameters_t *params); ATTR_COLD netlist_matrix_solver_t(const eSolverType type, const netlist_solver_parameters_t *params);
virtual ~netlist_matrix_solver_t(); virtual ~netlist_matrix_solver_t();
virtual void vsetup(netlist_analog_net_t::list_t &nets) = 0; virtual void vsetup(analog_net_t::list_t &nets) = 0;
template<class C> template<class C>
void solve_base(C *p); void solve_base(C *p);
@ -130,22 +130,22 @@ public:
virtual void start(); virtual void start();
virtual void reset(); virtual void reset();
ATTR_COLD int get_net_idx(netlist_net_t *net); ATTR_COLD int get_net_idx(net_t *net);
virtual void log_stats() {}; virtual void log_stats() {};
inline eSolverType type() const { return m_type; } inline eSolverType type() const { return m_type; }
protected: protected:
ATTR_COLD void setup(netlist_analog_net_t::list_t &nets); ATTR_COLD void setup(analog_net_t::list_t &nets);
ATTR_HOT void update_dynamic(); ATTR_HOT void update_dynamic();
// should return next time step // should return next time step
ATTR_HOT virtual nl_double vsolve() = 0; ATTR_HOT virtual nl_double vsolve() = 0;
virtual void add_term(int net_idx, netlist_terminal_t *term) = 0; virtual void add_term(int net_idx, terminal_t *term) = 0;
plist_t<netlist_analog_net_t *> m_nets; plist_t<analog_net_t *> m_nets;
plist_t<netlist_analog_output_t *> m_inps; plist_t<netlist_analog_output_t *> m_inps;
int m_stat_calculations; int m_stat_calculations;
@ -162,8 +162,8 @@ private:
dev_list_t m_step_devices; dev_list_t m_step_devices;
dev_list_t m_dynamic_devices; dev_list_t m_dynamic_devices;
netlist_logic_input_t m_fb_sync; logic_input_t m_fb_sync;
netlist_logic_output_t m_Q_sync; logic_output_t m_Q_sync;
ATTR_HOT void step(const netlist_time delta); ATTR_HOT void step(const netlist_time delta);
@ -174,11 +174,11 @@ private:
class NETLIB_NAME(solver) : public netlist_device_t class NETLIB_NAME(solver) : public device_t
{ {
public: public:
NETLIB_NAME(solver)() NETLIB_NAME(solver)()
: netlist_device_t() { } : device_t() { }
virtual ~NETLIB_NAME(solver)(); virtual ~NETLIB_NAME(solver)();
@ -193,8 +193,8 @@ protected:
ATTR_HOT void reset(); ATTR_HOT void reset();
ATTR_HOT void update_param(); ATTR_HOT void update_param();
netlist_logic_input_t m_fb_step; logic_input_t m_fb_step;
netlist_logic_output_t m_Q_step; logic_output_t m_Q_step;
netlist_param_double_t m_freq; netlist_param_double_t m_freq;
netlist_param_double_t m_sync_delay; netlist_param_double_t m_sync_delay;

6
src/emu/netlist/analog/nld_twoterm.c
View File

@ -35,7 +35,7 @@ ATTR_COLD void netlist_generic_diode::set_param(const nl_double Is, const nl_dou
m_VtInv = 1.0 / m_Vt; m_VtInv = 1.0 / m_Vt;
} }
ATTR_COLD void netlist_generic_diode::save(pstring name, netlist_object_t &parent) ATTR_COLD void netlist_generic_diode::save(pstring name, object_t &parent)
{ {
parent.save(m_Vd, name + ".m_Vd"); parent.save(m_Vd, name + ".m_Vd");
parent.save(m_Id, name + ".m_Id"); parent.save(m_Id, name + ".m_Id");
@ -47,14 +47,14 @@ ATTR_COLD void netlist_generic_diode::save(pstring name, netlist_object_t &paren
// ---------------------------------------------------------------------------------------- // ----------------------------------------------------------------------------------------
ATTR_COLD NETLIB_NAME(twoterm)::NETLIB_NAME(twoterm)(const family_t afamily) ATTR_COLD NETLIB_NAME(twoterm)::NETLIB_NAME(twoterm)(const family_t afamily)
: netlist_device_t(afamily) : device_t(afamily)
{ {
m_P.m_otherterm = &m_N; m_P.m_otherterm = &m_N;
m_N.m_otherterm = &m_P; m_N.m_otherterm = &m_P;
} }
ATTR_COLD NETLIB_NAME(twoterm)::NETLIB_NAME(twoterm)() ATTR_COLD NETLIB_NAME(twoterm)::NETLIB_NAME(twoterm)()
: netlist_device_t(TWOTERM) : device_t(TWOTERM)
{ {
m_P.m_otherterm = &m_N; m_P.m_otherterm = &m_N;
m_N.m_otherterm = &m_P; m_N.m_otherterm = &m_P;

8
src/emu/netlist/analog/nld_twoterm.h
View File

@ -91,14 +91,14 @@ NETLIB_NAMESPACE_DEVICES_START()
// nld_twoterm // nld_twoterm
// ---------------------------------------------------------------------------------------- // ----------------------------------------------------------------------------------------
class NETLIB_NAME(twoterm) : public netlist_device_t class NETLIB_NAME(twoterm) : public device_t
{ {
public: public:
ATTR_COLD NETLIB_NAME(twoterm)(const family_t afamily); ATTR_COLD NETLIB_NAME(twoterm)(const family_t afamily);
ATTR_COLD NETLIB_NAME(twoterm)(); ATTR_COLD NETLIB_NAME(twoterm)();
netlist_terminal_t m_P; terminal_t m_P;
netlist_terminal_t m_N; terminal_t m_N;
virtual NETLIB_UPDATE_TERMINALSI() virtual NETLIB_UPDATE_TERMINALSI()
{ {
@ -256,7 +256,7 @@ public:
/* owning object must save those ... */ /* owning object must save those ... */
ATTR_COLD void save(pstring name, netlist_object_t &parent); ATTR_COLD void save(pstring name, object_t &parent);
private: private:
nl_double m_Vd; nl_double m_Vd;

4
src/emu/netlist/devices/net_lib.c
View File

@ -43,7 +43,7 @@ NETLIST_END()
NETLIB_NAMESPACE_DEVICES_START() NETLIB_NAMESPACE_DEVICES_START()
void initialize_factory(netlist_factory_list_t &factory) void initialize_factory(factory_list_t &factory)
{ {
ENTRY(R, RES, "R") ENTRY(R, RES, "R")
ENTRY(POT, POT, "R") ENTRY(POT, POT, "R")
@ -150,7 +150,7 @@ NETLIB_NAMESPACE_DEVICES_END()
namespace netlist namespace netlist
{ {
void initialize_factory(netlist_factory_list_t &factory) void initialize_factory(factory_list_t &factory)
{ {
devices::initialize_factory(factory); devices::initialize_factory(factory);
} }

2
src/emu/netlist/devices/net_lib.h
View File

@ -68,7 +68,7 @@ NETLIST_EXTERNAL(diode_models);
NETLIST_EXTERNAL(bjt_models); NETLIST_EXTERNAL(bjt_models);
namespace netlist { namespace netlist {
void initialize_factory(netlist::netlist_factory_list_t &factory); void initialize_factory(netlist::factory_list_t &factory);
} }
#endif #endif

2
src/emu/netlist/devices/nld_4020.c
View File

@ -60,7 +60,7 @@ NETLIB_START(4020_sub)
NETLIB_RESET(4020_sub) NETLIB_RESET(4020_sub)
{ {
m_IP.set_state(netlist_logic_t::STATE_INP_HL); m_IP.set_state(logic_t::STATE_INP_HL);
m_cnt = 0; m_cnt = 0;
} }

6
src/emu/netlist/devices/nld_4020.h
View File

@ -47,18 +47,18 @@ NETLIB_SUBDEVICE(4020_sub,
NETLIB_LOGIC_FAMILY(CD4000) NETLIB_LOGIC_FAMILY(CD4000)
ATTR_HOT void update_outputs(const UINT16 cnt); ATTR_HOT void update_outputs(const UINT16 cnt);
netlist_logic_input_t m_IP; logic_input_t m_IP;
UINT16 m_cnt; UINT16 m_cnt;
netlist_logic_output_t m_Q[14]; logic_output_t m_Q[14];
); );
NETLIB_DEVICE(4020, NETLIB_DEVICE(4020,
NETLIB_LOGIC_FAMILY(CD4000) NETLIB_LOGIC_FAMILY(CD4000)
NETLIB_NAME(4020_sub) sub; NETLIB_NAME(4020_sub) sub;
NETLIB_NAME(vdd_vss) m_supply; NETLIB_NAME(vdd_vss) m_supply;
netlist_logic_input_t m_RESET; logic_input_t m_RESET;
); );
NETLIB_DEVICE_DERIVED_PURE(4020_dip, 4020); NETLIB_DEVICE_DERIVED_PURE(4020_dip, 4020);

2
src/emu/netlist/devices/nld_4066.h
View File

@ -39,7 +39,7 @@ NETLIB_SUBDEVICE(4066,
NETLIB_LOGIC_FAMILY(CD4000) NETLIB_LOGIC_FAMILY(CD4000)
public: public:
netlist_analog_input_t m_control; analog_input_t m_control;
NETLIB_NAME(R) m_R; NETLIB_NAME(R) m_R;
NETLIB_NAME(vdd_vss) *m_supply; NETLIB_NAME(vdd_vss) *m_supply;

2
src/emu/netlist/devices/nld_74107.c
View File

@ -22,7 +22,7 @@ NETLIB_START(74107Asub)
NETLIB_RESET(74107Asub) NETLIB_RESET(74107Asub)
{ {
m_clk.set_state(netlist_logic_t::STATE_INP_HL); m_clk.set_state(logic_t::STATE_INP_HL);
m_Q.initial(0); m_Q.initial(0);
m_QQ.initial(1); m_QQ.initial(1);

12
src/emu/netlist/devices/nld_74107.h
View File

@ -77,10 +77,10 @@
NETLIB_NAMESPACE_DEVICES_START() NETLIB_NAMESPACE_DEVICES_START()
NETLIB_SUBDEVICE(74107Asub, NETLIB_SUBDEVICE(74107Asub,
netlist_logic_input_t m_clk; logic_input_t m_clk;
netlist_logic_output_t m_Q; logic_output_t m_Q;
netlist_logic_output_t m_QQ; logic_output_t m_QQ;
netlist_sig_t m_Q1; netlist_sig_t m_Q1;
netlist_sig_t m_Q2; netlist_sig_t m_Q2;
@ -94,9 +94,9 @@ NETLIB_DEVICE(74107A,
public: public:
NETLIB_NAME(74107Asub) sub; NETLIB_NAME(74107Asub) sub;
netlist_logic_input_t m_J; logic_input_t m_J;
netlist_logic_input_t m_K; logic_input_t m_K;
netlist_logic_input_t m_clrQ; logic_input_t m_clrQ;
); );

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

@ -49,16 +49,16 @@ public:
NETLIB_NAME(res_sw) m_RP; NETLIB_NAME(res_sw) m_RP;
NETLIB_NAME(res_sw) m_RN; NETLIB_NAME(res_sw) m_RN;
netlist_logic_output_t m_RP_Q; logic_output_t m_RP_Q;
netlist_logic_output_t m_RN_Q; logic_output_t m_RN_Q;
netlist_logic_input_t m_A; logic_input_t m_A;
netlist_logic_input_t m_B; logic_input_t m_B;
netlist_logic_input_t m_CLRQ; logic_input_t m_CLRQ;
netlist_logic_output_t m_Q; logic_output_t m_Q;
netlist_logic_output_t m_QQ; logic_output_t m_QQ;
netlist_analog_input_t m_CV; analog_input_t m_CV;
netlist_sig_t m_last_trig; netlist_sig_t m_last_trig;
UINT8 m_state; UINT8 m_state;

14
src/emu/netlist/devices/nld_74153.h
View File

@ -63,10 +63,10 @@
NETLIB_NAMESPACE_DEVICES_START() NETLIB_NAMESPACE_DEVICES_START()
NETLIB_SUBDEVICE(74153sub, NETLIB_SUBDEVICE(74153sub,
netlist_logic_input_t m_C[4]; logic_input_t m_C[4];
netlist_logic_input_t m_G; logic_input_t m_G;
netlist_logic_output_t m_Y; logic_output_t m_Y;
int m_chan; int m_chan;
); );
@ -74,16 +74,16 @@ NETLIB_SUBDEVICE(74153sub,
NETLIB_DEVICE(74153, NETLIB_DEVICE(74153,
public: public:
NETLIB_NAME(74153sub) m_sub; NETLIB_NAME(74153sub) m_sub;
netlist_logic_input_t m_A; logic_input_t m_A;
netlist_logic_input_t m_B; logic_input_t m_B;
); );
NETLIB_DEVICE(74153_dip, NETLIB_DEVICE(74153_dip,
NETLIB_NAME(74153sub) m_1; NETLIB_NAME(74153sub) m_1;
NETLIB_NAME(74153sub) m_2; NETLIB_NAME(74153sub) m_2;
netlist_logic_input_t m_A; logic_input_t m_A;
netlist_logic_input_t m_B; logic_input_t m_B;
); );
NETLIB_NAMESPACE_DEVICES_END() NETLIB_NAMESPACE_DEVICES_END()

2
src/emu/netlist/devices/nld_74175.c
View File

@ -31,7 +31,7 @@ NETLIB_START(74175_sub)
NETLIB_RESET(74175_sub) NETLIB_RESET(74175_sub)
{ {
m_CLK.set_state(netlist_logic_t::STATE_INP_LH); m_CLK.set_state(logic_t::STATE_INP_LH);
m_clrq = 0; m_clrq = 0;
m_data = 0xFF; m_data = 0xFF;
} }

10
src/emu/netlist/devices/nld_74175.h
View File

@ -47,9 +47,9 @@ NETLIB_NAMESPACE_DEVICES_START()
NETLIB_SUBDEVICE(74175_sub, NETLIB_SUBDEVICE(74175_sub,
netlist_logic_input_t m_CLK; logic_input_t m_CLK;
netlist_logic_output_t m_Q[4]; logic_output_t m_Q[4];
netlist_logic_output_t m_QQ[4]; logic_output_t m_QQ[4];
netlist_sig_t m_clrq; netlist_sig_t m_clrq;
UINT8 m_data; UINT8 m_data;
@ -58,8 +58,8 @@ NETLIB_SUBDEVICE(74175_sub,
NETLIB_DEVICE(74175, NETLIB_DEVICE(74175,
NETLIB_NAME(74175_sub) m_sub; NETLIB_NAME(74175_sub) m_sub;
netlist_logic_input_t m_D[4]; logic_input_t m_D[4];
netlist_logic_input_t m_CLRQ; logic_input_t m_CLRQ;
); );
NETLIB_DEVICE_DERIVED_PURE(74175_dip, 74175); NETLIB_DEVICE_DERIVED_PURE(74175_dip, 74175);

14
src/emu/netlist/devices/nld_74192.h
View File

@ -44,18 +44,18 @@ NETLIB_DEVICE(74192,
ATTR_HOT void update_outputs(); ATTR_HOT void update_outputs();
NETLIB_NAME(9316_subABCD) m_ABCD; NETLIB_NAME(9316_subABCD) m_ABCD;
netlist_logic_input_t m_CLEAR; logic_input_t m_CLEAR;
netlist_logic_input_t m_LOADQ; logic_input_t m_LOADQ;
netlist_logic_input_t m_CU; logic_input_t m_CU;
netlist_logic_input_t m_CD; logic_input_t m_CD;
INT8 m_cnt; INT8 m_cnt;
UINT8 m_last_CU; UINT8 m_last_CU;
UINT8 m_last_CD; UINT8 m_last_CD;
netlist_logic_output_t m_Q[4]; logic_output_t m_Q[4];
netlist_logic_output_t m_BORROWQ; logic_output_t m_BORROWQ;
netlist_logic_output_t m_CARRYQ; logic_output_t m_CARRYQ;
); );
NETLIB_DEVICE_DERIVED_PURE(74192_dip, 74192); NETLIB_DEVICE_DERIVED_PURE(74192_dip, 74192);

22
src/emu/netlist/devices/nld_74193.h
View File

@ -39,22 +39,22 @@ NETLIB_NAMESPACE_DEVICES_START()
NETLIB_DEVICE(74193, NETLIB_DEVICE(74193,
ATTR_HOT void update_outputs(); ATTR_HOT void update_outputs();
netlist_logic_input_t m_A; logic_input_t m_A;
netlist_logic_input_t m_B; logic_input_t m_B;
netlist_logic_input_t m_C; logic_input_t m_C;
netlist_logic_input_t m_D; logic_input_t m_D;
netlist_logic_input_t m_CLEAR; logic_input_t m_CLEAR;
netlist_logic_input_t m_LOADQ; logic_input_t m_LOADQ;
netlist_logic_input_t m_CU; logic_input_t m_CU;
netlist_logic_input_t m_CD; logic_input_t m_CD;
INT8 m_cnt; INT8 m_cnt;
UINT8 m_last_CU; UINT8 m_last_CU;
UINT8 m_last_CD; UINT8 m_last_CD;
netlist_logic_output_t m_Q[4]; logic_output_t m_Q[4];
netlist_logic_output_t m_BORROWQ; logic_output_t m_BORROWQ;
netlist_logic_output_t m_CARRYQ; logic_output_t m_CARRYQ;
); );
NETLIB_DEVICE_DERIVED_PURE(74193_dip, 74193); NETLIB_DEVICE_DERIVED_PURE(74193_dip, 74193);

16
src/emu/netlist/devices/nld_7448.h
View File

@ -54,15 +54,15 @@ NETLIB_SUBDEVICE(7448_sub,
ATTR_HOT void update_outputs(UINT8 v); ATTR_HOT void update_outputs(UINT8 v);
static const UINT8 tab7448[16][7]; static const UINT8 tab7448[16][7];
netlist_logic_input_t m_A; logic_input_t m_A;
netlist_logic_input_t m_B; logic_input_t m_B;
netlist_logic_input_t m_C; logic_input_t m_C;
netlist_logic_input_t m_D; logic_input_t m_D;
netlist_logic_input_t m_RBIQ; logic_input_t m_RBIQ;
UINT8 m_state; UINT8 m_state;
netlist_logic_output_t m_Q[7]; /* a .. g */ logic_output_t m_Q[7]; /* a .. g */
); );
@ -70,8 +70,8 @@ NETLIB_DEVICE(7448,
public: public:
NETLIB_NAME(7448_sub) sub; NETLIB_NAME(7448_sub) sub;
netlist_logic_input_t m_LTQ; logic_input_t m_LTQ;
netlist_logic_input_t m_BIQ; logic_input_t m_BIQ;
); );
#endif #endif

10
src/emu/netlist/devices/nld_7450.h
View File

@ -40,11 +40,11 @@ NETLIB_NAMESPACE_DEVICES_START()
NETLIB_DEVICE(7450, NETLIB_DEVICE(7450,
public: public:
netlist_logic_input_t m_A; logic_input_t m_A;
netlist_logic_input_t m_B; logic_input_t m_B;
netlist_logic_input_t m_C; logic_input_t m_C;
netlist_logic_input_t m_D; logic_input_t m_D;
netlist_logic_output_t m_Q; logic_output_t m_Q;
); );
NETLIB_DEVICE(7450_dip, NETLIB_DEVICE(7450_dip,

2
src/emu/netlist/devices/nld_7474.c
View File

@ -85,7 +85,7 @@ NETLIB_START(7474sub)
NETLIB_RESET(7474sub) NETLIB_RESET(7474sub)
{ {
m_CLK.set_state(netlist_logic_t::STATE_INP_LH); m_CLK.set_state(logic_t::STATE_INP_LH);
m_nextD = 0; m_nextD = 0;
/* FIXME: required by pong doubles - need a mechanism to set this from netlist */ /* FIXME: required by pong doubles - need a mechanism to set this from netlist */

12
src/emu/netlist/devices/nld_7474.h
View File

@ -57,11 +57,11 @@
NETLIB_NAMESPACE_DEVICES_START() NETLIB_NAMESPACE_DEVICES_START()
NETLIB_SUBDEVICE(7474sub, NETLIB_SUBDEVICE(7474sub,
netlist_logic_input_t m_CLK; logic_input_t m_CLK;
INT8 m_nextD; INT8 m_nextD;
netlist_logic_output_t m_Q; logic_output_t m_Q;
netlist_logic_output_t m_QQ; logic_output_t m_QQ;
ATTR_HOT inline void newstate(const UINT8 stateQ, const UINT8 stateQQ); ATTR_HOT inline void newstate(const UINT8 stateQ, const UINT8 stateQQ);
); );
@ -70,9 +70,9 @@ NETLIB_DEVICE(7474,
public: public:
NETLIB_NAME(7474sub) sub; NETLIB_NAME(7474sub) sub;
netlist_logic_input_t m_D; logic_input_t m_D;
netlist_logic_input_t m_CLRQ; logic_input_t m_CLRQ;
netlist_logic_input_t m_PREQ; logic_input_t m_PREQ;
); );
NETLIB_DEVICE(7474_dip, NETLIB_DEVICE(7474_dip,

28
src/emu/netlist/devices/nld_7483.h
View File

@ -47,23 +47,23 @@
NETLIB_NAMESPACE_DEVICES_START() NETLIB_NAMESPACE_DEVICES_START()
NETLIB_DEVICE(7483, NETLIB_DEVICE(7483,
netlist_logic_input_t m_C0; logic_input_t m_C0;
netlist_logic_input_t m_A1; logic_input_t m_A1;
netlist_logic_input_t m_A2; logic_input_t m_A2;
netlist_logic_input_t m_A3; logic_input_t m_A3;
netlist_logic_input_t m_A4; logic_input_t m_A4;
netlist_logic_input_t m_B1; logic_input_t m_B1;
netlist_logic_input_t m_B2; logic_input_t m_B2;
netlist_logic_input_t m_B3; logic_input_t m_B3;
netlist_logic_input_t m_B4; logic_input_t m_B4;
UINT8 m_lastr; UINT8 m_lastr;
netlist_logic_output_t m_S1; logic_output_t m_S1;
netlist_logic_output_t m_S2; logic_output_t m_S2;
netlist_logic_output_t m_S3; logic_output_t m_S3;
netlist_logic_output_t m_S4; logic_output_t m_S4;
netlist_logic_output_t m_C4; logic_output_t m_C4;
); );

14
src/emu/netlist/devices/nld_7490.h
View File

@ -74,18 +74,18 @@ NETLIB_NAMESPACE_DEVICES_START()
NETLIB_DEVICE(7490, NETLIB_DEVICE(7490,
ATTR_HOT void update_outputs(); ATTR_HOT void update_outputs();
netlist_logic_input_t m_R1; logic_input_t m_R1;
netlist_logic_input_t m_R2; logic_input_t m_R2;
netlist_logic_input_t m_R91; logic_input_t m_R91;
netlist_logic_input_t m_R92; logic_input_t m_R92;
netlist_logic_input_t m_A; logic_input_t m_A;
netlist_logic_input_t m_B; logic_input_t m_B;
UINT8 m_cnt; UINT8 m_cnt;
UINT8 m_last_A; UINT8 m_last_A;
UINT8 m_last_B; UINT8 m_last_B;
netlist_logic_output_t m_Q[4]; logic_output_t m_Q[4];
); );
NETLIB_DEVICE_DERIVED_PURE(7490_dip, 7490); NETLIB_DEVICE_DERIVED_PURE(7490_dip, 7490);

2
src/emu/netlist/devices/nld_7493.c
View File

@ -52,7 +52,7 @@ NETLIB_RESET(7493ff)
{ {
m_reset = 1; m_reset = 1;
m_state = 0; m_state = 0;
m_I.set_state(netlist_logic_t::STATE_INP_HL); m_I.set_state(logic_t::STATE_INP_HL);
} }
NETLIB_UPDATE(7493ff) NETLIB_UPDATE(7493ff)

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

@ -72,16 +72,16 @@
NETLIB_NAMESPACE_DEVICES_START() NETLIB_NAMESPACE_DEVICES_START()
NETLIB_SUBDEVICE(7493ff, NETLIB_SUBDEVICE(7493ff,
netlist_logic_input_t m_I; logic_input_t m_I;
netlist_logic_output_t m_Q; logic_output_t m_Q;
UINT8 m_reset; UINT8 m_reset;
UINT8 m_state; UINT8 m_state;
); );
NETLIB_DEVICE(7493, NETLIB_DEVICE(7493,
netlist_logic_input_t m_R1; logic_input_t m_R1;
netlist_logic_input_t m_R2; logic_input_t m_R2;
NETLIB_NAME(7493ff) A; NETLIB_NAME(7493ff) A;
NETLIB_NAME(7493ff) B; NETLIB_NAME(7493ff) B;

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

@ -38,8 +38,8 @@
NETLIB_NAMESPACE_DEVICES_START() NETLIB_NAMESPACE_DEVICES_START()
NETLIB_SUBDEVICE(SN74LS629clk, NETLIB_SUBDEVICE(SN74LS629clk,
netlist_logic_input_t m_FB; logic_input_t m_FB;
netlist_logic_output_t m_Y; logic_output_t m_Y;
netlist_time m_inc; netlist_time m_inc;
netlist_sig_t m_enableq; netlist_sig_t m_enableq;
@ -52,9 +52,9 @@ public:
NETLIB_NAME(R_base) m_R_FC; NETLIB_NAME(R_base) m_R_FC;
NETLIB_NAME(R_base) m_R_RNG; NETLIB_NAME(R_base) m_R_RNG;
netlist_logic_input_t m_ENQ; logic_input_t m_ENQ;
netlist_analog_input_t m_RNG; analog_input_t m_RNG;
netlist_analog_input_t m_FC; analog_input_t m_FC;
netlist_param_double_t m_CAP; netlist_param_double_t m_CAP;
); );

14
src/emu/netlist/devices/nld_82S16.h
View File

@ -35,13 +35,13 @@ NETLIB_NAMESPACE_DEVICES_START()
NETLIB_DEVICE(82S16, NETLIB_DEVICE(82S16,
netlist_logic_input_t m_A[8]; logic_input_t m_A[8];
netlist_logic_input_t m_CE1Q; logic_input_t m_CE1Q;
netlist_logic_input_t m_CE2Q; logic_input_t m_CE2Q;
netlist_logic_input_t m_CE3Q; logic_input_t m_CE3Q;
netlist_logic_input_t m_WEQ; logic_input_t m_WEQ;
netlist_logic_input_t m_DIN; logic_input_t m_DIN;
netlist_logic_output_t m_DOUTQ; logic_output_t m_DOUTQ;
//netlist_state_t<UINT8[256]> m_ram; //netlist_state_t<UINT8[256]> m_ram;
UINT8 m_ram[256]; UINT8 m_ram[256];

2
src/emu/netlist/devices/nld_9310.c
View File

@ -83,7 +83,7 @@ NETLIB_START(9310_sub)
NETLIB_RESET(9310_sub) NETLIB_RESET(9310_sub)
{ {
m_CLK.set_state(netlist_logic_t::STATE_INP_LH); m_CLK.set_state(logic_t::STATE_INP_LH);
m_cnt = 0; m_cnt = 0;
m_loadq = 1; m_loadq = 1;
m_ent = 1; m_ent = 1;

28
src/emu/netlist/devices/nld_9310.h
View File

@ -65,10 +65,10 @@
NETLIB_NAMESPACE_DEVICES_START() NETLIB_NAMESPACE_DEVICES_START()
NETLIB_SUBDEVICE(9310_subABCD, NETLIB_SUBDEVICE(9310_subABCD,
netlist_logic_input_t m_A; logic_input_t m_A;
netlist_logic_input_t m_B; logic_input_t m_B;
netlist_logic_input_t m_C; logic_input_t m_C;
netlist_logic_input_t m_D; logic_input_t m_D;
ATTR_HOT inline UINT8 read_ABCD() const ATTR_HOT inline UINT8 read_ABCD() const
{ {
@ -81,27 +81,27 @@ NETLIB_SUBDEVICE(9310_sub,
ATTR_HOT inline void update_outputs_all(const UINT8 cnt, const netlist_time out_delay); ATTR_HOT inline void update_outputs_all(const UINT8 cnt, const netlist_time out_delay);
ATTR_HOT inline void update_outputs(const UINT8 cnt); ATTR_HOT inline void update_outputs(const UINT8 cnt);
netlist_logic_input_t m_CLK; logic_input_t m_CLK;
UINT8 m_cnt; UINT8 m_cnt;
NETLIB_NAME(9310_subABCD) *m_ABCD; NETLIB_NAME(9310_subABCD) *m_ABCD;
netlist_sig_t m_loadq; netlist_sig_t m_loadq;
netlist_sig_t m_ent; netlist_sig_t m_ent;
netlist_logic_output_t m_QA; logic_output_t m_QA;
netlist_logic_output_t m_QB; logic_output_t m_QB;
netlist_logic_output_t m_QC; logic_output_t m_QC;
netlist_logic_output_t m_QD; logic_output_t m_QD;
netlist_logic_output_t m_RC; logic_output_t m_RC;
); );
NETLIB_DEVICE(9310, NETLIB_DEVICE(9310,
NETLIB_NAME(9310_sub) sub; NETLIB_NAME(9310_sub) sub;
NETLIB_NAME(9310_subABCD) subABCD; NETLIB_NAME(9310_subABCD) subABCD;
netlist_logic_input_t m_ENP; logic_input_t m_ENP;
netlist_logic_input_t m_ENT; logic_input_t m_ENT;
netlist_logic_input_t m_CLRQ; logic_input_t m_CLRQ;
netlist_logic_input_t m_LOADQ; logic_input_t m_LOADQ;
); );
NETLIB_DEVICE_DERIVED_PURE(9310_dip, 9310); NETLIB_DEVICE_DERIVED_PURE(9310_dip, 9310);

2
src/emu/netlist/devices/nld_9316.c
View File

@ -83,7 +83,7 @@ NETLIB_START(9316_sub)
NETLIB_RESET(9316_sub) NETLIB_RESET(9316_sub)
{ {
m_CLK.set_state(netlist_logic_t::STATE_INP_LH); m_CLK.set_state(logic_t::STATE_INP_LH);
m_cnt = 0; m_cnt = 0;
m_loadq = 1; m_loadq = 1;
m_ent = 1; m_ent = 1;

28
src/emu/netlist/devices/nld_9316.h
View File

@ -69,10 +69,10 @@
NETLIB_NAMESPACE_DEVICES_START() NETLIB_NAMESPACE_DEVICES_START()
NETLIB_SUBDEVICE(9316_subABCD, NETLIB_SUBDEVICE(9316_subABCD,
netlist_logic_input_t m_A; logic_input_t m_A;
netlist_logic_input_t m_B; logic_input_t m_B;
netlist_logic_input_t m_C; logic_input_t m_C;
netlist_logic_input_t m_D; logic_input_t m_D;
ATTR_HOT inline UINT8 read_ABCD() const ATTR_HOT inline UINT8 read_ABCD() const
{ {
@ -85,13 +85,13 @@ NETLIB_SUBDEVICE(9316_sub,
ATTR_HOT inline void update_outputs_all(const UINT8 cnt, const netlist_time out_delay); ATTR_HOT inline void update_outputs_all(const UINT8 cnt, const netlist_time out_delay);
ATTR_HOT inline void update_outputs(const UINT8 cnt); ATTR_HOT inline void update_outputs(const UINT8 cnt);
netlist_logic_input_t m_CLK; logic_input_t m_CLK;
netlist_logic_output_t m_QA; logic_output_t m_QA;
netlist_logic_output_t m_QB; logic_output_t m_QB;
netlist_logic_output_t m_QC; logic_output_t m_QC;
netlist_logic_output_t m_QD; logic_output_t m_QD;
netlist_logic_output_t m_RC; logic_output_t m_RC;
UINT8 m_cnt; UINT8 m_cnt;
NETLIB_NAME(9316_subABCD) *m_ABCD; NETLIB_NAME(9316_subABCD) *m_ABCD;
@ -103,10 +103,10 @@ NETLIB_SUBDEVICE(9316_sub,
NETLIB_DEVICE(9316, NETLIB_DEVICE(9316,
NETLIB_NAME(9316_sub) sub; NETLIB_NAME(9316_sub) sub;
NETLIB_NAME(9316_subABCD) subABCD; NETLIB_NAME(9316_subABCD) subABCD;
netlist_logic_input_t m_ENP; logic_input_t m_ENP;
netlist_logic_input_t m_ENT; logic_input_t m_ENT;
netlist_logic_input_t m_CLRQ; logic_input_t m_CLRQ;
netlist_logic_input_t m_LOADQ; logic_input_t m_LOADQ;
); );
NETLIB_DEVICE_DERIVED_PURE(9316_dip, 9316); NETLIB_DEVICE_DERIVED_PURE(9316_dip, 9316);

8
src/emu/netlist/devices/nld_cmos.h
View File

@ -13,15 +13,15 @@
NETLIB_NAMESPACE_DEVICES_START() NETLIB_NAMESPACE_DEVICES_START()
class nld_vdd_vss : public netlist_device_t class nld_vdd_vss : public device_t
{ {
public: public:
nld_vdd_vss () nld_vdd_vss ()
: netlist_device_t() : device_t()
{ } { }
netlist_analog_input_t m_vdd; analog_input_t m_vdd;
netlist_analog_input_t m_vss; analog_input_t m_vss;
protected: protected:
ATTR_HOT void update() {}; ATTR_HOT void update() {};

12
src/emu/netlist/devices/nld_legacy.h
View File

@ -32,18 +32,18 @@ NETLIB_NAMESPACE_DEVICES_START()
// ---------------------------------------------------------------------------------------- // ----------------------------------------------------------------------------------------
NETLIB_DEVICE(nicRSFF, NETLIB_DEVICE(nicRSFF,
netlist_logic_input_t m_S; logic_input_t m_S;
netlist_logic_input_t m_R; logic_input_t m_R;
netlist_logic_output_t m_Q; logic_output_t m_Q;
netlist_logic_output_t m_QQ; logic_output_t m_QQ;
); );
NETLIB_DEVICE_WITH_PARAMS(nicDelay, NETLIB_DEVICE_WITH_PARAMS(nicDelay,
netlist_logic_input_t m_I; logic_input_t m_I;
netlist_logic_output_t m_Q; logic_output_t m_Q;
netlist_param_int_t m_L_to_H; netlist_param_int_t m_L_to_H;
netlist_param_int_t m_H_to_L; netlist_param_int_t m_H_to_L;

6
src/emu/netlist/devices/nld_log.h
View File

@ -28,7 +28,7 @@ NETLIB_NAMESPACE_DEVICES_START()
NETLIB_DEVICE(log, NETLIB_DEVICE(log,
~NETLIB_NAME(log)(); ~NETLIB_NAME(log)();
netlist_analog_input_t m_I; analog_input_t m_I;
protected: protected:
void * m_file; void * m_file;
); );
@ -39,13 +39,13 @@ protected:
NET_CONNECT(_name, I2, _I2) NET_CONNECT(_name, I2, _I2)
NETLIB_DEVICE_DERIVED(logD, log, NETLIB_DEVICE_DERIVED(logD, log,
netlist_analog_input_t m_I2; analog_input_t m_I2;
); );
#if 0 #if 0
NETLIB_DEVICE(wav, NETLIB_DEVICE(wav,
~NETLIB_NAME(wav)(); ~NETLIB_NAME(wav)();
netlist_analog_input_t m_I; analog_input_t m_I;
private: private:
// FIXME: rewrite sound/wavwrite.h to be an object ... // FIXME: rewrite sound/wavwrite.h to be an object ...
void *m_file; void *m_file;

6
src/emu/netlist/devices/nld_ne555.h
View File

@ -33,9 +33,9 @@ NETLIB_DEVICE(NE555,
NETLIB_NAME(R) m_R3; NETLIB_NAME(R) m_R3;
NETLIB_NAME(R) m_RDIS; NETLIB_NAME(R) m_RDIS;
netlist_logic_input_t m_RESET; logic_input_t m_RESET;
netlist_analog_input_t m_THRES; analog_input_t m_THRES;
netlist_analog_input_t m_TRIG; analog_input_t m_TRIG;
netlist_analog_output_t m_OUT; netlist_analog_output_t m_OUT;
bool m_last_out; bool m_last_out;

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

@ -29,11 +29,11 @@ NETLIB_NAMESPACE_DEVICES_START()
// ---------------------------------------------------------------------------------------- // ----------------------------------------------------------------------------------------
template <int _numdev, int _check, int _invert> template <int _numdev, int _check, int _invert>
class net_signal_t : public netlist_device_t class net_signal_t : public device_t
{ {
public: public:
net_signal_t() net_signal_t()
: netlist_device_t(), m_active(1) : device_t(), m_active(1)
{ {
} }
@ -109,8 +109,8 @@ public:
} }
public: public:
netlist_logic_input_t m_I[_numdev]; logic_input_t m_I[_numdev];
netlist_logic_output_t m_Q[1]; logic_output_t m_Q[1];
INT32 m_active; INT32 m_active;
}; };

68
src/emu/netlist/devices/nld_system.h
View File

@ -81,12 +81,12 @@ public:
NETLIB_DEVICE_WITH_PARAMS(mainclock, NETLIB_DEVICE_WITH_PARAMS(mainclock,
public: public:
netlist_logic_output_t m_Q; logic_output_t m_Q;
netlist_param_double_t m_freq; netlist_param_double_t m_freq;
netlist_time m_inc; netlist_time m_inc;
ATTR_HOT inline static void mc_update(netlist_logic_net_t &net); ATTR_HOT inline static void mc_update(logic_net_t &net);
); );
// ----------------------------------------------------------------------------- // -----------------------------------------------------------------------------
@ -94,8 +94,8 @@ public:
// ----------------------------------------------------------------------------- // -----------------------------------------------------------------------------
NETLIB_DEVICE_WITH_PARAMS(clock, NETLIB_DEVICE_WITH_PARAMS(clock,
netlist_logic_input_t m_feedback; logic_input_t m_feedback;
netlist_logic_output_t m_Q; logic_output_t m_Q;
netlist_param_double_t m_freq; netlist_param_double_t m_freq;
netlist_time m_inc; netlist_time m_inc;
@ -106,8 +106,8 @@ NETLIB_DEVICE_WITH_PARAMS(clock,
// ----------------------------------------------------------------------------- // -----------------------------------------------------------------------------
NETLIB_DEVICE_WITH_PARAMS(extclock, NETLIB_DEVICE_WITH_PARAMS(extclock,
netlist_logic_input_t m_feedback; logic_input_t m_feedback;
netlist_logic_output_t m_Q; logic_output_t m_Q;
netlist_param_double_t m_freq; netlist_param_double_t m_freq;
netlist_param_str_t m_pattern; netlist_param_str_t m_pattern;
@ -124,7 +124,7 @@ NETLIB_DEVICE_WITH_PARAMS(extclock,
// ----------------------------------------------------------------------------- // -----------------------------------------------------------------------------
NETLIB_DEVICE_WITH_PARAMS(ttl_input, NETLIB_DEVICE_WITH_PARAMS(ttl_input,
netlist_logic_output_t m_Q; logic_output_t m_Q;
netlist_param_logic_t m_IN; netlist_param_logic_t m_IN;
); );
@ -139,11 +139,11 @@ NETLIB_DEVICE_WITH_PARAMS(analog_input,
// nld_gnd // nld_gnd
// ----------------------------------------------------------------------------- // -----------------------------------------------------------------------------
class NETLIB_NAME(gnd) : public netlist_device_t class NETLIB_NAME(gnd) : public device_t
{ {
public: public:
NETLIB_NAME(gnd)() NETLIB_NAME(gnd)()
: netlist_device_t(GND) { } : device_t(GND) { }
virtual ~NETLIB_NAME(gnd)() {} virtual ~NETLIB_NAME(gnd)() {}
@ -172,11 +172,11 @@ private:
// nld_dummy_input // nld_dummy_input
// ----------------------------------------------------------------------------- // -----------------------------------------------------------------------------
class NETLIB_NAME(dummy_input) : public netlist_device_t class NETLIB_NAME(dummy_input) : public device_t
{ {
public: public:
NETLIB_NAME(dummy_input)() NETLIB_NAME(dummy_input)()
: netlist_device_t(DUMMY) { } : device_t(DUMMY) { }
virtual ~NETLIB_NAME(dummy_input)() {} virtual ~NETLIB_NAME(dummy_input)() {}
@ -196,7 +196,7 @@ protected:
} }
private: private:
netlist_analog_input_t m_I; analog_input_t m_I;
}; };
@ -204,11 +204,11 @@ private:
// nld_frontier // nld_frontier
// ----------------------------------------------------------------------------- // -----------------------------------------------------------------------------
class NETLIB_NAME(frontier) : public netlist_device_t class NETLIB_NAME(frontier) : public device_t
{ {
public: public:
NETLIB_NAME(frontier)() NETLIB_NAME(frontier)()
: netlist_device_t(DUMMY) { } : device_t(DUMMY) { }
virtual ~NETLIB_NAME(frontier)() {} virtual ~NETLIB_NAME(frontier)() {}
@ -244,7 +244,7 @@ protected:
private: private:
NETLIB_NAME(twoterm) m_RIN; NETLIB_NAME(twoterm) m_RIN;
NETLIB_NAME(twoterm) m_ROUT; NETLIB_NAME(twoterm) m_ROUT;
netlist_analog_input_t m_I; analog_input_t m_I;
netlist_analog_output_t m_Q; netlist_analog_output_t m_Q;
netlist_param_double_t m_p_RIN; netlist_param_double_t m_p_RIN;
@ -255,17 +255,17 @@ private:
// nld_res_sw // nld_res_sw
// ----------------------------------------------------------------------------- // -----------------------------------------------------------------------------
class NETLIB_NAME(res_sw) : public netlist_device_t class NETLIB_NAME(res_sw) : public device_t
{ {
public: public:
NETLIB_NAME(res_sw)() NETLIB_NAME(res_sw)()
: netlist_device_t() { } : device_t() { }
virtual ~NETLIB_NAME(res_sw)() {} virtual ~NETLIB_NAME(res_sw)() {}
netlist_param_double_t m_RON; netlist_param_double_t m_RON;
netlist_param_double_t m_ROFF; netlist_param_double_t m_ROFF;
netlist_logic_input_t m_I; logic_input_t m_I;
NETLIB_NAME(R) m_R; NETLIB_NAME(R) m_R;
protected: protected:
@ -283,11 +283,11 @@ private:
// nld_base_proxy // nld_base_proxy
// ----------------------------------------------------------------------------- // -----------------------------------------------------------------------------
class nld_base_proxy : public netlist_device_t class nld_base_proxy : public device_t
{ {
public: public:
nld_base_proxy(netlist_logic_t *inout_proxied, netlist_core_terminal_t *proxy_inout) nld_base_proxy(logic_t *inout_proxied, core_terminal_t *proxy_inout)
: netlist_device_t() : device_t()
{ {
m_logic_family = inout_proxied->logic_family(); m_logic_family = inout_proxied->logic_family();
m_term_proxied = inout_proxied; m_term_proxied = inout_proxied;
@ -296,20 +296,20 @@ public:
virtual ~nld_base_proxy() {} virtual ~nld_base_proxy() {}
netlist_logic_t &term_proxied() const { return *m_term_proxied; } logic_t &term_proxied() const { return *m_term_proxied; }
netlist_core_terminal_t &proxy_term() const { return *m_proxy_term; } core_terminal_t &proxy_term() const { return *m_proxy_term; }
protected: protected:
virtual const netlist_logic_family_desc_t &logic_family() const virtual const logic_family_desc_t &logic_family() const
{ {
return *m_logic_family; return *m_logic_family;
} }
private: private:
const netlist_logic_family_desc_t *m_logic_family; const logic_family_desc_t *m_logic_family;
netlist_logic_t *m_term_proxied; logic_t *m_term_proxied;
netlist_core_terminal_t *m_proxy_term; core_terminal_t *m_proxy_term;
}; };
// ----------------------------------------------------------------------------- // -----------------------------------------------------------------------------
@ -319,15 +319,15 @@ private:
class nld_a_to_d_proxy : public nld_base_proxy class nld_a_to_d_proxy : public nld_base_proxy
{ {
public: public:
nld_a_to_d_proxy(netlist_logic_input_t *in_proxied) nld_a_to_d_proxy(logic_input_t *in_proxied)
: nld_base_proxy(in_proxied, &m_I) : nld_base_proxy(in_proxied, &m_I)
{ {
} }
virtual ~nld_a_to_d_proxy() {} virtual ~nld_a_to_d_proxy() {}
netlist_analog_input_t m_I; analog_input_t m_I;
netlist_logic_output_t m_Q; logic_output_t m_Q;
protected: protected:
void start() void start()
@ -363,10 +363,10 @@ class nld_base_d_to_a_proxy : public nld_base_proxy
public: public:
virtual ~nld_base_d_to_a_proxy() {} virtual ~nld_base_d_to_a_proxy() {}
virtual netlist_logic_input_t &in() { return m_I; } virtual logic_input_t &in() { return m_I; }
protected: protected:
nld_base_d_to_a_proxy(netlist_logic_output_t *out_proxied, netlist_core_terminal_t &proxy_out) 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_proxy(out_proxied, &proxy_out)
{ {
} }
@ -376,7 +376,7 @@ protected:
register_input("I", m_I); register_input("I", m_I);
} }
netlist_logic_input_t m_I; logic_input_t m_I;
private: private:
}; };
@ -384,7 +384,7 @@ private:
class nld_d_to_a_proxy : public nld_base_d_to_a_proxy class nld_d_to_a_proxy : public nld_base_d_to_a_proxy
{ {
public: public:
nld_d_to_a_proxy(netlist_logic_output_t *out_proxied) nld_d_to_a_proxy(logic_output_t *out_proxied)
: nld_base_d_to_a_proxy(out_proxied, m_RV.m_P) : nld_base_d_to_a_proxy(out_proxied, m_RV.m_P)
, m_RV(TWOTERM) , m_RV(TWOTERM)
, m_last_state(-1) , m_last_state(-1)

4
src/emu/netlist/devices/nld_truthtable.c
View File

@ -135,7 +135,7 @@ void truthtable_desc_t::help(unsigned cur, pstring_list_t list,
{ {
// cutoff previous inputs and outputs for ignore // cutoff previous inputs and outputs for ignore
if (m_outs[nstate] != ~0U && m_outs[nstate] != val) if (m_outs[nstate] != ~0U && m_outs[nstate] != val)
nl_fatalerror("Error in truthtable: State %04x already set, %d != %d\n", fatalerror_e("Error in truthtable: State %04x already set, %d != %d\n",
(UINT32) nstate, m_outs[nstate], val); (UINT32) nstate, m_outs[nstate], val);
m_outs[nstate] = val; m_outs[nstate] = val;
for (unsigned j=0; j<m_NO; j++) for (unsigned j=0; j<m_NO; j++)
@ -231,7 +231,7 @@ void truthtable_desc_t::setup(const pstring_list_t &truthtable, UINT32 disabled_
for (UINT32 i=0; i<m_size; i++) for (UINT32 i=0; i<m_size; i++)
{ {
if (m_outs[i] == ~0U) if (m_outs[i] == ~0U)
nl_fatalerror("truthtable: found element not set %04x\n", i); fatalerror_e("truthtable: found element not set %04x\n", i);
m_outs[i] |= ((ign[i] & ~disabled_ignore) << m_NO); m_outs[i] |= ((ign[i] & ~disabled_ignore) << m_NO);
} }
*m_initialized = true; *m_initialized = true;

18
src/emu/netlist/devices/nld_truthtable.h
View File

@ -88,7 +88,7 @@ private:
}; };
template<unsigned m_NI, unsigned m_NO, int has_state> template<unsigned m_NI, unsigned m_NO, int has_state>
class nld_truthtable_t : public netlist_device_t class nld_truthtable_t : public device_t
{ {
public: public:
@ -107,7 +107,7 @@ public:
}; };
nld_truthtable_t(truthtable_t *ttbl, const char *desc[]) nld_truthtable_t(truthtable_t *ttbl, const char *desc[])
: netlist_device_t(), m_last_state(0), m_ign(0), m_active(1), m_ttp(ttbl) : device_t(), m_last_state(0), m_ign(0), m_active(1), m_ttp(ttbl)
{ {
while (*desc != NULL && **desc != 0 ) while (*desc != NULL && **desc != 0 )
{ {
@ -118,7 +118,7 @@ public:
} }
nld_truthtable_t(truthtable_t *ttbl, const pstring_list_t &desc) nld_truthtable_t(truthtable_t *ttbl, const pstring_list_t &desc)
: netlist_device_t(), m_last_state(0), m_ign(0), m_active(1), m_ttp(ttbl) : device_t(), m_last_state(0), m_ign(0), m_active(1), m_ttp(ttbl)
{ {
m_desc = desc; m_desc = desc;
} }
@ -275,8 +275,8 @@ public:
} }
} }
netlist_logic_input_t m_I[m_NI]; logic_input_t m_I[m_NI];
netlist_logic_output_t m_Q[m_NO]; logic_output_t m_Q[m_NO];
private: private:
@ -288,13 +288,13 @@ private:
pstring_list_t m_desc; pstring_list_t m_desc;
}; };
class netlist_base_factory_truthtable_t : public netlist_base_factory_t class netlist_base_factory_truthtable_t : public base_factory_t
{ {
NETLIST_PREVENT_COPYING(netlist_base_factory_truthtable_t) NETLIST_PREVENT_COPYING(netlist_base_factory_truthtable_t)
public: public:
netlist_base_factory_truthtable_t(const pstring &name, const pstring &classname, netlist_base_factory_truthtable_t(const pstring &name, const pstring &classname,
const pstring &def_param) const pstring &def_param)
: netlist_base_factory_t(name, classname, def_param) : base_factory_t(name, classname, def_param)
{} {}
pstring_list_t m_desc; pstring_list_t m_desc;
}; };
@ -309,10 +309,10 @@ public:
const pstring &def_param) const pstring &def_param)
: netlist_base_factory_truthtable_t(name, classname, def_param) { } : netlist_base_factory_truthtable_t(name, classname, def_param) { }
netlist_device_t *Create() device_t *Create()
{ {
typedef nld_truthtable_t<m_NI, m_NO, has_state> tt_type; typedef nld_truthtable_t<m_NI, m_NO, has_state> tt_type;
netlist_device_t *r = palloc(tt_type, &m_ttbl, m_desc); device_t *r = palloc(tt_type, &m_ttbl, m_desc);
//r->init(setup, name); //r->init(setup, name);
return r; return r;
} }

288
src/emu/netlist/nl_base.c
View File

@ -25,7 +25,7 @@ namespace netlist
//============================================================ //============================================================
// emu_fatalerror is a generic fatal exception that provides an error string // emu_fatalerror is a generic fatal exception that provides an error string
nl_fatalerror::nl_fatalerror(const char *format, ...) fatalerror_e::fatalerror_e(const char *format, ...)
{ {
va_list ap; va_list ap;
va_start(ap, format); va_start(ap, format);
@ -34,7 +34,7 @@ nl_fatalerror::nl_fatalerror(const char *format, ...)
va_end(ap); va_end(ap);
} }
nl_fatalerror::nl_fatalerror(const char *format, va_list ap) fatalerror_e::fatalerror_e(const char *format, va_list ap)
{ {
m_text = pstring(format).vprintf(ap); m_text = pstring(format).vprintf(ap);
} }
@ -43,7 +43,7 @@ nl_fatalerror::nl_fatalerror(const char *format, va_list ap)
// netlist_logic_family_ttl_t // netlist_logic_family_ttl_t
// ---------------------------------------------------------------------------------------- // ----------------------------------------------------------------------------------------
class netlist_logic_family_ttl_t : public netlist_logic_family_desc_t class netlist_logic_family_ttl_t : public logic_family_desc_t
{ {
public: public:
netlist_logic_family_ttl_t() netlist_logic_family_ttl_t()
@ -56,14 +56,14 @@ public:
m_R_low = 1.0; m_R_low = 1.0;
m_R_high = 130.0; m_R_high = 130.0;
} }
virtual devices::nld_base_d_to_a_proxy *create_d_a_proxy(netlist_logic_output_t *proxied) const virtual devices::nld_base_d_to_a_proxy *create_d_a_proxy(logic_output_t *proxied) const
{ {
return palloc(devices::nld_d_to_a_proxy, proxied); return palloc(devices::nld_d_to_a_proxy, proxied);
} }
}; };
//FIXME: set to proper values //FIXME: set to proper values
class netlist_logic_family_cd4000_t : public netlist_logic_family_desc_t class netlist_logic_family_cd4000_t : public logic_family_desc_t
{ {
public: public:
netlist_logic_family_cd4000_t() netlist_logic_family_cd4000_t()
@ -76,22 +76,22 @@ public:
m_R_low = 1.0; m_R_low = 1.0;
m_R_high = 130.0; m_R_high = 130.0;
} }
virtual devices::nld_base_d_to_a_proxy *create_d_a_proxy(netlist_logic_output_t *proxied) const virtual devices::nld_base_d_to_a_proxy *create_d_a_proxy(logic_output_t *proxied) const
{ {
return palloc(devices::nld_d_to_a_proxy , proxied); return palloc(devices::nld_d_to_a_proxy , proxied);
} }
}; };
const netlist_logic_family_desc_t &netlist_family_TTL = netlist_logic_family_ttl_t(); const logic_family_desc_t &netlist_family_TTL = netlist_logic_family_ttl_t();
const netlist_logic_family_desc_t &netlist_family_CD4000 = netlist_logic_family_cd4000_t(); const logic_family_desc_t &netlist_family_CD4000 = netlist_logic_family_cd4000_t();
// ---------------------------------------------------------------------------------------- // ----------------------------------------------------------------------------------------
// netlist_queue_t // netlist_queue_t
// ---------------------------------------------------------------------------------------- // ----------------------------------------------------------------------------------------
netlist_queue_t::netlist_queue_t(netlist_base_t &nl) queue_t::queue_t(netlist_t &nl)
: netlist_timed_queue<netlist_net_t *, netlist_time>(512) : netlist_timed_queue<net_t *, netlist_time>(512)
, netlist_object_t(QUEUE, GENERIC) , object_t(QUEUE, GENERIC)
, pstate_callback_t() , pstate_callback_t()
, m_qsize(0) , m_qsize(0)
, m_times(512) , m_times(512)
@ -100,7 +100,7 @@ netlist_queue_t::netlist_queue_t(netlist_base_t &nl)
this->init_object(nl, "QUEUE"); this->init_object(nl, "QUEUE");
} }
void netlist_queue_t::register_state(pstate_manager_t &manager, const pstring &module) void queue_t::register_state(pstate_manager_t &manager, const pstring &module)
{ {
NL_VERBOSE_OUT(("register_state\n")); NL_VERBOSE_OUT(("register_state\n"));
manager.save_item(m_qsize, this, module + "." + "qsize"); manager.save_item(m_qsize, this, module + "." + "qsize");
@ -108,7 +108,7 @@ void netlist_queue_t::register_state(pstate_manager_t &manager, const pstring &m
manager.save_item(&(m_names[0][0]), this, module + "." + "names", m_names.size() * 64); manager.save_item(&(m_names[0][0]), this, module + "." + "names", m_names.size() * 64);
} }
void netlist_queue_t::on_pre_save() void queue_t::on_pre_save()
{ {
NL_VERBOSE_OUT(("on_pre_save\n")); NL_VERBOSE_OUT(("on_pre_save\n"));
m_qsize = this->count(); m_qsize = this->count();
@ -125,16 +125,16 @@ void netlist_queue_t::on_pre_save()
} }
void netlist_queue_t::on_post_load() void queue_t::on_post_load()
{ {
this->clear(); this->clear();
NL_VERBOSE_OUT(("current time %f qsize %d\n", netlist().time().as_double(), m_qsize)); NL_VERBOSE_OUT(("current time %f qsize %d\n", netlist().time().as_double(), m_qsize));
for (int i = 0; i < m_qsize; i++ ) for (int i = 0; i < m_qsize; i++ )
{ {
netlist_net_t *n = netlist().find_net(&(m_names[i][0])); net_t *n = netlist().find_net(&(m_names[i][0]));
//NL_VERBOSE_OUT(("Got %s ==> %p\n", qtemp[i].m_name, n)); //NL_VERBOSE_OUT(("Got %s ==> %p\n", qtemp[i].m_name, n));
//NL_VERBOSE_OUT(("schedule time %f (%f)\n", n->time().as_double(), netlist_time::from_raw(m_times[i]).as_double())); //NL_VERBOSE_OUT(("schedule time %f (%f)\n", n->time().as_double(), netlist_time::from_raw(m_times[i]).as_double()));
this->push(netlist_queue_t::entry_t(netlist_time::from_raw(m_times[i]), n)); this->push(queue_t::entry_t(netlist_time::from_raw(m_times[i]), n));
} }
} }
@ -142,24 +142,24 @@ void netlist_queue_t::on_post_load()
// netlist_object_t // netlist_object_t
// ---------------------------------------------------------------------------------------- // ----------------------------------------------------------------------------------------
ATTR_COLD netlist_object_t::netlist_object_t(const type_t atype, const family_t afamily) ATTR_COLD object_t::object_t(const type_t atype, const family_t afamily)
: m_objtype(atype) : m_objtype(atype)
, m_family(afamily) , m_family(afamily)
, m_netlist(NULL) , m_netlist(NULL)
{} {}
ATTR_COLD netlist_object_t::~netlist_object_t() ATTR_COLD object_t::~object_t()
{ {
} }
ATTR_COLD void netlist_object_t::init_object(netlist_base_t &nl, const pstring &aname) ATTR_COLD void object_t::init_object(netlist_t &nl, const pstring &aname)
{ {
m_netlist = &nl; m_netlist = &nl;
m_name = aname; m_name = aname;
save_register(); save_register();
} }
ATTR_COLD const pstring &netlist_object_t::name() const ATTR_COLD const pstring &object_t::name() const
{ {
if (m_name == "") if (m_name == "")
netlist().error("object not initialized"); netlist().error("object not initialized");
@ -170,17 +170,17 @@ ATTR_COLD const pstring &netlist_object_t::name() const
// netlist_owned_object_t // netlist_owned_object_t
// ---------------------------------------------------------------------------------------- // ----------------------------------------------------------------------------------------
ATTR_COLD netlist_owned_object_t::netlist_owned_object_t(const type_t atype, ATTR_COLD owned_object_t::owned_object_t(const type_t atype,
const family_t afamily) const family_t afamily)
: netlist_object_t(atype, afamily) : object_t(atype, afamily)
, m_netdev(NULL) , m_netdev(NULL)
{ {
} }
ATTR_COLD void netlist_owned_object_t::init_object(netlist_core_device_t &dev, ATTR_COLD void owned_object_t::init_object(core_device_t &dev,
const pstring &aname) const pstring &aname)
{ {
netlist_object_t::init_object(dev.netlist(), aname); object_t::init_object(dev.netlist(), aname);
m_netdev = &dev; m_netdev = &dev;
} }
@ -188,8 +188,8 @@ ATTR_COLD void netlist_owned_object_t::init_object(netlist_core_device_t &dev,
// netlist_base_t // netlist_base_t
// ---------------------------------------------------------------------------------------- // ----------------------------------------------------------------------------------------
netlist_base_t::netlist_base_t() netlist_t::netlist_t()
: netlist_object_t(NETLIST, GENERIC), pstate_manager_t(), : object_t(NETLIST, GENERIC), pstate_manager_t(),
m_stop(netlist_time::zero), m_stop(netlist_time::zero),
m_time(netlist_time::zero), m_time(netlist_time::zero),
m_use_deactivate(0), m_use_deactivate(0),
@ -201,7 +201,7 @@ netlist_base_t::netlist_base_t()
{ {
} }
netlist_base_t::~netlist_base_t() netlist_t::~netlist_t()
{ {
for (std::size_t i=0; i < m_nets.size(); i++) for (std::size_t i=0; i < m_nets.size(); i++)
{ {
@ -218,19 +218,19 @@ netlist_base_t::~netlist_base_t()
pstring::resetmem(); pstring::resetmem();
} }
ATTR_COLD void netlist_base_t::save_register() ATTR_COLD void netlist_t::save_register()
{ {
save(static_cast<pstate_callback_t &>(m_queue), "m_queue"); save(static_cast<pstate_callback_t &>(m_queue), "m_queue");
save(NLNAME(m_time)); save(NLNAME(m_time));
netlist_object_t::save_register(); object_t::save_register();
} }
ATTR_HOT nl_double netlist_base_t::gmin() const ATTR_HOT nl_double netlist_t::gmin() const
{ {
return solver()->gmin(); return solver()->gmin();
} }
ATTR_COLD void netlist_base_t::start() ATTR_COLD void netlist_t::start()
{ {
/* find the main clock and solver ... */ /* find the main clock and solver ... */
@ -256,14 +256,14 @@ ATTR_COLD void netlist_base_t::start()
NL_VERBOSE_OUT(("Initializing devices ...\n")); NL_VERBOSE_OUT(("Initializing devices ...\n"));
for (std::size_t i = 0; i < m_devices.size(); i++) for (std::size_t i = 0; i < m_devices.size(); i++)
{ {
netlist_device_t *dev = m_devices[i]; device_t *dev = m_devices[i];
if (dev != m_solver && dev != m_params) if (dev != m_solver && dev != m_params)
dev->start_dev(); dev->start_dev();
} }
} }
ATTR_COLD void netlist_base_t::stop() ATTR_COLD void netlist_t::stop()
{ {
/* find the main clock and solver ... */ /* find the main clock and solver ... */
@ -276,7 +276,7 @@ ATTR_COLD void netlist_base_t::stop()
} }
} }
ATTR_COLD netlist_net_t *netlist_base_t::find_net(const pstring &name) ATTR_COLD net_t *netlist_t::find_net(const pstring &name)
{ {
for (std::size_t i = 0; i < m_nets.size(); i++) for (std::size_t i = 0; i < m_nets.size(); i++)
{ {
@ -286,7 +286,7 @@ ATTR_COLD netlist_net_t *netlist_base_t::find_net(const pstring &name)
return NULL; return NULL;
} }
ATTR_COLD void netlist_base_t::rebuild_lists() ATTR_COLD void netlist_t::rebuild_lists()
{ {
//printf("Rebuild Lists\n"); //printf("Rebuild Lists\n");
for (std::size_t i = 0; i < m_nets.size(); i++) for (std::size_t i = 0; i < m_nets.size(); i++)
@ -294,7 +294,7 @@ ATTR_COLD void netlist_base_t::rebuild_lists()
} }
ATTR_COLD void netlist_base_t::reset() ATTR_COLD void netlist_t::reset()
{ {
m_time = netlist_time::zero; m_time = netlist_time::zero;
m_queue.clear(); m_queue.clear();
@ -328,7 +328,7 @@ ATTR_COLD void netlist_base_t::reset()
} }
ATTR_HOT void netlist_base_t::process_queue(const netlist_time &delta) ATTR_HOT void netlist_t::process_queue(const netlist_time &delta)
{ {
m_stop = m_time + delta; m_stop = m_time + delta;
@ -336,7 +336,7 @@ ATTR_HOT void netlist_base_t::process_queue(const netlist_time &delta)
{ {
while ( (m_time < m_stop) && (m_queue.is_not_empty())) while ( (m_time < m_stop) && (m_queue.is_not_empty()))
{ {
const netlist_queue_t::entry_t e = *m_queue.pop(); const queue_t::entry_t e = *m_queue.pop();
m_time = e.exec_time(); m_time = e.exec_time();
e.object()->update_devs(); e.object()->update_devs();
@ -346,7 +346,7 @@ ATTR_HOT void netlist_base_t::process_queue(const netlist_time &delta)
m_time = m_stop; m_time = m_stop;
} else { } else {
netlist_logic_net_t &mc_net = m_mainclock->m_Q.net().as_logic(); logic_net_t &mc_net = m_mainclock->m_Q.net().as_logic();
const netlist_time inc = m_mainclock->m_inc; const netlist_time inc = m_mainclock->m_inc;
netlist_time mc_time = mc_net.time(); netlist_time mc_time = mc_net.time();
@ -361,7 +361,7 @@ ATTR_HOT void netlist_base_t::process_queue(const netlist_time &delta)
devices::NETLIB_NAME(mainclock)::mc_update(mc_net); devices::NETLIB_NAME(mainclock)::mc_update(mc_net);
} }
const netlist_queue_t::entry_t e = *m_queue.pop(); const queue_t::entry_t e = *m_queue.pop();
m_time = e.exec_time(); m_time = e.exec_time();
e.object()->update_devs(); e.object()->update_devs();
@ -377,7 +377,7 @@ ATTR_HOT void netlist_base_t::process_queue(const netlist_time &delta)
} }
} }
ATTR_COLD void netlist_base_t::error(const char *format, ...) const ATTR_COLD void netlist_t::error(const char *format, ...) const
{ {
va_list ap; va_list ap;
va_start(ap, format); va_start(ap, format);
@ -385,7 +385,7 @@ ATTR_COLD void netlist_base_t::error(const char *format, ...) const
va_end(ap); va_end(ap);
} }
ATTR_COLD void netlist_base_t::warning(const char *format, ...) const ATTR_COLD void netlist_t::warning(const char *format, ...) const
{ {
va_list ap; va_list ap;
va_start(ap, format); va_start(ap, format);
@ -393,7 +393,7 @@ ATTR_COLD void netlist_base_t::warning(const char *format, ...) const
va_end(ap); va_end(ap);
} }
ATTR_COLD void netlist_base_t::log(const char *format, ...) const ATTR_COLD void netlist_t::log(const char *format, ...) const
{ {
va_list ap; va_list ap;
va_start(ap, format); va_start(ap, format);
@ -412,8 +412,8 @@ ATTR_COLD void netlist_base_t::log(const char *format, ...) const
// net_core_device_t // net_core_device_t
// ---------------------------------------------------------------------------------------- // ----------------------------------------------------------------------------------------
ATTR_COLD netlist_core_device_t::netlist_core_device_t(const family_t afamily) ATTR_COLD core_device_t::core_device_t(const family_t afamily)
: netlist_object_t(DEVICE, afamily), netlist_logic_family_t() : object_t(DEVICE, afamily), logic_family_t()
#if (NL_KEEP_STATISTICS) #if (NL_KEEP_STATISTICS)
, stat_total_time(0) , stat_total_time(0)
, stat_update_count(0) , stat_update_count(0)
@ -422,27 +422,27 @@ ATTR_COLD netlist_core_device_t::netlist_core_device_t(const family_t afamily)
{ {
} }
ATTR_COLD void netlist_core_device_t::init(netlist_base_t &anetlist, const pstring &name) ATTR_COLD void core_device_t::init(netlist_t &anetlist, const pstring &name)
{ {
set_logic_family(this->default_logic_family()); set_logic_family(this->default_logic_family());
init_object(anetlist, name); init_object(anetlist, name);
#if (NL_PMF_TYPE == NL_PMF_TYPE_GNUC_PMF) #if (NL_PMF_TYPE == NL_PMF_TYPE_GNUC_PMF)
void (netlist_core_device_t::* pFunc)() = &netlist_core_device_t::update; void (core_device_t::* pFunc)() = &core_device_t::update;
m_static_update = pFunc; m_static_update = pFunc;
#elif (NL_PMF_TYPE == NL_PMF_TYPE_GNUC_PMF_CONV) #elif (NL_PMF_TYPE == NL_PMF_TYPE_GNUC_PMF_CONV)
void (netlist_core_device_t::* pFunc)() = &netlist_core_device_t::update; void (core_device_t::* pFunc)() = &core_device_t::update;
m_static_update = reinterpret_cast<net_update_delegate>((this->*pFunc)); m_static_update = reinterpret_cast<net_update_delegate>((this->*pFunc));
#elif (NL_PMF_TYPE == NL_PMF_TYPE_INTERNAL) #elif (NL_PMF_TYPE == NL_PMF_TYPE_INTERNAL)
m_static_update = pmfp::get_mfp<net_update_delegate>(&netlist_core_device_t::update, this); m_static_update = pmfp::get_mfp<net_update_delegate>(&core_device_t::update, this);
#endif #endif
} }
ATTR_COLD netlist_core_device_t::~netlist_core_device_t() ATTR_COLD core_device_t::~core_device_t()
{ {
} }
ATTR_COLD void netlist_core_device_t::start_dev() ATTR_COLD void core_device_t::start_dev()
{ {
#if (NL_KEEP_STATISTICS) #if (NL_KEEP_STATISTICS)
netlist().m_started_devices.add(this, false); netlist().m_started_devices.add(this, false);
@ -450,16 +450,16 @@ ATTR_COLD void netlist_core_device_t::start_dev()
start(); start();
} }
ATTR_COLD void netlist_core_device_t::stop_dev() ATTR_COLD void core_device_t::stop_dev()
{ {
#if (NL_KEEP_STATISTICS) #if (NL_KEEP_STATISTICS)
#endif #endif
stop(); stop();
} }
ATTR_HOT netlist_sig_t netlist_core_device_t::INPLOGIC_PASSIVE(netlist_logic_input_t &inp) ATTR_HOT netlist_sig_t core_device_t::INPLOGIC_PASSIVE(logic_input_t &inp)
{ {
if (inp.state() != netlist_logic_t::STATE_INP_PASSIVE) if (inp.state() != logic_t::STATE_INP_PASSIVE)
return inp.Q(); return inp.Q();
else else
{ {
@ -475,35 +475,35 @@ ATTR_HOT netlist_sig_t netlist_core_device_t::INPLOGIC_PASSIVE(netlist_logic_inp
// netlist_device_t // netlist_device_t
// ---------------------------------------------------------------------------------------- // ----------------------------------------------------------------------------------------
netlist_device_t::netlist_device_t() device_t::device_t()
: netlist_core_device_t(GENERIC), : core_device_t(GENERIC),
m_terminals(20) m_terminals(20)
{ {
} }
netlist_device_t::netlist_device_t(const family_t afamily) device_t::device_t(const family_t afamily)
: netlist_core_device_t(afamily), : core_device_t(afamily),
m_terminals(20) m_terminals(20)
{ {
} }
netlist_device_t::~netlist_device_t() device_t::~device_t()
{ {
//NL_VERBOSE_OUT(("~net_device_t\n"); //NL_VERBOSE_OUT(("~net_device_t\n");
} }
ATTR_COLD netlist_setup_t &netlist_device_t::setup() ATTR_COLD netlist_setup_t &device_t::setup()
{ {
return netlist().setup(); return netlist().setup();
} }
ATTR_COLD void netlist_device_t::init(netlist_base_t &anetlist, const pstring &name) ATTR_COLD void device_t::init(netlist_t &anetlist, const pstring &name)
{ {
netlist_core_device_t::init(anetlist, name); core_device_t::init(anetlist, name);
} }
ATTR_COLD void netlist_device_t::register_sub(const pstring &name, netlist_device_t &dev) ATTR_COLD void device_t::register_sub(const pstring &name, device_t &dev)
{ {
dev.init(netlist(), this->name() + "." + name); dev.init(netlist(), this->name() + "." + name);
// subdevices always first inherit the logic family of the parent // subdevices always first inherit the logic family of the parent
@ -511,51 +511,51 @@ ATTR_COLD void netlist_device_t::register_sub(const pstring &name, netlist_devic
dev.start_dev(); dev.start_dev();
} }
ATTR_COLD void netlist_device_t::register_subalias(const pstring &name, netlist_core_terminal_t &term) ATTR_COLD void device_t::register_subalias(const pstring &name, core_terminal_t &term)
{ {
pstring alias = this->name() + "." + name; pstring alias = this->name() + "." + name;
// everything already fully qualified // everything already fully qualified
setup().register_alias_nofqn(alias, term.name()); setup().register_alias_nofqn(alias, term.name());
if (term.isType(netlist_terminal_t::INPUT) || term.isType(netlist_terminal_t::TERMINAL)) if (term.isType(terminal_t::INPUT) || term.isType(terminal_t::TERMINAL))
m_terminals.add(alias); m_terminals.add(alias);
} }
ATTR_COLD void netlist_device_t::register_terminal(const pstring &name, netlist_terminal_t &port) ATTR_COLD void device_t::register_terminal(const pstring &name, terminal_t &port)
{ {
setup().register_object(*this, name, port); setup().register_object(*this, name, port);
if (port.isType(netlist_terminal_t::INPUT) || port.isType(netlist_terminal_t::TERMINAL)) if (port.isType(terminal_t::INPUT) || port.isType(terminal_t::TERMINAL))
m_terminals.add(port.name()); m_terminals.add(port.name());
} }
ATTR_COLD void netlist_device_t::register_output(const pstring &name, netlist_logic_output_t &port) ATTR_COLD void device_t::register_output(const pstring &name, logic_output_t &port)
{ {
port.set_logic_family(this->logic_family()); port.set_logic_family(this->logic_family());
setup().register_object(*this, name, port); setup().register_object(*this, name, port);
} }
ATTR_COLD void netlist_device_t::register_output(const pstring &name, netlist_analog_output_t &port) ATTR_COLD void device_t::register_output(const pstring &name, netlist_analog_output_t &port)
{ {
//port.set_logic_family(this->logic_family()); //port.set_logic_family(this->logic_family());
setup().register_object(*this, name, port); setup().register_object(*this, name, port);
} }
ATTR_COLD void netlist_device_t::register_input(const pstring &name, netlist_logic_input_t &inp) ATTR_COLD void device_t::register_input(const pstring &name, logic_input_t &inp)
{ {
inp.set_logic_family(this->logic_family()); inp.set_logic_family(this->logic_family());
setup().register_object(*this, name, inp); setup().register_object(*this, name, inp);
m_terminals.add(inp.name()); m_terminals.add(inp.name());
} }
ATTR_COLD void netlist_device_t::register_input(const pstring &name, netlist_analog_input_t &inp) ATTR_COLD void device_t::register_input(const pstring &name, analog_input_t &inp)
{ {
//inp.set_logic_family(this->logic_family()); //inp.set_logic_family(this->logic_family());
setup().register_object(*this, name, inp); setup().register_object(*this, name, inp);
m_terminals.add(inp.name()); m_terminals.add(inp.name());
} }
ATTR_COLD void netlist_device_t::connect(netlist_core_terminal_t &t1, netlist_core_terminal_t &t2) ATTR_COLD void device_t::connect(core_terminal_t &t1, core_terminal_t &t2)
{ {
/* FIXME: These should really first be collected like NET_C connects */ /* FIXME: These should really first be collected like NET_C connects */
if (!setup().connect(t1, t2)) if (!setup().connect(t1, t2))
@ -564,7 +564,7 @@ ATTR_COLD void netlist_device_t::connect(netlist_core_terminal_t &t1, netlist_co
template <class C, class T> template <class C, class T>
ATTR_COLD void netlist_device_t::register_param(const pstring &sname, C &param, const T initialVal) ATTR_COLD void device_t::register_param(const pstring &sname, C &param, const T initialVal)
{ {
pstring fullname = this->name() + "." + sname; pstring fullname = this->name() + "." + sname;
param.init_object(*this, fullname); param.init_object(*this, fullname);
@ -572,21 +572,21 @@ ATTR_COLD void netlist_device_t::register_param(const pstring &sname, C &param,
setup().register_object(*this, fullname, param); setup().register_object(*this, fullname, param);
} }
template ATTR_COLD void netlist_device_t::register_param(const pstring &sname, netlist_param_double_t &param, const double initialVal); template ATTR_COLD void device_t::register_param(const pstring &sname, netlist_param_double_t &param, const double initialVal);
template ATTR_COLD void netlist_device_t::register_param(const pstring &sname, netlist_param_double_t &param, const float initialVal); template ATTR_COLD void device_t::register_param(const pstring &sname, netlist_param_double_t &param, const float initialVal);
template ATTR_COLD void netlist_device_t::register_param(const pstring &sname, netlist_param_int_t &param, const int initialVal); template ATTR_COLD void device_t::register_param(const pstring &sname, netlist_param_int_t &param, const int initialVal);
template ATTR_COLD void netlist_device_t::register_param(const pstring &sname, netlist_param_logic_t &param, const int initialVal); template ATTR_COLD void device_t::register_param(const pstring &sname, netlist_param_logic_t &param, const int initialVal);
template ATTR_COLD void netlist_device_t::register_param(const pstring &sname, netlist_param_str_t &param, const char * const initialVal); template ATTR_COLD void device_t::register_param(const pstring &sname, netlist_param_str_t &param, const char * const initialVal);
template ATTR_COLD void netlist_device_t::register_param(const pstring &sname, netlist_param_str_t &param, const pstring &initialVal); template ATTR_COLD void device_t::register_param(const pstring &sname, netlist_param_str_t &param, const pstring &initialVal);
template ATTR_COLD void netlist_device_t::register_param(const pstring &sname, netlist_param_model_t &param, const char * const initialVal); template ATTR_COLD void device_t::register_param(const pstring &sname, netlist_param_model_t &param, const char * const initialVal);
// ---------------------------------------------------------------------------------------- // ----------------------------------------------------------------------------------------
// netlist_net_t // netlist_net_t
// ---------------------------------------------------------------------------------------- // ----------------------------------------------------------------------------------------
ATTR_COLD netlist_net_t::netlist_net_t(const family_t afamily) ATTR_COLD net_t::net_t(const family_t afamily)
: netlist_object_t(NET, afamily) : object_t(NET, afamily)
, m_new_Q(0) , m_new_Q(0)
, m_cur_Q (0) , m_cur_Q (0)
, m_railterminal(NULL) , m_railterminal(NULL)
@ -597,19 +597,19 @@ ATTR_COLD netlist_net_t::netlist_net_t(const family_t afamily)
{ {
} }
ATTR_COLD netlist_net_t::~netlist_net_t() ATTR_COLD net_t::~net_t()
{ {
if (isInitialized()) if (isInitialized())
netlist().remove_save_items(this); netlist().remove_save_items(this);
} }
ATTR_COLD void netlist_net_t::init_object(netlist_base_t &nl, const pstring &aname) ATTR_COLD void net_t::init_object(netlist_t &nl, const pstring &aname)
{ {
netlist_object_t::init_object(nl, aname); object_t::init_object(nl, aname);
nl.m_nets.add(this); nl.m_nets.add(this);
} }
ATTR_HOT void netlist_net_t::inc_active(netlist_core_terminal_t &term) ATTR_HOT void net_t::inc_active(core_terminal_t &term)
{ {
m_active++; m_active++;
m_list_active.insert(term); m_list_active.insert(term);
@ -639,7 +639,7 @@ ATTR_HOT void netlist_net_t::inc_active(netlist_core_terminal_t &term)
} }
} }
ATTR_HOT void netlist_net_t::dec_active(netlist_core_terminal_t &term) ATTR_HOT void net_t::dec_active(core_terminal_t &term)
{ {
m_active--; m_active--;
nl_assert(m_active >= 0); nl_assert(m_active >= 0);
@ -648,20 +648,20 @@ ATTR_HOT void netlist_net_t::dec_active(netlist_core_terminal_t &term)
railterminal().netdev().dec_active(); railterminal().netdev().dec_active();
} }
ATTR_COLD void netlist_net_t::register_railterminal(netlist_core_terminal_t &mr) ATTR_COLD void net_t::register_railterminal(core_terminal_t &mr)
{ {
nl_assert(m_railterminal == NULL); nl_assert(m_railterminal == NULL);
m_railterminal = &mr; m_railterminal = &mr;
} }
ATTR_COLD void netlist_net_t::rebuild_list() ATTR_COLD void net_t::rebuild_list()
{ {
/* rebuild m_list */ /* rebuild m_list */
unsigned cnt = 0; unsigned cnt = 0;
m_list_active.clear(); m_list_active.clear();
for (std::size_t i=0; i < m_core_terms.size(); i++) for (std::size_t i=0; i < m_core_terms.size(); i++)
if (m_core_terms[i]->state() != netlist_logic_t::STATE_INP_PASSIVE) if (m_core_terms[i]->state() != logic_t::STATE_INP_PASSIVE)
{ {
m_list_active.add(*m_core_terms[i]); m_list_active.add(*m_core_terms[i]);
cnt++; cnt++;
@ -671,7 +671,7 @@ ATTR_COLD void netlist_net_t::rebuild_list()
m_active = cnt; m_active = cnt;
} }
ATTR_COLD void netlist_net_t::save_register() ATTR_COLD void net_t::save_register()
{ {
save(NLNAME(m_time)); save(NLNAME(m_time));
save(NLNAME(m_active)); save(NLNAME(m_active));
@ -679,10 +679,10 @@ ATTR_COLD void netlist_net_t::save_register()
save(NLNAME(m_cur_Analog)); save(NLNAME(m_cur_Analog));
save(NLNAME(m_cur_Q)); save(NLNAME(m_cur_Q));
save(NLNAME(m_new_Q)); save(NLNAME(m_new_Q));
netlist_object_t::save_register(); object_t::save_register();
} }
ATTR_HOT /* inline */ void netlist_core_terminal_t::update_dev(const UINT32 mask) ATTR_HOT /* inline */ void core_terminal_t::update_dev(const UINT32 mask)
{ {
inc_stat(netdev().stat_call_count); inc_stat(netdev().stat_call_count);
if ((state() & mask) != 0) if ((state() & mask) != 0)
@ -691,7 +691,7 @@ ATTR_HOT /* inline */ void netlist_core_terminal_t::update_dev(const UINT32 mask
} }
} }
ATTR_HOT /* inline */ void netlist_net_t::update_devs() ATTR_HOT /* inline */ void net_t::update_devs()
{ {
//assert(m_num_cons != 0); //assert(m_num_cons != 0);
nl_assert(this->isRailNet()); nl_assert(this->isRailNet());
@ -702,8 +702,8 @@ ATTR_HOT /* inline */ void netlist_net_t::update_devs()
m_in_queue = 2; /* mark as taken ... */ m_in_queue = 2; /* mark as taken ... */
m_cur_Q = m_new_Q; m_cur_Q = m_new_Q;
#if 0 #if 0
netlist_core_terminal_t * t[256]; core_terminal_t * t[256];
netlist_core_terminal_t *p = m_list_active.first(); core_terminal_t *p = m_list_active.first();
int cnt = 0; int cnt = 0;
while (p != NULL) while (p != NULL)
{ {
@ -714,7 +714,7 @@ ATTR_HOT /* inline */ void netlist_net_t::update_devs()
for (int i=0; i<cnt; i++) for (int i=0; i<cnt; i++)
t[i]->netdev().update_dev(); t[i]->netdev().update_dev();
netlist_core_terminal_t *p = m_list_active.first(); core_terminal_t *p = m_list_active.first();
while (p != NULL) while (p != NULL)
{ {
@ -723,7 +723,7 @@ ATTR_HOT /* inline */ void netlist_net_t::update_devs()
} }
#else #else
netlist_core_terminal_t *p = m_list_active.first(); core_terminal_t *p = m_list_active.first();
while (p != NULL) while (p != NULL)
{ {
@ -733,7 +733,7 @@ ATTR_HOT /* inline */ void netlist_net_t::update_devs()
#endif #endif
} }
ATTR_COLD void netlist_net_t::reset() ATTR_COLD void net_t::reset()
{ {
m_time = netlist_time::zero; m_time = netlist_time::zero;
m_active = 0; m_active = 0;
@ -753,32 +753,32 @@ ATTR_COLD void netlist_net_t::reset()
m_core_terms[i]->do_reset(); m_core_terms[i]->do_reset();
for (std::size_t i=0; i < m_core_terms.size(); i++) for (std::size_t i=0; i < m_core_terms.size(); i++)
if (m_core_terms[i]->state() != netlist_logic_t::STATE_INP_PASSIVE) if (m_core_terms[i]->state() != logic_t::STATE_INP_PASSIVE)
m_active++; m_active++;
} }
ATTR_COLD void netlist_net_t::register_con(netlist_core_terminal_t &terminal) ATTR_COLD void net_t::register_con(core_terminal_t &terminal)
{ {
terminal.set_net(*this); terminal.set_net(*this);
m_core_terms.add(&terminal); m_core_terms.add(&terminal);
if (terminal.state() != netlist_logic_t::STATE_INP_PASSIVE) if (terminal.state() != logic_t::STATE_INP_PASSIVE)
m_active++; m_active++;
} }
ATTR_COLD void netlist_net_t::move_connections(netlist_net_t *dest_net) ATTR_COLD void net_t::move_connections(net_t *dest_net)
{ {
for (std::size_t i = 0; i < m_core_terms.size(); i++) for (std::size_t i = 0; i < m_core_terms.size(); i++)
{ {
netlist_core_terminal_t *p = m_core_terms[i]; core_terminal_t *p = m_core_terms[i];
dest_net->register_con(*p); dest_net->register_con(*p);
} }
m_core_terms.clear(); // FIXME: othernet needs to be free'd from memory m_core_terms.clear(); // FIXME: othernet needs to be free'd from memory
m_active = 0; m_active = 0;
} }
ATTR_COLD void netlist_net_t::merge_net(netlist_net_t *othernet) ATTR_COLD void net_t::merge_net(net_t *othernet)
{ {
NL_VERBOSE_OUT(("merging nets ...\n")); NL_VERBOSE_OUT(("merging nets ...\n"));
if (othernet == NULL) if (othernet == NULL)
@ -809,47 +809,47 @@ ATTR_COLD void netlist_net_t::merge_net(netlist_net_t *othernet)
// netlist_logic_net_t // netlist_logic_net_t
// ---------------------------------------------------------------------------------------- // ----------------------------------------------------------------------------------------
ATTR_COLD netlist_logic_net_t::netlist_logic_net_t() ATTR_COLD logic_net_t::logic_net_t()
: netlist_net_t(LOGIC) : net_t(LOGIC)
{ {
} }
ATTR_COLD void netlist_logic_net_t::reset() ATTR_COLD void logic_net_t::reset()
{ {
netlist_net_t::reset(); net_t::reset();
} }
ATTR_COLD void netlist_logic_net_t::save_register() ATTR_COLD void logic_net_t::save_register()
{ {
netlist_net_t::save_register(); net_t::save_register();
} }
// ---------------------------------------------------------------------------------------- // ----------------------------------------------------------------------------------------
// netlist_analog_net_t // netlist_analog_net_t
// ---------------------------------------------------------------------------------------- // ----------------------------------------------------------------------------------------
ATTR_COLD netlist_analog_net_t::netlist_analog_net_t() ATTR_COLD analog_net_t::analog_net_t()
: netlist_net_t(ANALOG) : net_t(ANALOG)
, m_DD_n_m_1(0.0) , m_DD_n_m_1(0.0)
, m_h_n_m_1(1e-6) , m_h_n_m_1(1e-6)
, m_solver(NULL) , m_solver(NULL)
{ {
} }
ATTR_COLD void netlist_analog_net_t::reset() ATTR_COLD void analog_net_t::reset()
{ {
netlist_net_t::reset(); net_t::reset();
} }
ATTR_COLD void netlist_analog_net_t::save_register() ATTR_COLD void analog_net_t::save_register()
{ {
save(NLNAME(m_DD_n_m_1)); save(NLNAME(m_DD_n_m_1));
save(NLNAME(m_h_n_m_1)); save(NLNAME(m_h_n_m_1));
netlist_net_t::save_register(); net_t::save_register();
} }
ATTR_COLD bool netlist_analog_net_t::already_processed(list_t *groups, int cur_group) ATTR_COLD bool analog_net_t::already_processed(list_t *groups, int cur_group)
{ {
if (isRailNet()) if (isRailNet())
return true; return true;
@ -861,7 +861,7 @@ ATTR_COLD bool netlist_analog_net_t::already_processed(list_t *groups, int cur_g
return false; return false;
} }
ATTR_COLD void netlist_analog_net_t::process_net(list_t *groups, int &cur_group) ATTR_COLD void analog_net_t::process_net(list_t *groups, int &cur_group)
{ {
if (num_cons() == 0) if (num_cons() == 0)
return; return;
@ -870,13 +870,13 @@ ATTR_COLD void netlist_analog_net_t::process_net(list_t *groups, int &cur_group)
groups[cur_group].add(this); groups[cur_group].add(this);
for (std::size_t i = 0; i < m_core_terms.size(); i++) for (std::size_t i = 0; i < m_core_terms.size(); i++)
{ {
netlist_core_terminal_t *p = m_core_terms[i]; core_terminal_t *p = m_core_terms[i];
//SOLVER_VERBOSE_OUT(("terminal %s\n", p->name().cstr())); //SOLVER_VERBOSE_OUT(("terminal %s\n", p->name().cstr()));
if (p->isType(netlist_terminal_t::TERMINAL)) if (p->isType(terminal_t::TERMINAL))
{ {
//SOLVER_VERBOSE_OUT(("isterminal\n")); //SOLVER_VERBOSE_OUT(("isterminal\n"));
netlist_terminal_t *pt = static_cast<netlist_terminal_t *>(p); terminal_t *pt = static_cast<terminal_t *>(p);
netlist_analog_net_t *other_net = &pt->m_otherterm->net().as_analog(); analog_net_t *other_net = &pt->m_otherterm->net().as_analog();
if (!other_net->already_processed(groups, cur_group)) if (!other_net->already_processed(groups, cur_group))
other_net->process_net(groups, cur_group); other_net->process_net(groups, cur_group);
} }
@ -888,15 +888,15 @@ ATTR_COLD void netlist_analog_net_t::process_net(list_t *groups, int &cur_group)
// netlist_core_terminal_t // netlist_core_terminal_t
// ---------------------------------------------------------------------------------------- // ----------------------------------------------------------------------------------------
ATTR_COLD netlist_core_terminal_t::netlist_core_terminal_t(const type_t atype, const family_t afamily) ATTR_COLD core_terminal_t::core_terminal_t(const type_t atype, const family_t afamily)
: netlist_owned_object_t(atype, afamily) : owned_object_t(atype, afamily)
, plinkedlist_element_t<netlist_core_terminal_t>() , plinkedlist_element_t<core_terminal_t>()
, m_net(NULL) , m_net(NULL)
, m_state(STATE_NONEX) , m_state(STATE_NONEX)
{ {
} }
ATTR_COLD void netlist_core_terminal_t::set_net(netlist_net_t &anet) ATTR_COLD void core_terminal_t::set_net(net_t &anet)
{ {
m_net = &anet; m_net = &anet;
} }
@ -905,8 +905,8 @@ ATTR_COLD void netlist_core_terminal_t::set_net(netlist_net_t &anet)
// netlist_terminal_t // netlist_terminal_t
// ---------------------------------------------------------------------------------------- // ----------------------------------------------------------------------------------------
ATTR_COLD netlist_terminal_t::netlist_terminal_t() ATTR_COLD terminal_t::terminal_t()
: netlist_core_terminal_t(TERMINAL, ANALOG) : core_terminal_t(TERMINAL, ANALOG)
, m_Idr1(NULL) , m_Idr1(NULL)
, m_go1(NULL) , m_go1(NULL)
, m_gt1(NULL) , m_gt1(NULL)
@ -914,21 +914,21 @@ ATTR_COLD netlist_terminal_t::netlist_terminal_t()
{ {
} }
ATTR_HOT void netlist_terminal_t::schedule_solve() ATTR_HOT void terminal_t::schedule_solve()
{ {
// FIXME: Remove this after we found a way to remove *ALL* twoterms connected to railnets only. // FIXME: Remove this after we found a way to remove *ALL* twoterms connected to railnets only.
if (net().as_analog().solver() != NULL) if (net().as_analog().solver() != NULL)
net().as_analog().solver()->update_forced(); net().as_analog().solver()->update_forced();
} }
ATTR_HOT void netlist_terminal_t::schedule_after(const netlist_time &after) ATTR_HOT void terminal_t::schedule_after(const netlist_time &after)
{ {
// FIXME: Remove this after we found a way to remove *ALL* twoterms connected to railnets only. // FIXME: Remove this after we found a way to remove *ALL* twoterms connected to railnets only.
if (net().as_analog().solver() != NULL) if (net().as_analog().solver() != NULL)
net().as_analog().solver()->update_after(after); net().as_analog().solver()->update_after(after);
} }
ATTR_COLD void netlist_terminal_t::reset() ATTR_COLD void terminal_t::reset()
{ {
set_state(STATE_INP_ACTIVE); set_state(STATE_INP_ACTIVE);
set_ptr(m_Idr1, 0.0); set_ptr(m_Idr1, 0.0);
@ -936,12 +936,12 @@ ATTR_COLD void netlist_terminal_t::reset()
set_ptr(m_gt1, netlist().gmin()); set_ptr(m_gt1, netlist().gmin());
} }
ATTR_COLD void netlist_terminal_t::save_register() ATTR_COLD void terminal_t::save_register()
{ {
save(NLNAME(m_Idr1)); save(NLNAME(m_Idr1));
save(NLNAME(m_go1)); save(NLNAME(m_go1));
save(NLNAME(m_gt1)); save(NLNAME(m_gt1));
netlist_core_terminal_t::save_register(); core_terminal_t::save_register();
} }
@ -957,21 +957,21 @@ ATTR_COLD void netlist_terminal_t::save_register()
// netlist_logic_output_t // netlist_logic_output_t
// ---------------------------------------------------------------------------------------- // ----------------------------------------------------------------------------------------
ATTR_COLD netlist_logic_output_t::netlist_logic_output_t() ATTR_COLD logic_output_t::logic_output_t()
: netlist_logic_t(OUTPUT) : logic_t(OUTPUT)
{ {
set_state(STATE_OUT); set_state(STATE_OUT);
this->set_net(m_my_net); this->set_net(m_my_net);
} }
ATTR_COLD void netlist_logic_output_t::init_object(netlist_core_device_t &dev, const pstring &aname) ATTR_COLD void logic_output_t::init_object(core_device_t &dev, const pstring &aname)
{ {
netlist_core_terminal_t::init_object(dev, aname); core_terminal_t::init_object(dev, aname);
net().init_object(dev.netlist(), aname + ".net"); net().init_object(dev.netlist(), aname + ".net");
net().register_railterminal(*this); net().register_railterminal(*this);
} }
ATTR_COLD void netlist_logic_output_t::initial(const netlist_sig_t val) ATTR_COLD void logic_output_t::initial(const netlist_sig_t val)
{ {
net().as_logic().initial(val); net().as_logic().initial(val);
} }
@ -990,9 +990,9 @@ ATTR_COLD netlist_analog_output_t::netlist_analog_output_t()
net().as_analog().m_cur_Analog = 0.98; net().as_analog().m_cur_Analog = 0.98;
} }
ATTR_COLD void netlist_analog_output_t::init_object(netlist_core_device_t &dev, const pstring &aname) ATTR_COLD void netlist_analog_output_t::init_object(core_device_t &dev, const pstring &aname)
{ {
netlist_core_terminal_t::init_object(dev, aname); core_terminal_t::init_object(dev, aname);
net().init_object(dev.netlist(), aname + ".net"); net().init_object(dev.netlist(), aname + ".net");
net().register_railterminal(*this); net().register_railterminal(*this);
} }
@ -1008,7 +1008,7 @@ ATTR_COLD void netlist_analog_output_t::initial(const nl_double val)
// ---------------------------------------------------------------------------------------- // ----------------------------------------------------------------------------------------
ATTR_COLD netlist_param_t::netlist_param_t(const param_type_t atype) ATTR_COLD netlist_param_t::netlist_param_t(const param_type_t atype)
: netlist_owned_object_t(PARAM, ANALOG) : owned_object_t(PARAM, ANALOG)
, m_param_type(atype) , m_param_type(atype)
{ {
} }
@ -1099,7 +1099,7 @@ NETLIB_NAMESPACE_DEVICES_START()
// mainclock // mainclock
// ---------------------------------------------------------------------------------------- // ----------------------------------------------------------------------------------------
ATTR_HOT /* inline */ void NETLIB_NAME(mainclock)::mc_update(netlist_logic_net_t &net) ATTR_HOT /* inline */ void NETLIB_NAME(mainclock)::mc_update(logic_net_t &net)
{ {
net.toggle_new_Q(); net.toggle_new_Q();
net.update_devs(); net.update_devs();
@ -1125,7 +1125,7 @@ NETLIB_UPDATE_PARAM(mainclock)
NETLIB_UPDATE(mainclock) NETLIB_UPDATE(mainclock)
{ {
netlist_logic_net_t &net = m_Q.net().as_logic(); logic_net_t &net = m_Q.net().as_logic();
// this is only called during setup ... // this is only called during setup ...
net.toggle_new_Q(); net.toggle_new_Q();
net.set_time(netlist().time() + m_inc); net.set_time(netlist().time() + m_inc);

340
src/emu/netlist/nl_base.h
View File

@ -216,14 +216,14 @@
NETLIB_DEVICE_BASE(NETLIB_NAME(_name), NETLIB_NAME(_pclass), protected:, _priv) NETLIB_DEVICE_BASE(NETLIB_NAME(_name), NETLIB_NAME(_pclass), protected:, _priv)
#define NETLIB_DEVICE(_name, _priv) \ #define NETLIB_DEVICE(_name, _priv) \
NETLIB_DEVICE_BASE(NETLIB_NAME(_name), netlist_device_t, protected:, _priv) NETLIB_DEVICE_BASE(NETLIB_NAME(_name), device_t, protected:, _priv)
#define NETLIB_SUBDEVICE(_name, _priv) \ #define NETLIB_SUBDEVICE(_name, _priv) \
class NETLIB_NAME(_name) : public netlist_device_t \ class NETLIB_NAME(_name) : public device_t \
{ \ { \
public: \ public: \
NETLIB_NAME(_name) () \ NETLIB_NAME(_name) () \
: netlist_device_t() \ : device_t() \
{ } \ { } \
/*protected:*/ \ /*protected:*/ \
ATTR_HOT void update(); \ ATTR_HOT void update(); \
@ -234,7 +234,7 @@
} }
#define NETLIB_DEVICE_WITH_PARAMS(_name, _priv) \ #define NETLIB_DEVICE_WITH_PARAMS(_name, _priv) \
NETLIB_DEVICE_BASE(NETLIB_NAME(_name), netlist_device_t, \ NETLIB_DEVICE_BASE(NETLIB_NAME(_name), device_t, \
ATTR_HOT void update_param(); \ ATTR_HOT void update_param(); \
, _priv) , _priv)
@ -244,7 +244,7 @@
, _priv) , _priv)
#define NETLIB_LOGIC_FAMILY(_fam) \ #define NETLIB_LOGIC_FAMILY(_fam) \
virtual const netlist_logic_family_desc_t *default_logic_family() \ virtual const logic_family_desc_t *default_logic_family() \
{ \ { \
return &netlist_family_ ## _fam; \ return &netlist_family_ ## _fam; \
} }
@ -255,11 +255,11 @@ virtual const netlist_logic_family_desc_t *default_logic_family() \
//============================================================ //============================================================
#if defined(MAME_DEBUG) #if defined(MAME_DEBUG)
#define nl_assert(x) do { if (!(x)) throw nl_fatalerror("assert: %s:%d: %s", __FILE__, __LINE__, #x); } while (0) #define nl_assert(x) do { if (!(x)) throw fatalerror_e("assert: %s:%d: %s", __FILE__, __LINE__, #x); } while (0)
#else #else
#define nl_assert(x) do { if (0) if (!(x)) throw nl_fatalerror("assert: %s:%d: %s", __FILE__, __LINE__, #x); } while (0) #define nl_assert(x) do { if (0) if (!(x)) throw fatalerror_e("assert: %s:%d: %s", __FILE__, __LINE__, #x); } while (0)
#endif #endif
#define nl_assert_always(x, msg) do { if (!(x)) throw nl_fatalerror("Fatal error: %s\nCaused by assert: %s:%d: %s", msg, __FILE__, __LINE__, #x); } while (0) #define nl_assert_always(x, msg) do { if (!(x)) throw fatalerror_e("Fatal error: %s\nCaused by assert: %s:%d: %s", msg, __FILE__, __LINE__, #x); } while (0)
// ----------------------------------------------------------------------------- // -----------------------------------------------------------------------------
@ -287,35 +287,35 @@ namespace netlist
// Exceptions // Exceptions
//============================================================ //============================================================
class nl_fatalerror : public std::exception class fatalerror_e : public std::exception
{ {
public: public:
nl_fatalerror(const char *format, ...) ATTR_PRINTF(2,3); fatalerror_e(const char *format, ...) ATTR_PRINTF(2,3);
nl_fatalerror(const char *format, va_list ap); fatalerror_e(const char *format, va_list ap);
virtual ~nl_fatalerror() throw() {} virtual ~fatalerror_e() throw() {}
const pstring &text() { return m_text; } const pstring &text() { return m_text; }
private: private:
pstring m_text; pstring m_text;
}; };
class netlist_logic_output_t; class logic_output_t;
class netlist_analog_net_t; class analog_net_t;
class netlist_logic_net_t; class logic_net_t;
class netlist_net_t; class net_t;
class netlist_setup_t; class netlist_setup_t;
class netlist_base_t; class netlist_t;
class netlist_core_device_t; class core_device_t;
// ----------------------------------------------------------------------------- // -----------------------------------------------------------------------------
// netlist_output_family_t // netlist_output_family_t
// ----------------------------------------------------------------------------- // -----------------------------------------------------------------------------
class netlist_logic_family_desc_t class logic_family_desc_t
{ {
public: public:
virtual ~netlist_logic_family_desc_t() {} virtual ~logic_family_desc_t() {}
virtual devices::nld_base_d_to_a_proxy *create_d_a_proxy(netlist_logic_output_t *proxied) const = 0; virtual devices::nld_base_d_to_a_proxy *create_d_a_proxy(logic_output_t *proxied) const = 0;
nl_double m_low_thresh_V; nl_double m_low_thresh_V;
nl_double m_high_thresh_V; nl_double m_high_thresh_V;
@ -325,17 +325,17 @@ namespace netlist
nl_double m_R_high; nl_double m_R_high;
}; };
class netlist_logic_family_t class logic_family_t
{ {
public: public:
netlist_logic_family_t() : m_logic_family(NULL) {} logic_family_t() : m_logic_family(NULL) {}
ATTR_HOT const netlist_logic_family_desc_t *logic_family() const { return m_logic_family; } ATTR_HOT const logic_family_desc_t *logic_family() const { return m_logic_family; }
ATTR_COLD void set_logic_family(const netlist_logic_family_desc_t *fam) { m_logic_family = fam; } ATTR_COLD void set_logic_family(const logic_family_desc_t *fam) { m_logic_family = fam; }
private: private:
const netlist_logic_family_desc_t *m_logic_family; const logic_family_desc_t *m_logic_family;
}; };
/* Terminals inherit the family description from the netlist_device /* Terminals inherit the family description from the netlist_device
@ -345,17 +345,17 @@ namespace netlist
* Only devices of type GENERIC should have a family description entry * Only devices of type GENERIC should have a family description entry
*/ */
extern const netlist_logic_family_desc_t &netlist_family_TTL; extern const logic_family_desc_t &netlist_family_TTL;
extern const netlist_logic_family_desc_t &netlist_family_CD4000; extern const logic_family_desc_t &netlist_family_CD4000;
// ----------------------------------------------------------------------------- // -----------------------------------------------------------------------------
// netlist_object_t // netlist_object_t
// ----------------------------------------------------------------------------- // -----------------------------------------------------------------------------
class netlist_object_t class object_t
{ {
NETLIST_PREVENT_COPYING(netlist_object_t) NETLIST_PREVENT_COPYING(object_t)
public: public:
enum type_t { enum type_t {
TERMINAL = 0, TERMINAL = 0,
@ -387,11 +387,11 @@ namespace netlist
GND // GND device GND // GND device
}; };
ATTR_COLD netlist_object_t(const type_t atype, const family_t afamily); ATTR_COLD object_t(const type_t atype, const family_t afamily);
virtual ~netlist_object_t(); virtual ~object_t();
ATTR_COLD void init_object(netlist_base_t &nl, const pstring &aname); ATTR_COLD void init_object(netlist_t &nl, const pstring &aname);
ATTR_COLD bool isInitialized() { return (m_netlist != NULL); } ATTR_COLD bool isInitialized() { return (m_netlist != NULL); }
ATTR_COLD const pstring &name() const; ATTR_COLD const pstring &name() const;
@ -404,8 +404,8 @@ namespace netlist
ATTR_HOT bool isType(const type_t atype) const { return (m_objtype == atype); } ATTR_HOT bool isType(const type_t atype) const { return (m_objtype == atype); }
ATTR_HOT bool isFamily(const family_t afamily) const { return (m_family == afamily); } ATTR_HOT bool isFamily(const family_t afamily) const { return (m_family == afamily); }
ATTR_HOT netlist_base_t & netlist() { return *m_netlist; } ATTR_HOT netlist_t & netlist() { return *m_netlist; }
ATTR_HOT const netlist_base_t & netlist() const { return *m_netlist; } ATTR_HOT const netlist_t & netlist() const { return *m_netlist; }
ATTR_COLD void do_reset() ATTR_COLD void do_reset()
{ {
@ -422,36 +422,36 @@ namespace netlist
pstring m_name; pstring m_name;
const type_t m_objtype; const type_t m_objtype;
const family_t m_family; const family_t m_family;
netlist_base_t * m_netlist; netlist_t * m_netlist;
}; };
// ----------------------------------------------------------------------------- // -----------------------------------------------------------------------------
// netlist_owned_object_t // netlist_owned_object_t
// ----------------------------------------------------------------------------- // -----------------------------------------------------------------------------
class netlist_owned_object_t : public netlist_object_t class owned_object_t : public object_t
{ {
NETLIST_PREVENT_COPYING(netlist_owned_object_t) NETLIST_PREVENT_COPYING(owned_object_t)
public: public:
ATTR_COLD netlist_owned_object_t(const type_t atype, const family_t afamily); ATTR_COLD owned_object_t(const type_t atype, const family_t afamily);
ATTR_COLD void init_object(netlist_core_device_t &dev, const pstring &aname); ATTR_COLD void init_object(core_device_t &dev, const pstring &aname);
ATTR_HOT netlist_core_device_t &netdev() const { return *m_netdev; } ATTR_HOT core_device_t &netdev() const { return *m_netdev; }
private: private:
netlist_core_device_t * m_netdev; core_device_t * m_netdev;
}; };
// ----------------------------------------------------------------------------- // -----------------------------------------------------------------------------
// netlist_core_terminal_t // netlist_core_terminal_t
// ----------------------------------------------------------------------------- // -----------------------------------------------------------------------------
class netlist_core_terminal_t : public netlist_owned_object_t, public plinkedlist_element_t<netlist_core_terminal_t> class core_terminal_t : public owned_object_t, public plinkedlist_element_t<core_terminal_t>
{ {
NETLIST_PREVENT_COPYING(netlist_core_terminal_t) NETLIST_PREVENT_COPYING(core_terminal_t)
public: public:
typedef plist_t<netlist_core_terminal_t *> list_t; typedef plist_t<core_terminal_t *> list_t;
/* needed here ... */ /* needed here ... */
@ -465,16 +465,16 @@ namespace netlist
}; };
ATTR_COLD netlist_core_terminal_t(const type_t atype, const family_t afamily); ATTR_COLD core_terminal_t(const type_t atype, const family_t afamily);
//ATTR_COLD void init_object(netlist_core_device_t &dev, const pstring &aname); //ATTR_COLD void init_object(netlist_core_device_t &dev, const pstring &aname);
ATTR_COLD void set_net(netlist_net_t &anet); ATTR_COLD void set_net(net_t &anet);
ATTR_COLD void clear_net() { m_net = NULL; } ATTR_COLD void clear_net() { m_net = NULL; }
ATTR_HOT bool has_net() const { return (m_net != NULL); } ATTR_HOT bool has_net() const { return (m_net != NULL); }
ATTR_HOT const netlist_net_t & net() const { return *m_net;} ATTR_HOT const net_t & net() const { return *m_net;}
ATTR_HOT netlist_net_t & net() { return *m_net;} ATTR_HOT net_t & net() { return *m_net;}
ATTR_HOT bool is_state(const state_e astate) const { return (m_state == astate); } ATTR_HOT bool is_state(const state_e astate) const { return (m_state == astate); }
ATTR_HOT state_e state() const { return m_state; } ATTR_HOT state_e state() const { return m_state; }
@ -491,22 +491,22 @@ namespace netlist
virtual void save_register() virtual void save_register()
{ {
save(NLNAME(m_state)); save(NLNAME(m_state));
netlist_owned_object_t::save_register(); owned_object_t::save_register();
} }
private: private:
netlist_net_t * m_net; net_t * m_net;
state_e m_state; state_e m_state;
}; };
class netlist_terminal_t : public netlist_core_terminal_t class terminal_t : public core_terminal_t
{ {
NETLIST_PREVENT_COPYING(netlist_terminal_t) NETLIST_PREVENT_COPYING(terminal_t)
public: public:
typedef plist_t<netlist_terminal_t *> list_t; typedef plist_t<terminal_t *> list_t;
ATTR_COLD netlist_terminal_t(); ATTR_COLD terminal_t();
nl_double *m_Idr1; // drive current nl_double *m_Idr1; // drive current
nl_double *m_go1; // conductance for Voltage from other term nl_double *m_go1; // conductance for Voltage from other term
@ -536,7 +536,7 @@ namespace netlist
ATTR_HOT void schedule_solve(); ATTR_HOT void schedule_solve();
ATTR_HOT void schedule_after(const netlist_time &after); ATTR_HOT void schedule_after(const netlist_time &after);
netlist_terminal_t *m_otherterm; terminal_t *m_otherterm;
protected: protected:
virtual void save_register(); virtual void save_register();
@ -557,13 +557,13 @@ namespace netlist
// netlist_input_t // netlist_input_t
// ----------------------------------------------------------------------------- // -----------------------------------------------------------------------------
class netlist_logic_t : public netlist_core_terminal_t, public netlist_logic_family_t class logic_t : public core_terminal_t, public logic_family_t
{ {
public: public:
ATTR_COLD netlist_logic_t(const type_t atype) ATTR_COLD logic_t(const type_t atype)
: netlist_core_terminal_t(atype, LOGIC), netlist_logic_family_t(), : core_terminal_t(atype, LOGIC), logic_family_t(),
m_proxy(NULL) m_proxy(NULL)
{ {
} }
@ -578,13 +578,13 @@ namespace netlist
devices::nld_base_proxy *m_proxy; devices::nld_base_proxy *m_proxy;
}; };
class netlist_analog_t : public netlist_core_terminal_t class netlist_analog_t : public core_terminal_t
{ {
public: public:
ATTR_COLD netlist_analog_t(const type_t atype) ATTR_COLD netlist_analog_t(const type_t atype)
: netlist_core_terminal_t(atype, ANALOG) : core_terminal_t(atype, ANALOG)
{ {
} }
@ -597,11 +597,11 @@ namespace netlist
// netlist_logic_input_t // netlist_logic_input_t
// ----------------------------------------------------------------------------- // -----------------------------------------------------------------------------
class netlist_logic_input_t : public netlist_logic_t class logic_input_t : public logic_t
{ {
public: public:
ATTR_COLD netlist_logic_input_t() ATTR_COLD logic_input_t()
: netlist_logic_t(INPUT) : logic_t(INPUT)
{ {
set_state(STATE_INP_ACTIVE); set_state(STATE_INP_ACTIVE);
} }
@ -627,10 +627,10 @@ namespace netlist
// netlist_analog_input_t // netlist_analog_input_t
// ----------------------------------------------------------------------------- // -----------------------------------------------------------------------------
class netlist_analog_input_t : public netlist_analog_t class analog_input_t : public netlist_analog_t
{ {
public: public:
ATTR_COLD netlist_analog_input_t() ATTR_COLD analog_input_t()
: netlist_analog_t(INPUT) : netlist_analog_t(INPUT)
{ {
set_state(STATE_INP_ACTIVE); set_state(STATE_INP_ACTIVE);
@ -650,27 +650,27 @@ namespace netlist
// net_net_t // net_net_t
// ----------------------------------------------------------------------------- // -----------------------------------------------------------------------------
class netlist_net_t : public netlist_object_t class net_t : public object_t
{ {
NETLIST_PREVENT_COPYING(netlist_net_t) NETLIST_PREVENT_COPYING(net_t)
public: public:
typedef plist_t<netlist_net_t *> list_t; typedef plist_t<net_t *> list_t;
ATTR_COLD netlist_net_t(const family_t afamily); ATTR_COLD net_t(const family_t afamily);
virtual ~netlist_net_t(); virtual ~net_t();
ATTR_COLD void init_object(netlist_base_t &nl, const pstring &aname); ATTR_COLD void init_object(netlist_t &nl, const pstring &aname);
ATTR_COLD void register_con(netlist_core_terminal_t &terminal); ATTR_COLD void register_con(core_terminal_t &terminal);
ATTR_COLD void merge_net(netlist_net_t *othernet); ATTR_COLD void merge_net(net_t *othernet);
ATTR_COLD void register_railterminal(netlist_core_terminal_t &mr); ATTR_COLD void register_railterminal(core_terminal_t &mr);
ATTR_HOT netlist_logic_net_t & as_logic(); ATTR_HOT logic_net_t & as_logic();
ATTR_HOT const netlist_logic_net_t & as_logic() const; ATTR_HOT const logic_net_t & as_logic() const;
ATTR_HOT netlist_analog_net_t & as_analog(); ATTR_HOT analog_net_t & as_analog();
ATTR_HOT const netlist_analog_net_t & as_analog() const; ATTR_HOT const analog_net_t & as_analog() const;
ATTR_HOT void update_devs(); ATTR_HOT void update_devs();
@ -678,7 +678,7 @@ namespace netlist
ATTR_HOT void set_time(const netlist_time &ntime) { m_time = ntime; } ATTR_HOT void set_time(const netlist_time &ntime) { m_time = ntime; }
ATTR_HOT bool isRailNet() const { return !(m_railterminal == NULL); } ATTR_HOT bool isRailNet() const { return !(m_railterminal == NULL); }
ATTR_HOT netlist_core_terminal_t & railterminal() const { return *m_railterminal; } ATTR_HOT core_terminal_t & railterminal() const { return *m_railterminal; }
ATTR_HOT void push_to_queue(const netlist_time &delay); ATTR_HOT void push_to_queue(const netlist_time &delay);
ATTR_HOT void reschedule_in_queue(const netlist_time &delay); ATTR_HOT void reschedule_in_queue(const netlist_time &delay);
@ -686,14 +686,14 @@ namespace netlist
ATTR_HOT int num_cons() const { return m_core_terms.size(); } ATTR_HOT int num_cons() const { return m_core_terms.size(); }
ATTR_HOT void inc_active(netlist_core_terminal_t &term); ATTR_HOT void inc_active(core_terminal_t &term);
ATTR_HOT void dec_active(netlist_core_terminal_t &term); ATTR_HOT void dec_active(core_terminal_t &term);
ATTR_COLD void rebuild_list(); /* rebuild m_list after a load */ ATTR_COLD void rebuild_list(); /* rebuild m_list after a load */
ATTR_COLD void move_connections(netlist_net_t *new_net); ATTR_COLD void move_connections(net_t *new_net);
plist_t<netlist_core_terminal_t *> m_core_terms; // save post-start m_list ... plist_t<core_terminal_t *> m_core_terms; // save post-start m_list ...
ATTR_HOT void set_Q_time(const netlist_sig_t &newQ, const netlist_time &at) ATTR_HOT void set_Q_time(const netlist_sig_t &newQ, const netlist_time &at)
{ {
@ -715,8 +715,8 @@ namespace netlist
private: private:
netlist_core_terminal_t * m_railterminal; core_terminal_t * m_railterminal;
plinkedlist_t<netlist_core_terminal_t> m_list_active; plinkedlist_t<core_terminal_t> m_list_active;
netlist_time m_time; netlist_time m_time;
INT32 m_active; INT32 m_active;
@ -730,15 +730,15 @@ namespace netlist
}; };
class netlist_logic_net_t : public netlist_net_t class logic_net_t : public net_t
{ {
NETLIST_PREVENT_COPYING(netlist_logic_net_t) NETLIST_PREVENT_COPYING(logic_net_t)
public: public:
typedef plist_t<netlist_logic_net_t *> list_t; typedef plist_t<logic_net_t *> list_t;
ATTR_COLD netlist_logic_net_t(); ATTR_COLD logic_net_t();
virtual ~netlist_logic_net_t() { }; virtual ~logic_net_t() { };
ATTR_HOT netlist_sig_t Q() const ATTR_HOT netlist_sig_t Q() const
{ {
@ -790,15 +790,15 @@ namespace netlist
}; };
class netlist_analog_net_t : public netlist_net_t class analog_net_t : public net_t
{ {
NETLIST_PREVENT_COPYING(netlist_analog_net_t) NETLIST_PREVENT_COPYING(analog_net_t)
public: public:
typedef plist_t<netlist_analog_net_t *> list_t; typedef plist_t<analog_net_t *> list_t;
ATTR_COLD netlist_analog_net_t(); ATTR_COLD analog_net_t();
virtual ~netlist_analog_net_t() { }; virtual ~analog_net_t() { };
ATTR_HOT nl_double Q_Analog() const ATTR_HOT nl_double Q_Analog() const
{ {
@ -835,14 +835,14 @@ namespace netlist
// net_output_t // net_output_t
// ----------------------------------------------------------------------------- // -----------------------------------------------------------------------------
class netlist_logic_output_t : public netlist_logic_t class logic_output_t : public logic_t
{ {
NETLIST_PREVENT_COPYING(netlist_logic_output_t) NETLIST_PREVENT_COPYING(logic_output_t)
public: public:
ATTR_COLD netlist_logic_output_t(); ATTR_COLD logic_output_t();
ATTR_COLD void init_object(netlist_core_device_t &dev, const pstring &aname); ATTR_COLD void init_object(core_device_t &dev, const pstring &aname);
virtual void reset() virtual void reset()
{ {
set_state(STATE_OUT); set_state(STATE_OUT);
@ -856,7 +856,7 @@ namespace netlist
} }
private: private:
netlist_logic_net_t m_my_net; logic_net_t m_my_net;
}; };
class netlist_analog_output_t : public netlist_analog_t class netlist_analog_output_t : public netlist_analog_t
@ -866,7 +866,7 @@ namespace netlist
ATTR_COLD netlist_analog_output_t(); ATTR_COLD netlist_analog_output_t();
ATTR_COLD void init_object(netlist_core_device_t &dev, const pstring &aname); ATTR_COLD void init_object(core_device_t &dev, const pstring &aname);
virtual void reset() virtual void reset()
{ {
set_state(STATE_OUT); set_state(STATE_OUT);
@ -876,17 +876,17 @@ namespace netlist
ATTR_HOT void set_Q(const nl_double newQ); ATTR_HOT void set_Q(const nl_double newQ);
netlist_analog_net_t *m_proxied_net; // only for proxy nets in analog input logic analog_net_t *m_proxied_net; // only for proxy nets in analog input logic
private: private:
netlist_analog_net_t m_my_net; analog_net_t m_my_net;
}; };
// ----------------------------------------------------------------------------- // -----------------------------------------------------------------------------
// net_param_t // net_param_t
// ----------------------------------------------------------------------------- // -----------------------------------------------------------------------------
class netlist_param_t : public netlist_owned_object_t class netlist_param_t : public owned_object_t
{ {
NETLIST_PREVENT_COPYING(netlist_param_t) NETLIST_PREVENT_COPYING(netlist_param_t)
public: public:
@ -998,18 +998,18 @@ namespace netlist
// net_device_t // net_device_t
// ----------------------------------------------------------------------------- // -----------------------------------------------------------------------------
class netlist_core_device_t : public netlist_object_t, public netlist_logic_family_t class core_device_t : public object_t, public logic_family_t
{ {
NETLIST_PREVENT_COPYING(netlist_core_device_t) NETLIST_PREVENT_COPYING(core_device_t)
public: public:
typedef plist_t<netlist_core_device_t *> list_t; typedef plist_t<core_device_t *> list_t;
ATTR_COLD netlist_core_device_t(const family_t afamily); ATTR_COLD core_device_t(const family_t afamily);
virtual ~netlist_core_device_t(); virtual ~core_device_t();
virtual void init(netlist_base_t &anetlist, const pstring &name); virtual void init(netlist_t &anetlist, const pstring &name);
ATTR_HOT virtual void update_param() {} ATTR_HOT virtual void update_param() {}
ATTR_HOT void update_dev() ATTR_HOT void update_dev()
@ -1029,23 +1029,23 @@ namespace netlist
ATTR_COLD void start_dev(); ATTR_COLD void start_dev();
ATTR_COLD void stop_dev(); ATTR_COLD void stop_dev();
ATTR_HOT netlist_sig_t INPLOGIC_PASSIVE(netlist_logic_input_t &inp); ATTR_HOT netlist_sig_t INPLOGIC_PASSIVE(logic_input_t &inp);
ATTR_HOT netlist_sig_t INPLOGIC(const netlist_logic_input_t &inp) const ATTR_HOT netlist_sig_t INPLOGIC(const logic_input_t &inp) const
{ {
//printf("%s %d\n", inp.name().cstr(), inp.state()); //printf("%s %d\n", inp.name().cstr(), inp.state());
nl_assert(inp.state() != netlist_logic_t::STATE_INP_PASSIVE); nl_assert(inp.state() != logic_t::STATE_INP_PASSIVE);
return inp.Q(); return inp.Q();
} }
ATTR_HOT void OUTLOGIC(netlist_logic_output_t &out, const netlist_sig_t val, const netlist_time &delay) ATTR_HOT void OUTLOGIC(logic_output_t &out, const netlist_sig_t val, const netlist_time &delay)
{ {
out.set_Q(val, delay); out.set_Q(val, delay);
} }
ATTR_HOT nl_double INPANALOG(const netlist_analog_input_t &inp) const { return inp.Q_Analog(); } ATTR_HOT nl_double INPANALOG(const analog_input_t &inp) const { return inp.Q_Analog(); }
ATTR_HOT nl_double TERMANALOG(const netlist_terminal_t &term) const { return term.net().as_analog().Q_Analog(); } ATTR_HOT nl_double TERMANALOG(const terminal_t &term) const { return term.net().as_analog().Q_Analog(); }
ATTR_HOT void OUTANALOG(netlist_analog_output_t &out, const nl_double val) ATTR_HOT void OUTANALOG(netlist_analog_output_t &out, const nl_double val)
{ {
@ -1071,7 +1071,7 @@ namespace netlist
ATTR_HOT virtual void update() { } ATTR_HOT virtual void update() { }
virtual void start() { } virtual void start() { }
virtual void stop() { } \ virtual void stop() { } \
virtual const netlist_logic_family_desc_t *default_logic_family() virtual const logic_family_desc_t *default_logic_family()
{ {
return &netlist_family_TTL; return &netlist_family_TTL;
} }
@ -1079,9 +1079,9 @@ namespace netlist
private: private:
#if (NL_PMF_TYPE == NL_PMF_TYPE_GNUC_PMF) #if (NL_PMF_TYPE == NL_PMF_TYPE_GNUC_PMF)
typedef void (netlist_core_device_t::*net_update_delegate)(); typedef void (core_device_t::*net_update_delegate)();
#elif ((NL_PMF_TYPE == NL_PMF_TYPE_GNUC_PMF_CONV) || (NL_PMF_TYPE == NL_PMF_TYPE_INTERNAL)) #elif ((NL_PMF_TYPE == NL_PMF_TYPE_GNUC_PMF_CONV) || (NL_PMF_TYPE == NL_PMF_TYPE_INTERNAL))
typedef MEMBER_ABI void (*net_update_delegate)(netlist_core_device_t *); typedef MEMBER_ABI void (*net_update_delegate)(core_device_t *);
#endif #endif
#if (NL_PMF_TYPE > NL_PMF_TYPE_VIRTUAL) #if (NL_PMF_TYPE > NL_PMF_TYPE_VIRTUAL)
@ -1090,29 +1090,29 @@ namespace netlist
}; };
class netlist_device_t : public netlist_core_device_t class device_t : public core_device_t
{ {
NETLIST_PREVENT_COPYING(netlist_device_t) NETLIST_PREVENT_COPYING(device_t)
public: public:
ATTR_COLD netlist_device_t(); ATTR_COLD device_t();
ATTR_COLD netlist_device_t(const family_t afamily); ATTR_COLD device_t(const family_t afamily);
virtual ~netlist_device_t(); virtual ~device_t();
virtual void init(netlist_base_t &anetlist, const pstring &name); virtual void init(netlist_t &anetlist, const pstring &name);
ATTR_COLD netlist_setup_t &setup(); ATTR_COLD netlist_setup_t &setup();
ATTR_COLD void register_sub(const pstring &name, netlist_device_t &dev); ATTR_COLD void register_sub(const pstring &name, device_t &dev);
ATTR_COLD void register_subalias(const pstring &name, netlist_core_terminal_t &term); ATTR_COLD void register_subalias(const pstring &name, core_terminal_t &term);
ATTR_COLD void register_terminal(const pstring &name, netlist_terminal_t &port); ATTR_COLD void register_terminal(const pstring &name, terminal_t &port);
ATTR_COLD void register_output(const pstring &name, netlist_analog_output_t &out); ATTR_COLD void register_output(const pstring &name, netlist_analog_output_t &out);
ATTR_COLD void register_output(const pstring &name, netlist_logic_output_t &out); ATTR_COLD void register_output(const pstring &name, logic_output_t &out);
ATTR_COLD void register_input(const pstring &name, netlist_analog_input_t &in); ATTR_COLD void register_input(const pstring &name, analog_input_t &in);
ATTR_COLD void register_input(const pstring &name, netlist_logic_input_t &in); ATTR_COLD void register_input(const pstring &name, logic_input_t &in);
ATTR_COLD void connect(netlist_core_terminal_t &t1, netlist_core_terminal_t &t2); ATTR_COLD void connect(core_terminal_t &t1, core_terminal_t &t2);
plist_t<pstring> m_terminals; plist_t<pstring> m_terminals;
@ -1133,12 +1133,12 @@ namespace netlist
// netlist_queue_t // netlist_queue_t
// ----------------------------------------------------------------------------- // -----------------------------------------------------------------------------
class netlist_queue_t : public netlist_timed_queue<netlist_net_t *, netlist_time>, class queue_t : public netlist_timed_queue<net_t *, netlist_time>,
public netlist_object_t, public object_t,
public pstate_callback_t public pstate_callback_t
{ {
public: public:
netlist_queue_t(netlist_base_t &nl); queue_t(netlist_t &nl);
protected: protected:
@ -1159,26 +1159,26 @@ namespace netlist
// ----------------------------------------------------------------------------- // -----------------------------------------------------------------------------
class netlist_base_t : public netlist_object_t, public pstate_manager_t class netlist_t : public object_t, public pstate_manager_t
{ {
NETLIST_PREVENT_COPYING(netlist_base_t) NETLIST_PREVENT_COPYING(netlist_t)
public: public:
netlist_base_t(); netlist_t();
virtual ~netlist_base_t(); virtual ~netlist_t();
ATTR_COLD void start(); ATTR_COLD void start();
ATTR_COLD void stop(); ATTR_COLD void stop();
ATTR_HOT const netlist_queue_t &queue() const { return m_queue; } ATTR_HOT const queue_t &queue() const { return m_queue; }
ATTR_HOT netlist_queue_t &queue() { return m_queue; } ATTR_HOT queue_t &queue() { return m_queue; }
ATTR_HOT const netlist_time &time() const { return m_time; } ATTR_HOT const netlist_time &time() const { return m_time; }
ATTR_HOT devices::NETLIB_NAME(solver) *solver() const { return m_solver; } ATTR_HOT devices::NETLIB_NAME(solver) *solver() const { return m_solver; }
ATTR_HOT devices::NETLIB_NAME(gnd) *gnd() const { return m_gnd; } ATTR_HOT devices::NETLIB_NAME(gnd) *gnd() const { return m_gnd; }
ATTR_HOT nl_double gmin() const; ATTR_HOT nl_double gmin() const;
ATTR_HOT void push_to_queue(netlist_net_t &out, const netlist_time &attime); ATTR_HOT void push_to_queue(net_t &out, const netlist_time &attime);
ATTR_HOT void remove_from_queue(netlist_net_t &out); ATTR_HOT void remove_from_queue(net_t &out);
ATTR_HOT void process_queue(const netlist_time &delta); ATTR_HOT void process_queue(const netlist_time &delta);
ATTR_HOT void abort_current_queue_slice() { m_stop = netlist_time::zero; } ATTR_HOT void abort_current_queue_slice() { m_stop = netlist_time::zero; }
@ -1190,7 +1190,7 @@ namespace netlist
ATTR_COLD void set_setup(netlist_setup_t *asetup) { m_setup = asetup; } ATTR_COLD void set_setup(netlist_setup_t *asetup) { m_setup = asetup; }
ATTR_COLD netlist_setup_t &setup() { return *m_setup; } ATTR_COLD netlist_setup_t &setup() { return *m_setup; }
ATTR_COLD netlist_net_t *find_net(const pstring &name); ATTR_COLD net_t *find_net(const pstring &name);
ATTR_COLD void error(const char *format, ...) const ATTR_PRINTF(2,3); ATTR_COLD void error(const char *format, ...) const ATTR_PRINTF(2,3);
ATTR_COLD void warning(const char *format, ...) const ATTR_PRINTF(2,3); ATTR_COLD void warning(const char *format, ...) const ATTR_PRINTF(2,3);
@ -1239,10 +1239,10 @@ namespace netlist
return ret; return ret;
} }
pnamedlist_t<netlist_device_t *> m_devices; pnamedlist_t<device_t *> m_devices;
netlist_net_t::list_t m_nets; net_t::list_t m_nets;
#if (NL_KEEP_STATISTICS) #if (NL_KEEP_STATISTICS)
pnamedlist_t<netlist_core_device_t *> m_started_devices; pnamedlist_t<core_device_t *> m_started_devices;
#endif #endif
protected: protected:
@ -1274,7 +1274,7 @@ namespace netlist
netlist_time m_time; netlist_time m_time;
bool m_use_deactivate; bool m_use_deactivate;
netlist_queue_t m_queue; queue_t m_queue;
devices::NETLIB_NAME(mainclock) * m_mainclock; devices::NETLIB_NAME(mainclock) * m_mainclock;
@ -1290,7 +1290,7 @@ namespace netlist
// inline implementations // inline implementations
// ----------------------------------------------------------------------------- // -----------------------------------------------------------------------------
PSTATE_INTERFACE(netlist_object_t, m_netlist, name()) PSTATE_INTERFACE(object_t, m_netlist, name())
ATTR_HOT inline void netlist_param_str_t::setTo(const pstring &param) ATTR_HOT inline void netlist_param_str_t::setTo(const pstring &param)
{ {
@ -1316,32 +1316,32 @@ namespace netlist
} }
} }
ATTR_HOT inline netlist_logic_net_t & netlist_net_t::as_logic() ATTR_HOT inline logic_net_t & net_t::as_logic()
{ {
nl_assert(family() == LOGIC); nl_assert(family() == LOGIC);
return static_cast<netlist_logic_net_t &>(*this); return static_cast<logic_net_t &>(*this);
} }
ATTR_HOT inline const netlist_logic_net_t & netlist_net_t::as_logic() const ATTR_HOT inline const logic_net_t & net_t::as_logic() const
{ {
nl_assert(family() == LOGIC); nl_assert(family() == LOGIC);
return static_cast<const netlist_logic_net_t &>(*this); return static_cast<const logic_net_t &>(*this);
} }
ATTR_HOT inline netlist_analog_net_t & netlist_net_t::as_analog() ATTR_HOT inline analog_net_t & net_t::as_analog()
{ {
nl_assert(family() == ANALOG); nl_assert(family() == ANALOG);
return static_cast<netlist_analog_net_t &>(*this); return static_cast<analog_net_t &>(*this);
} }
ATTR_HOT inline const netlist_analog_net_t & netlist_net_t::as_analog() const ATTR_HOT inline const analog_net_t & net_t::as_analog() const
{ {
nl_assert(family() == ANALOG); nl_assert(family() == ANALOG);
return static_cast<const netlist_analog_net_t &>(*this); return static_cast<const analog_net_t &>(*this);
} }
ATTR_HOT inline void netlist_logic_input_t::inactivate() ATTR_HOT inline void logic_input_t::inactivate()
{ {
if (EXPECTED(!is_state(STATE_INP_PASSIVE))) if (EXPECTED(!is_state(STATE_INP_PASSIVE)))
{ {
@ -1351,7 +1351,7 @@ namespace netlist
} }
} }
ATTR_HOT inline void netlist_logic_input_t::activate() ATTR_HOT inline void logic_input_t::activate()
{ {
if (is_state(STATE_INP_PASSIVE)) if (is_state(STATE_INP_PASSIVE))
{ {
@ -1360,7 +1360,7 @@ namespace netlist
} }
} }
ATTR_HOT inline void netlist_logic_input_t::activate_hl() ATTR_HOT inline void logic_input_t::activate_hl()
{ {
if (is_state(STATE_INP_PASSIVE)) if (is_state(STATE_INP_PASSIVE))
{ {
@ -1369,7 +1369,7 @@ namespace netlist
} }
} }
ATTR_HOT inline void netlist_logic_input_t::activate_lh() ATTR_HOT inline void logic_input_t::activate_lh()
{ {
if (is_state(STATE_INP_PASSIVE)) if (is_state(STATE_INP_PASSIVE))
{ {
@ -1379,7 +1379,7 @@ namespace netlist
} }
ATTR_HOT inline void netlist_net_t::push_to_queue(const netlist_time &delay) ATTR_HOT inline void net_t::push_to_queue(const netlist_time &delay)
{ {
if (!is_queued() && (num_cons() > 0)) if (!is_queued() && (num_cons() > 0))
{ {
@ -1392,7 +1392,7 @@ namespace netlist
} }
} }
ATTR_HOT inline void netlist_net_t::reschedule_in_queue(const netlist_time &delay) ATTR_HOT inline void net_t::reschedule_in_queue(const netlist_time &delay)
{ {
if (is_queued()) if (is_queued())
netlist().remove_from_queue(*this); netlist().remove_from_queue(*this);
@ -1406,12 +1406,12 @@ namespace netlist
} }
ATTR_HOT inline netlist_sig_t netlist_logic_input_t::Q() const ATTR_HOT inline netlist_sig_t logic_input_t::Q() const
{ {
return net().as_logic().Q(); return net().as_logic().Q();
} }
ATTR_HOT inline nl_double netlist_analog_input_t::Q_Analog() const ATTR_HOT inline nl_double analog_input_t::Q_Analog() const
{ {
return net().as_analog().Q_Analog(); return net().as_analog().Q_Analog();
} }
@ -1425,19 +1425,19 @@ namespace netlist
} }
} }
ATTR_HOT inline void netlist_base_t::push_to_queue(netlist_net_t &out, const netlist_time &attime) ATTR_HOT inline void netlist_t::push_to_queue(net_t &out, const netlist_time &attime)
{ {
m_queue.push(netlist_queue_t::entry_t(attime, &out)); m_queue.push(queue_t::entry_t(attime, &out));
} }
ATTR_HOT inline void netlist_base_t::remove_from_queue(netlist_net_t &out) ATTR_HOT inline void netlist_t::remove_from_queue(net_t &out)
{ {
m_queue.remove(&out); m_queue.remove(&out);
} }
} }
NETLIST_SAVE_TYPE(netlist::netlist_core_terminal_t::state_e, DT_INT); NETLIST_SAVE_TYPE(netlist::core_terminal_t::state_e, DT_INT);
#endif /* NLBASE_H_ */ #endif /* NLBASE_H_ */

24
src/emu/netlist/nl_factory.c
View File

@ -18,7 +18,7 @@ namespace netlist
// net_device_t_base_factory // net_device_t_base_factory
// ---------------------------------------------------------------------------------------- // ----------------------------------------------------------------------------------------
ATTR_COLD const pstring_list_t netlist_base_factory_t::term_param_list() ATTR_COLD const pstring_list_t base_factory_t::term_param_list()
{ {
if (m_def_param.startsWith("+")) if (m_def_param.startsWith("+"))
return pstring_list_t(m_def_param.substr(1), ","); return pstring_list_t(m_def_param.substr(1), ",");
@ -26,7 +26,7 @@ ATTR_COLD const pstring_list_t netlist_base_factory_t::term_param_list()
return pstring_list_t(); return pstring_list_t();
} }
ATTR_COLD const pstring_list_t netlist_base_factory_t::def_params() ATTR_COLD const pstring_list_t base_factory_t::def_params()
{ {
if (m_def_param.startsWith("+") || m_def_param.equals("-")) if (m_def_param.startsWith("+") || m_def_param.equals("-"))
return pstring_list_t(); return pstring_list_t();
@ -35,28 +35,28 @@ ATTR_COLD const pstring_list_t netlist_base_factory_t::def_params()
} }
netlist_factory_list_t::netlist_factory_list_t() factory_list_t::factory_list_t()
{ {
} }
netlist_factory_list_t::~netlist_factory_list_t() factory_list_t::~factory_list_t()
{ {
for (std::size_t i=0; i < m_list.size(); i++) for (std::size_t i=0; i < m_list.size(); i++)
{ {
netlist_base_factory_t *p = m_list[i]; base_factory_t *p = m_list[i];
pfree(p); pfree(p);
} }
m_list.clear(); m_list.clear();
} }
netlist_device_t *netlist_factory_list_t::new_device_by_classname(const pstring &classname) const device_t *factory_list_t::new_device_by_classname(const pstring &classname) const
{ {
for (std::size_t i=0; i < m_list.size(); i++) for (std::size_t i=0; i < m_list.size(); i++)
{ {
netlist_base_factory_t *p = m_list[i]; base_factory_t *p = m_list[i];
if (p->classname() == classname) if (p->classname() == classname)
{ {
netlist_device_t *ret = p->Create(); device_t *ret = p->Create();
return ret; return ret;
} }
p++; p++;
@ -64,17 +64,17 @@ netlist_device_t *netlist_factory_list_t::new_device_by_classname(const pstring
return NULL; // appease code analysis return NULL; // appease code analysis
} }
netlist_device_t *netlist_factory_list_t::new_device_by_name(const pstring &name, netlist_setup_t &setup) const device_t *factory_list_t::new_device_by_name(const pstring &name, netlist_setup_t &setup) const
{ {
netlist_base_factory_t *f = factory_by_name(name, setup); base_factory_t *f = factory_by_name(name, setup);
return f->Create(); return f->Create();
} }
netlist_base_factory_t * netlist_factory_list_t::factory_by_name(const pstring &name, netlist_setup_t &setup) const base_factory_t * factory_list_t::factory_by_name(const pstring &name, netlist_setup_t &setup) const
{ {
for (std::size_t i=0; i < m_list.size(); i++) for (std::size_t i=0; i < m_list.size(); i++)
{ {
netlist_base_factory_t *p = m_list[i]; base_factory_t *p = m_list[i];
if (p->name() == name) if (p->name() == name)
{ {
return p; return p;

128
src/emu/netlist/nl_factory.h
View File

@ -17,82 +17,82 @@
namespace netlist namespace netlist
{ {
// ----------------------------------------------------------------------------- // -----------------------------------------------------------------------------
// net_dev class factory // net_dev class factory
// ----------------------------------------------------------------------------- // -----------------------------------------------------------------------------
class netlist_base_factory_t class base_factory_t
{
NETLIST_PREVENT_COPYING(netlist_base_factory_t)
public:
ATTR_COLD netlist_base_factory_t(const pstring &name, const pstring &classname,
const pstring &def_param)
: m_name(name), m_classname(classname), m_def_param(def_param)
{}
virtual ~netlist_base_factory_t() {}
virtual netlist_device_t *Create() = 0;
ATTR_COLD const pstring &name() const { return m_name; }
ATTR_COLD const pstring &classname() const { return m_classname; }
ATTR_COLD const pstring &param_desc() const { return m_def_param; }
ATTR_COLD const pstring_list_t term_param_list();
ATTR_COLD const pstring_list_t def_params();
protected:
pstring m_name; /* device name */
pstring m_classname; /* device class name */
pstring m_def_param; /* default parameter */
};
template <class C>
class net_list_factory_t : public netlist_base_factory_t
{
NETLIST_PREVENT_COPYING(net_list_factory_t)
public:
ATTR_COLD net_list_factory_t(const pstring &name, const pstring &classname,
const pstring &def_param)
: netlist_base_factory_t(name, classname, def_param) { }
ATTR_COLD netlist_device_t *Create()
{ {
netlist_device_t *r = palloc(C); NETLIST_PREVENT_COPYING(base_factory_t)
//r->init(setup, name); public:
return r; ATTR_COLD base_factory_t(const pstring &name, const pstring &classname,
} const pstring &def_param)
}; : m_name(name), m_classname(classname), m_def_param(def_param)
{}
class netlist_factory_list_t virtual ~base_factory_t() {}
{
public:
typedef plist_t<netlist_base_factory_t *> list_t;
netlist_factory_list_t(); virtual device_t *Create() = 0;
~netlist_factory_list_t();
template<class _C> ATTR_COLD const pstring &name() const { return m_name; }
ATTR_COLD void register_device(const pstring &name, const pstring &classname, ATTR_COLD const pstring &classname() const { return m_classname; }
const pstring &def_param) ATTR_COLD const pstring &param_desc() const { return m_def_param; }
ATTR_COLD const pstring_list_t term_param_list();
ATTR_COLD const pstring_list_t def_params();
protected:
pstring m_name; /* device name */
pstring m_classname; /* device class name */
pstring m_def_param; /* default parameter */
};
template <class C>
class factory_t : public base_factory_t
{ {
m_list.add(palloc(net_list_factory_t< _C >, name, classname, def_param)); NETLIST_PREVENT_COPYING(factory_t)
} public:
ATTR_COLD factory_t(const pstring &name, const pstring &classname,
const pstring &def_param)
: base_factory_t(name, classname, def_param) { }
ATTR_COLD void register_device(netlist_base_factory_t *factory) ATTR_COLD device_t *Create()
{
device_t *r = palloc(C);
//r->init(setup, name);
return r;
}
};
class factory_list_t
{ {
m_list.add(factory); public:
} typedef plist_t<base_factory_t *> list_t;
ATTR_COLD netlist_device_t *new_device_by_classname(const pstring &classname) const; factory_list_t();
ATTR_COLD netlist_device_t *new_device_by_name(const pstring &name, netlist_setup_t &setup) const; ~factory_list_t();
ATTR_COLD netlist_base_factory_t * factory_by_name(const pstring &name, netlist_setup_t &setup) const;
const list_t &list() { return m_list; } template<class _C>
ATTR_COLD void register_device(const pstring &name, const pstring &classname,
const pstring &def_param)
{
m_list.add(palloc(factory_t< _C >, name, classname, def_param));
}
private: ATTR_COLD void register_device(base_factory_t *factory)
list_t m_list; {
m_list.add(factory);
}
}; ATTR_COLD device_t *new_device_by_classname(const pstring &classname) const;
ATTR_COLD device_t *new_device_by_name(const pstring &name, netlist_setup_t &setup) const;
ATTR_COLD base_factory_t * factory_by_name(const pstring &name, netlist_setup_t &setup) const;
const list_t &list() { return m_list; }
private:
list_t m_list;
};
} }

4
src/emu/netlist/nl_parser.c
View File

@ -300,8 +300,8 @@ void netlist_parser::netdev_param()
void netlist_parser::device(const pstring &dev_type) void netlist_parser::device(const pstring &dev_type)
{ {
pstring devname; pstring devname;
netlist_base_factory_t *f = m_setup.factory().factory_by_name(dev_type, m_setup); base_factory_t *f = m_setup.factory().factory_by_name(dev_type, m_setup);
netlist_device_t *dev; device_t *dev;
pstring_list_t termlist = f->term_param_list(); pstring_list_t termlist = f->term_param_list();
pstring_list_t def_params = f->def_params(); pstring_list_t def_params = f->def_params();

2
src/emu/netlist/nl_parser.h
View File

@ -40,7 +40,7 @@ public:
protected: protected:
/* for debugging messages */ /* for debugging messages */
netlist_base_t &netlist() { return m_setup.netlist(); } netlist_t &netlist() { return m_setup.netlist(); }
virtual void verror(pstring msg, int line_num, pstring line); virtual void verror(pstring msg, int line_num, pstring line);
private: private:

156
src/emu/netlist/nl_setup.c
View File

@ -40,12 +40,12 @@ NETLIST_END()
namespace netlist namespace netlist
{ {
netlist_setup_t::netlist_setup_t(netlist_base_t *netlist) netlist_setup_t::netlist_setup_t(netlist_t *netlist)
: m_netlist(netlist) : m_netlist(netlist)
, m_proxy_cnt(0) , m_proxy_cnt(0)
{ {
netlist->set_setup(this); netlist->set_setup(this);
m_factory = palloc(netlist_factory_list_t); m_factory = palloc(factory_list_t);
} }
void netlist_setup_t::init() void netlist_setup_t::init()
@ -92,7 +92,7 @@ void netlist_setup_t::namespace_pop()
} }
netlist_device_t *netlist_setup_t::register_dev(netlist_device_t *dev, const pstring &name) device_t *netlist_setup_t::register_dev(device_t *dev, const pstring &name)
{ {
pstring fqn = build_fqn(name); pstring fqn = build_fqn(name);
@ -103,9 +103,9 @@ netlist_device_t *netlist_setup_t::register_dev(netlist_device_t *dev, const pst
return dev; return dev;
} }
netlist_device_t *netlist_setup_t::register_dev(const pstring &classname, const pstring &name) device_t *netlist_setup_t::register_dev(const pstring &classname, const pstring &name)
{ {
netlist_device_t *dev = factory().new_device_by_classname(classname); device_t *dev = factory().new_device_by_classname(classname);
if (dev == NULL) if (dev == NULL)
netlist().error("Class %s not found!\n", classname.cstr()); netlist().error("Class %s not found!\n", classname.cstr());
return register_dev(dev, name); return register_dev(dev, name);
@ -113,7 +113,7 @@ netlist_device_t *netlist_setup_t::register_dev(const pstring &classname, const
void netlist_setup_t::remove_dev(const pstring &name) void netlist_setup_t::remove_dev(const pstring &name)
{ {
netlist_device_t *dev = netlist().m_devices.find_by_name(name); device_t *dev = netlist().m_devices.find_by_name(name);
pstring temp = name + "."; pstring temp = name + ".";
if (dev == NULL) if (dev == NULL)
netlist().error("Device %s does not exist\n", name.cstr()); netlist().error("Device %s does not exist\n", name.cstr());
@ -150,25 +150,25 @@ void netlist_setup_t::register_alias(const pstring &alias, const pstring &out)
register_alias_nofqn(alias_fqn, out_fqn); register_alias_nofqn(alias_fqn, out_fqn);
} }
pstring netlist_setup_t::objtype_as_astr(netlist_object_t &in) const pstring netlist_setup_t::objtype_as_astr(object_t &in) const
{ {
switch (in.type()) switch (in.type())
{ {
case netlist_terminal_t::TERMINAL: case terminal_t::TERMINAL:
return "TERMINAL"; return "TERMINAL";
case netlist_terminal_t::INPUT: case terminal_t::INPUT:
return "INPUT"; return "INPUT";
case netlist_terminal_t::OUTPUT: case terminal_t::OUTPUT:
return "OUTPUT"; return "OUTPUT";
case netlist_terminal_t::NET: case terminal_t::NET:
return "NET"; return "NET";
case netlist_terminal_t::PARAM: case terminal_t::PARAM:
return "PARAM"; return "PARAM";
case netlist_terminal_t::DEVICE: case terminal_t::DEVICE:
return "DEVICE"; return "DEVICE";
case netlist_terminal_t::NETLIST: case terminal_t::NETLIST:
return "NETLIST"; return "NETLIST";
case netlist_terminal_t::QUEUE: case terminal_t::QUEUE:
return "QUEUE"; return "QUEUE";
} }
// FIXME: noreturn // FIXME: noreturn
@ -176,20 +176,20 @@ pstring netlist_setup_t::objtype_as_astr(netlist_object_t &in) const
return "Error"; return "Error";
} }
void netlist_setup_t::register_object(netlist_device_t &dev, const pstring &name, netlist_object_t &obj) void netlist_setup_t::register_object(device_t &dev, const pstring &name, object_t &obj)
{ {
switch (obj.type()) switch (obj.type())
{ {
case netlist_terminal_t::TERMINAL: case terminal_t::TERMINAL:
case netlist_terminal_t::INPUT: case terminal_t::INPUT:
case netlist_terminal_t::OUTPUT: case terminal_t::OUTPUT:
{ {
netlist_core_terminal_t &term = dynamic_cast<netlist_core_terminal_t &>(obj); core_terminal_t &term = dynamic_cast<core_terminal_t &>(obj);
if (obj.isType(netlist_terminal_t::OUTPUT)) if (obj.isType(terminal_t::OUTPUT))
{ {
if (obj.isFamily(netlist_terminal_t::LOGIC)) if (obj.isFamily(terminal_t::LOGIC))
dynamic_cast<netlist_logic_output_t &>(term).init_object(dev, dev.name() + "." + name); dynamic_cast<logic_output_t &>(term).init_object(dev, dev.name() + "." + name);
else if (obj.isFamily(netlist_terminal_t::ANALOG)) else if (obj.isFamily(terminal_t::ANALOG))
dynamic_cast<netlist_analog_output_t &>(term).init_object(dev, dev.name() + "." + name); dynamic_cast<netlist_analog_output_t &>(term).init_object(dev, dev.name() + "." + name);
else else
netlist().error("Error adding %s %s to terminal list, neither LOGIC nor ANALOG\n", objtype_as_astr(term).cstr(), term.name().cstr()); netlist().error("Error adding %s %s to terminal list, neither LOGIC nor ANALOG\n", objtype_as_astr(term).cstr(), term.name().cstr());
@ -202,9 +202,9 @@ void netlist_setup_t::register_object(netlist_device_t &dev, const pstring &name
NL_VERBOSE_OUT(("%s %s\n", objtype_as_astr(term).cstr(), name.cstr())); NL_VERBOSE_OUT(("%s %s\n", objtype_as_astr(term).cstr(), name.cstr()));
} }
break; break;
case netlist_terminal_t::NET: case terminal_t::NET:
break; break;
case netlist_terminal_t::PARAM: case terminal_t::PARAM:
{ {
netlist_param_t &param = dynamic_cast<netlist_param_t &>(obj); netlist_param_t &param = dynamic_cast<netlist_param_t &>(obj);
//printf("name: %s\n", name.cstr()); //printf("name: %s\n", name.cstr());
@ -265,13 +265,13 @@ void netlist_setup_t::register_object(netlist_device_t &dev, const pstring &name
netlist().error("Error adding parameter %s to parameter list\n", name.cstr()); netlist().error("Error adding parameter %s to parameter list\n", name.cstr());
} }
break; break;
case netlist_terminal_t::DEVICE: case terminal_t::DEVICE:
netlist().error("Device registration not yet supported - %s\n", name.cstr()); netlist().error("Device registration not yet supported - %s\n", name.cstr());
break; break;
case netlist_terminal_t::NETLIST: case terminal_t::NETLIST:
netlist().error("Netlist registration not yet supported - %s\n", name.cstr()); netlist().error("Netlist registration not yet supported - %s\n", name.cstr());
break; break;
case netlist_terminal_t::QUEUE: case terminal_t::QUEUE:
netlist().error("QUEUE registration not yet supported - %s\n", name.cstr()); netlist().error("QUEUE registration not yet supported - %s\n", name.cstr());
break; break;
} }
@ -321,7 +321,7 @@ void netlist_setup_t::register_frontier(const pstring attach, const double r_IN,
static int frontier_cnt = 0; static int frontier_cnt = 0;
pstring frontier_name = pstring::sprintf("frontier_%d", frontier_cnt); pstring frontier_name = pstring::sprintf("frontier_%d", frontier_cnt);
frontier_cnt++; frontier_cnt++;
netlist_device_t *front = register_dev("nld_frontier", frontier_name); device_t *front = register_dev("nld_frontier", frontier_name);
register_param(frontier_name + ".RIN", r_IN); register_param(frontier_name + ".RIN", r_IN);
register_param(frontier_name + ".ROUT", r_OUT); register_param(frontier_name + ".ROUT", r_OUT);
register_link(frontier_name + ".G", "GND"); register_link(frontier_name + ".G", "GND");
@ -375,10 +375,10 @@ const pstring netlist_setup_t::resolve_alias(const pstring &name) const
return ret; return ret;
} }
netlist_core_terminal_t *netlist_setup_t::find_terminal(const pstring &terminal_in, bool required) core_terminal_t *netlist_setup_t::find_terminal(const pstring &terminal_in, bool required)
{ {
const pstring &tname = resolve_alias(terminal_in); const pstring &tname = resolve_alias(terminal_in);
netlist_core_terminal_t *ret; core_terminal_t *ret;
ret = m_terminals.find_by_name(tname); ret = m_terminals.find_by_name(tname);
/* look for default */ /* look for default */
@ -395,14 +395,14 @@ netlist_core_terminal_t *netlist_setup_t::find_terminal(const pstring &terminal_
return ret; return ret;
} }
netlist_core_terminal_t *netlist_setup_t::find_terminal(const pstring &terminal_in, netlist_object_t::type_t atype, bool required) core_terminal_t *netlist_setup_t::find_terminal(const pstring &terminal_in, object_t::type_t atype, bool required)
{ {
const pstring &tname = resolve_alias(terminal_in); const pstring &tname = resolve_alias(terminal_in);
netlist_core_terminal_t *ret; core_terminal_t *ret;
ret = m_terminals.find_by_name(tname); ret = m_terminals.find_by_name(tname);
/* look for default */ /* look for default */
if (ret == NULL && atype == netlist_object_t::OUTPUT) if (ret == NULL && atype == object_t::OUTPUT)
{ {
/* look for ".Q" std output */ /* look for ".Q" std output */
pstring s = tname + ".Q"; pstring s = tname + ".Q";
@ -438,12 +438,12 @@ netlist_param_t *netlist_setup_t::find_param(const pstring &param_in, bool requi
} }
// FIXME avoid dynamic cast here // FIXME avoid dynamic cast here
devices::nld_base_proxy *netlist_setup_t::get_d_a_proxy(netlist_core_terminal_t &out) devices::nld_base_proxy *netlist_setup_t::get_d_a_proxy(core_terminal_t &out)
{ {
nl_assert(out.isFamily(netlist_terminal_t::LOGIC)); nl_assert(out.isFamily(terminal_t::LOGIC));
//printf("proxy for %s\n", out.name().cstr());; //printf("proxy for %s\n", out.name().cstr());;
netlist_logic_output_t &out_cast = dynamic_cast<netlist_logic_output_t &>(out); logic_output_t &out_cast = dynamic_cast<logic_output_t &>(out);
devices::nld_base_proxy *proxy = out_cast.get_proxy(); devices::nld_base_proxy *proxy = out_cast.get_proxy();
if (proxy == NULL) if (proxy == NULL)
@ -461,7 +461,7 @@ devices::nld_base_proxy *netlist_setup_t::get_d_a_proxy(netlist_core_terminal_t
for (std::size_t i = 0; i < out.net().m_core_terms.size(); i++) for (std::size_t i = 0; i < out.net().m_core_terms.size(); i++)
{ {
netlist_core_terminal_t *p = out.net().m_core_terms[i]; core_terminal_t *p = out.net().m_core_terms[i];
p->clear_net(); // de-link from all nets ... p->clear_net(); // de-link from all nets ...
if (!connect(new_proxy->proxy_term(), *p)) if (!connect(new_proxy->proxy_term(), *p))
netlist().error("Error connecting %s to %s\n", new_proxy->proxy_term().name().cstr(), (*p).name().cstr()); netlist().error("Error connecting %s to %s\n", new_proxy->proxy_term().name().cstr(), (*p).name().cstr());
@ -475,11 +475,11 @@ devices::nld_base_proxy *netlist_setup_t::get_d_a_proxy(netlist_core_terminal_t
return proxy; return proxy;
} }
void netlist_setup_t::connect_input_output(netlist_core_terminal_t &in, netlist_core_terminal_t &out) void netlist_setup_t::connect_input_output(core_terminal_t &in, core_terminal_t &out)
{ {
if (out.isFamily(netlist_terminal_t::ANALOG) && in.isFamily(netlist_terminal_t::LOGIC)) if (out.isFamily(terminal_t::ANALOG) && in.isFamily(terminal_t::LOGIC))
{ {
netlist_logic_input_t &incast = dynamic_cast<netlist_logic_input_t &>(in); 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); devices::nld_a_to_d_proxy *proxy = palloc(devices::nld_a_to_d_proxy, &incast);
incast.set_proxy(proxy); incast.set_proxy(proxy);
pstring x = pstring::sprintf("proxy_ad_%s_%d", in.name().cstr(), m_proxy_cnt); pstring x = pstring::sprintf("proxy_ad_%s_%d", in.name().cstr(), m_proxy_cnt);
@ -492,7 +492,7 @@ void netlist_setup_t::connect_input_output(netlist_core_terminal_t &in, netlist_
out.net().register_con(proxy->m_I); out.net().register_con(proxy->m_I);
} }
else if (out.isFamily(netlist_terminal_t::LOGIC) && in.isFamily(netlist_terminal_t::ANALOG)) else if (out.isFamily(terminal_t::LOGIC) && in.isFamily(terminal_t::ANALOG))
{ {
devices::nld_base_proxy *proxy = get_d_a_proxy(out); devices::nld_base_proxy *proxy = get_d_a_proxy(out);
@ -509,15 +509,15 @@ void netlist_setup_t::connect_input_output(netlist_core_terminal_t &in, netlist_
} }
void netlist_setup_t::connect_terminal_input(netlist_terminal_t &term, netlist_core_terminal_t &inp) void netlist_setup_t::connect_terminal_input(terminal_t &term, core_terminal_t &inp)
{ {
if (inp.isFamily(netlist_terminal_t::ANALOG)) if (inp.isFamily(terminal_t::ANALOG))
{ {
connect_terminals(inp, term); connect_terminals(inp, term);
} }
else if (inp.isFamily(netlist_terminal_t::LOGIC)) else if (inp.isFamily(terminal_t::LOGIC))
{ {
netlist_logic_input_t &incast = dynamic_cast<netlist_logic_input_t &>(inp); logic_input_t &incast = dynamic_cast<logic_input_t &>(inp);
NL_VERBOSE_OUT(("connect_terminal_input: connecting proxy\n")); NL_VERBOSE_OUT(("connect_terminal_input: connecting proxy\n"));
devices::nld_a_to_d_proxy *proxy = palloc(devices::nld_a_to_d_proxy, &incast); devices::nld_a_to_d_proxy *proxy = palloc(devices::nld_a_to_d_proxy, &incast);
incast.set_proxy(proxy); incast.set_proxy(proxy);
@ -541,9 +541,9 @@ void netlist_setup_t::connect_terminal_input(netlist_terminal_t &term, netlist_c
} }
} }
void netlist_setup_t::connect_terminal_output(netlist_terminal_t &in, netlist_core_terminal_t &out) void netlist_setup_t::connect_terminal_output(terminal_t &in, core_terminal_t &out)
{ {
if (out.isFamily(netlist_terminal_t::ANALOG)) if (out.isFamily(terminal_t::ANALOG))
{ {
NL_VERBOSE_OUT(("connect_terminal_output: %s %s\n", in.name().cstr(), out.name().cstr())); NL_VERBOSE_OUT(("connect_terminal_output: %s %s\n", in.name().cstr(), out.name().cstr()));
/* no proxy needed, just merge existing terminal net */ /* no proxy needed, just merge existing terminal net */
@ -552,7 +552,7 @@ void netlist_setup_t::connect_terminal_output(netlist_terminal_t &in, netlist_co
else else
out.net().register_con(in); out.net().register_con(in);
} }
else if (out.isFamily(netlist_terminal_t::LOGIC)) else if (out.isFamily(terminal_t::LOGIC))
{ {
NL_VERBOSE_OUT(("connect_terminal_output: connecting proxy\n")); NL_VERBOSE_OUT(("connect_terminal_output: connecting proxy\n"));
devices::nld_base_proxy *proxy = get_d_a_proxy(out); devices::nld_base_proxy *proxy = get_d_a_proxy(out);
@ -565,7 +565,7 @@ void netlist_setup_t::connect_terminal_output(netlist_terminal_t &in, netlist_co
} }
} }
void netlist_setup_t::connect_terminals(netlist_core_terminal_t &t1, netlist_core_terminal_t &t2) void netlist_setup_t::connect_terminals(core_terminal_t &t1, core_terminal_t &t2)
{ {
//nl_assert(in.isType(netlist_terminal_t::TERMINAL)); //nl_assert(in.isType(netlist_terminal_t::TERMINAL));
//nl_assert(out.isType(netlist_terminal_t::TERMINAL)); //nl_assert(out.isType(netlist_terminal_t::TERMINAL));
@ -588,7 +588,7 @@ void netlist_setup_t::connect_terminals(netlist_core_terminal_t &t1, netlist_cor
else else
{ {
NL_VERBOSE_OUT(("adding net ...\n")); NL_VERBOSE_OUT(("adding net ...\n"));
netlist_analog_net_t *anet = palloc(netlist_analog_net_t); analog_net_t *anet = palloc(analog_net_t);
t1.set_net(*anet); t1.set_net(*anet);
//m_netlist.solver()->m_nets.add(anet); //m_netlist.solver()->m_nets.add(anet);
// FIXME: Nets should have a unique name // FIXME: Nets should have a unique name
@ -598,18 +598,18 @@ void netlist_setup_t::connect_terminals(netlist_core_terminal_t &t1, netlist_cor
} }
} }
static netlist_core_terminal_t &resolve_proxy(netlist_core_terminal_t &term) static core_terminal_t &resolve_proxy(core_terminal_t &term)
{ {
if (term.isFamily(netlist_core_terminal_t::LOGIC)) if (term.isFamily(core_terminal_t::LOGIC))
{ {
netlist_logic_t &out = dynamic_cast<netlist_logic_t &>(term); logic_t &out = dynamic_cast<logic_t &>(term);
if (out.has_proxy()) if (out.has_proxy())
return out.get_proxy()->proxy_term(); return out.get_proxy()->proxy_term();
} }
return term; return term;
} }
bool netlist_setup_t::connect_input_input(netlist_core_terminal_t &t1, netlist_core_terminal_t &t2) bool netlist_setup_t::connect_input_input(core_terminal_t &t1, core_terminal_t &t2)
{ {
bool ret = false; bool ret = false;
if (t1.has_net()) if (t1.has_net())
@ -620,7 +620,7 @@ bool netlist_setup_t::connect_input_input(netlist_core_terminal_t &t1, netlist_c
{ {
for (std::size_t i=0; i<t1.net().m_core_terms.size(); i++) for (std::size_t i=0; i<t1.net().m_core_terms.size(); i++)
{ {
if (t1.net().m_core_terms[i]->isType(netlist_core_terminal_t::TERMINAL) if (t1.net().m_core_terms[i]->isType(core_terminal_t::TERMINAL)
/*|| t1.net().m_core_terms[i]->isType(netlist_core_terminal_t::OUTPUT)*/) /*|| t1.net().m_core_terms[i]->isType(netlist_core_terminal_t::OUTPUT)*/)
{ {
ret = connect(t2, *t1.net().m_core_terms[i]); ret = connect(t2, *t1.net().m_core_terms[i]);
@ -638,7 +638,7 @@ bool netlist_setup_t::connect_input_input(netlist_core_terminal_t &t1, netlist_c
{ {
for (std::size_t i=0; i<t2.net().m_core_terms.size(); i++) for (std::size_t i=0; i<t2.net().m_core_terms.size(); i++)
{ {
if (t2.net().m_core_terms[i]->isType(netlist_core_terminal_t::TERMINAL) if (t2.net().m_core_terms[i]->isType(core_terminal_t::TERMINAL)
/*|| t2.net().m_core_terms[i]->isType(netlist_core_terminal_t::OUTPUT)*/) /*|| t2.net().m_core_terms[i]->isType(netlist_core_terminal_t::OUTPUT)*/)
{ {
ret = connect(t1, *t2.net().m_core_terms[i]); ret = connect(t1, *t2.net().m_core_terms[i]);
@ -653,46 +653,46 @@ bool netlist_setup_t::connect_input_input(netlist_core_terminal_t &t1, netlist_c
bool netlist_setup_t::connect(netlist_core_terminal_t &t1_in, netlist_core_terminal_t &t2_in) bool netlist_setup_t::connect(core_terminal_t &t1_in, core_terminal_t &t2_in)
{ {
NL_VERBOSE_OUT(("Connecting %s to %s\n", t1_in.name().cstr(), t2_in.name().cstr())); NL_VERBOSE_OUT(("Connecting %s to %s\n", t1_in.name().cstr(), t2_in.name().cstr()));
netlist_core_terminal_t &t1 = resolve_proxy(t1_in); core_terminal_t &t1 = resolve_proxy(t1_in);
netlist_core_terminal_t &t2 = resolve_proxy(t2_in); core_terminal_t &t2 = resolve_proxy(t2_in);
bool ret = true; bool ret = true;
if (t1.isType(netlist_core_terminal_t::OUTPUT) && t2.isType(netlist_core_terminal_t::INPUT)) if (t1.isType(core_terminal_t::OUTPUT) && t2.isType(core_terminal_t::INPUT))
{ {
if (t2.has_net() && t2.net().isRailNet()) if (t2.has_net() && t2.net().isRailNet())
netlist().error("Input %s already connected\n", t2.name().cstr()); netlist().error("Input %s already connected\n", t2.name().cstr());
connect_input_output(t2, t1); connect_input_output(t2, t1);
} }
else if (t1.isType(netlist_core_terminal_t::INPUT) && t2.isType(netlist_core_terminal_t::OUTPUT)) else if (t1.isType(core_terminal_t::INPUT) && t2.isType(core_terminal_t::OUTPUT))
{ {
if (t1.has_net() && t1.net().isRailNet()) if (t1.has_net() && t1.net().isRailNet())
netlist().error("Input %s already connected\n", t1.name().cstr()); netlist().error("Input %s already connected\n", t1.name().cstr());
connect_input_output(t1, t2); connect_input_output(t1, t2);
} }
else if (t1.isType(netlist_core_terminal_t::OUTPUT) && t2.isType(netlist_core_terminal_t::TERMINAL)) else if (t1.isType(core_terminal_t::OUTPUT) && t2.isType(core_terminal_t::TERMINAL))
{ {
connect_terminal_output(dynamic_cast<netlist_terminal_t &>(t2), t1); connect_terminal_output(dynamic_cast<terminal_t &>(t2), t1);
} }
else if (t1.isType(netlist_core_terminal_t::TERMINAL) && t2.isType(netlist_core_terminal_t::OUTPUT)) else if (t1.isType(core_terminal_t::TERMINAL) && t2.isType(core_terminal_t::OUTPUT))
{ {
connect_terminal_output(dynamic_cast<netlist_terminal_t &>(t1), t2); connect_terminal_output(dynamic_cast<terminal_t &>(t1), t2);
} }
else if (t1.isType(netlist_core_terminal_t::INPUT) && t2.isType(netlist_core_terminal_t::TERMINAL)) else if (t1.isType(core_terminal_t::INPUT) && t2.isType(core_terminal_t::TERMINAL))
{ {
connect_terminal_input(dynamic_cast<netlist_terminal_t &>(t2), t1); connect_terminal_input(dynamic_cast<terminal_t &>(t2), t1);
} }
else if (t1.isType(netlist_core_terminal_t::TERMINAL) && t2.isType(netlist_core_terminal_t::INPUT)) else if (t1.isType(core_terminal_t::TERMINAL) && t2.isType(core_terminal_t::INPUT))
{ {
connect_terminal_input(dynamic_cast<netlist_terminal_t &>(t1), t2); connect_terminal_input(dynamic_cast<terminal_t &>(t1), t2);
} }
else if (t1.isType(netlist_core_terminal_t::TERMINAL) && t2.isType(netlist_core_terminal_t::TERMINAL)) else if (t1.isType(core_terminal_t::TERMINAL) && t2.isType(core_terminal_t::TERMINAL))
{ {
connect_terminals(dynamic_cast<netlist_terminal_t &>(t1), dynamic_cast<netlist_terminal_t &>(t2)); connect_terminals(dynamic_cast<terminal_t &>(t1), dynamic_cast<terminal_t &>(t2));
} }
else if (t1.isType(netlist_core_terminal_t::INPUT) && t2.isType(netlist_core_terminal_t::INPUT)) else if (t1.isType(core_terminal_t::INPUT) && t2.isType(core_terminal_t::INPUT))
{ {
ret = connect_input_input(t1, t2); ret = connect_input_input(t1, t2);
} }
@ -720,8 +720,8 @@ void netlist_setup_t::resolve_inputs()
{ {
const pstring t1s = m_links[li].e1; const pstring t1s = m_links[li].e1;
const pstring t2s = m_links[li].e2; const pstring t2s = m_links[li].e2;
netlist_core_terminal_t *t1 = find_terminal(t1s); core_terminal_t *t1 = find_terminal(t1s);
netlist_core_terminal_t *t2 = find_terminal(t2s); core_terminal_t *t2 = find_terminal(t2s);
if (connect(*t1, *t2)) if (connect(*t1, *t2))
{ {
@ -746,7 +746,7 @@ void netlist_setup_t::resolve_inputs()
// delete empty nets ... and save m_list ... // delete empty nets ... and save m_list ...
netlist_net_t::list_t todelete; net_t::list_t todelete;
for (std::size_t i = 0; i<netlist().m_nets.size(); i++) for (std::size_t i = 0; i<netlist().m_nets.size(); i++)
{ {
@ -822,7 +822,7 @@ void netlist_setup_t::start_devices()
{ {
NL_VERBOSE_OUT(("%d: <%s>\n",i, ll[i].cstr())); NL_VERBOSE_OUT(("%d: <%s>\n",i, ll[i].cstr()));
NL_VERBOSE_OUT(("%d: <%s>\n",i, ll[i].cstr())); NL_VERBOSE_OUT(("%d: <%s>\n",i, ll[i].cstr()));
netlist_device_t *nc = factory().new_device_by_classname("nld_log"); device_t *nc = factory().new_device_by_classname("nld_log");
pstring name = "log_" + ll[i]; pstring name = "log_" + ll[i];
register_dev(nc, name); register_dev(nc, name);
register_link(name + ".I", ll[i]); register_link(name + ".I", ll[i]);

44
src/emu/netlist/nl_setup.h
View File

@ -76,7 +76,7 @@ namespace netlist
{ {
// Forward definition so we keep nl_factory.h out of the public // Forward definition so we keep nl_factory.h out of the public
class netlist_factory_list_t; class factory_list_t;
class netlist_setup_t class netlist_setup_t
@ -129,21 +129,21 @@ public:
typedef pnamedlist_t<link_t> tagmap_nstring_t; typedef pnamedlist_t<link_t> tagmap_nstring_t;
typedef pnamedlist_t<netlist_param_t *> tagmap_param_t; typedef pnamedlist_t<netlist_param_t *> tagmap_param_t;
typedef pnamedlist_t<netlist_core_terminal_t *> tagmap_terminal_t; typedef pnamedlist_t<core_terminal_t *> tagmap_terminal_t;
typedef plist_t<link_t> tagmap_link_t; typedef plist_t<link_t> tagmap_link_t;
netlist_setup_t(netlist_base_t *netlist); netlist_setup_t(netlist_t *netlist);
~netlist_setup_t(); ~netlist_setup_t();
void init(); void init();
netlist_base_t &netlist() { return *m_netlist; } netlist_t &netlist() { return *m_netlist; }
const netlist_base_t &netlist() const { return *m_netlist; } const netlist_t &netlist() const { return *m_netlist; }
pstring build_fqn(const pstring &obj_name) const; pstring build_fqn(const pstring &obj_name) const;
netlist_device_t *register_dev(netlist_device_t *dev, const pstring &name); device_t *register_dev(device_t *dev, const pstring &name);
netlist_device_t *register_dev(const pstring &classname, const pstring &name); device_t *register_dev(const pstring &classname, const pstring &name);
void remove_dev(const pstring &name); void remove_dev(const pstring &name);
void register_model(const pstring &model); void register_model(const pstring &model);
@ -157,11 +157,11 @@ public:
void register_frontier(const pstring attach, const double r_IN, const double r_OUT); void register_frontier(const pstring attach, const double r_IN, const double r_OUT);
void remove_connections(const pstring attach); void remove_connections(const pstring attach);
void register_object(netlist_device_t &dev, const pstring &name, netlist_object_t &obj); void register_object(device_t &dev, const pstring &name, object_t &obj);
bool connect(netlist_core_terminal_t &t1, netlist_core_terminal_t &t2); bool connect(core_terminal_t &t1, core_terminal_t &t2);
netlist_core_terminal_t *find_terminal(const pstring &outname_in, bool required = true); core_terminal_t *find_terminal(const pstring &outname_in, bool required = true);
netlist_core_terminal_t *find_terminal(const pstring &outname_in, netlist_object_t::type_t atype, bool required = true); core_terminal_t *find_terminal(const pstring &outname_in, object_t::type_t atype, bool required = true);
netlist_param_t *find_param(const pstring &param_in, bool required = true); netlist_param_t *find_param(const pstring &param_in, bool required = true);
@ -181,8 +181,8 @@ public:
void register_source(source_t *src) { m_sources.add(src); } void register_source(source_t *src) { m_sources.add(src); }
netlist_factory_list_t &factory() { return *m_factory; } factory_list_t &factory() { return *m_factory; }
const netlist_factory_list_t &factory() const { return *m_factory; } const factory_list_t &factory() const { return *m_factory; }
/* not ideal, but needed for save_state */ /* not ideal, but needed for save_state */
tagmap_terminal_t m_terminals; tagmap_terminal_t m_terminals;
@ -193,14 +193,14 @@ protected:
private: private:
netlist_base_t *m_netlist; netlist_t *m_netlist;
tagmap_nstring_t m_alias; tagmap_nstring_t m_alias;
tagmap_param_t m_params; tagmap_param_t m_params;
tagmap_link_t m_links; tagmap_link_t m_links;
tagmap_nstring_t m_params_temp; tagmap_nstring_t m_params_temp;
netlist_factory_list_t *m_factory; factory_list_t *m_factory;
plist_t<pstring> m_models; plist_t<pstring> m_models;
@ -210,17 +210,17 @@ private:
source_t::list_t m_sources; source_t::list_t m_sources;
void connect_terminals(netlist_core_terminal_t &in, netlist_core_terminal_t &out); void connect_terminals(core_terminal_t &in, core_terminal_t &out);
void connect_input_output(netlist_core_terminal_t &in, netlist_core_terminal_t &out); void connect_input_output(core_terminal_t &in, core_terminal_t &out);
void connect_terminal_output(netlist_terminal_t &in, netlist_core_terminal_t &out); void connect_terminal_output(terminal_t &in, core_terminal_t &out);
void connect_terminal_input(netlist_terminal_t &term, netlist_core_terminal_t &inp); void connect_terminal_input(terminal_t &term, core_terminal_t &inp);
bool connect_input_input(netlist_core_terminal_t &t1, netlist_core_terminal_t &t2); bool connect_input_input(core_terminal_t &t1, core_terminal_t &t2);
// helpers // helpers
pstring objtype_as_astr(netlist_object_t &in) const; pstring objtype_as_astr(object_t &in) const;
const pstring resolve_alias(const pstring &name) const; const pstring resolve_alias(const pstring &name) const;
devices::nld_base_proxy *get_d_a_proxy(netlist_core_terminal_t &out); devices::nld_base_proxy *get_d_a_proxy(core_terminal_t &out);
template <class T> template <class T>
void remove_start_with(T &hm, pstring &sw) void remove_start_with(T &hm, pstring &sw)

10
src/tools/nltool.c
View File

@ -166,12 +166,12 @@ pstring filetobuf(pstring fname)
} }
} }
class netlist_tool_t : public netlist::netlist_base_t class netlist_tool_t : public netlist::netlist_t
{ {
public: public:
netlist_tool_t() netlist_tool_t()
: netlist::netlist_base_t(), m_logs(""), m_verbose(false), m_setup(NULL) : netlist::netlist_t(), m_logs(""), m_verbose(false), m_setup(NULL)
{ {
} }
@ -290,7 +290,7 @@ static void listdevices()
{ {
netlist_tool_t nt; netlist_tool_t nt;
nt.init(); nt.init();
const netlist::netlist_factory_list_t::list_t &list = nt.setup().factory().list(); const netlist::factory_list_t::list_t &list = nt.setup().factory().list();
nt.setup().register_source(palloc(netlist::netlist_source_proc_t, "dummy", &netlist_dummy)); nt.setup().register_source(palloc(netlist::netlist_source_proc_t, "dummy", &netlist_dummy));
nt.setup().include("dummy"); nt.setup().include("dummy");
@ -304,8 +304,8 @@ static void listdevices()
list[i]->name().cstr() ); list[i]->name().cstr() );
pstring terms(""); pstring terms("");
netlist::netlist_base_factory_t *f = list[i]; netlist::base_factory_t *f = list[i];
netlist::netlist_device_t *d = f->Create(); netlist::device_t *d = f->Create();
d->init(nt, pstring::sprintf("dummy%d", i)); d->init(nt, pstring::sprintf("dummy%d", i));
d->start_dev(); d->start_dev();