Sprinter/mame
2
0
Fork 0
mirror of https://github.com/holub/mame synced 2025-04-19 23:12:11 +03:00
Code Issues Actions 6 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++)
{
netlist::netlist_net_t *n = netlist().m_nets[i];
if (n->isFamily(netlist::netlist_object_t::LOGIC))
netlist::net_t *n = netlist().m_nets[i];
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
{
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_t : public netlist::netlist_base_t
class netlist_mame_t : public netlist::netlist_t
{
public:
netlist_mame_t(netlist_mame_device_t &parent)
: netlist::netlist_base_t(),
: netlist::netlist_t(),
m_parent(parent)
{}
virtual ~netlist_mame_t() { };
@ -506,11 +506,11 @@ private:
// netdev_callback
// ----------------------------------------------------------------------------------------
class NETLIB_NAME(analog_callback) : public netlist::netlist_device_t
class NETLIB_NAME(analog_callback) : public netlist::device_t
{
public:
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()
{
@ -545,7 +545,7 @@ public:
}
private:
netlist::netlist_analog_input_t m_in;
netlist::analog_input_t m_in;
netlist_analog_output_delegate m_callback;
netlist_mame_cpu_device_t *m_cpu_device;
nl_double m_last;
@ -555,11 +555,11 @@ private:
// sound_out
// ----------------------------------------------------------------------------------------
class NETLIB_NAME(sound_out) : public netlist::netlist_device_t
class NETLIB_NAME(sound_out) : public netlist::device_t
{
public:
NETLIB_NAME(sound_out)()
: netlist::netlist_device_t() { }
: netlist::device_t() { }
static const int BUFSIZE = 2048;
@ -611,7 +611,7 @@ public:
netlist_time m_sample;
private:
netlist::netlist_analog_input_t m_in;
netlist::analog_input_t m_in;
stream_sample_t m_cur;
int m_last_pos;
netlist_time m_last_buffer;
@ -621,11 +621,11 @@ private:
// sound_in
// ----------------------------------------------------------------------------------------
class NETLIB_NAME(sound_in) : public netlist::netlist_device_t
class NETLIB_NAME(sound_in) : public netlist::device_t
{
public:
NETLIB_NAME(sound_in)()
: netlist::netlist_device_t() { }
: netlist::device_t() { }
static const int MAX_INPUT_CHANNELS = 10;
@ -697,8 +697,8 @@ public:
netlist_time m_inc;
private:
netlist::netlist_logic_input_t m_feedback;
netlist::netlist_logic_output_t m_Q;
netlist::logic_input_t m_feedback;
netlist::logic_output_t m_Q;
int m_pos;
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)
: netlist_device_t(afamily)
: device_t(afamily)
, m_qtype(BJT_NPN) { }
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
class NETLIB_NAME(Q) : public netlist_device_t
class NETLIB_NAME(Q) : public device_t
{
public:
enum q_type {
@ -96,9 +96,9 @@ class NETLIB_NAME(QBJT_switch) : public NETLIB_NAME(QBJT)
public:
ATTR_COLD NETLIB_NAME(QBJT_switch)()
: NETLIB_NAME(QBJT)(BJT_SWITCH),
m_RB(netlist_object_t::ANALOG),
m_RC(netlist_object_t::ANALOG),
m_BC_dummy(netlist_object_t::ANALOG),
m_RB(object_t::ANALOG),
m_RC(object_t::ANALOG),
m_BC_dummy(object_t::ANALOG),
m_gB(NETLIST_GMIN_DEFAULT), m_gC(NETLIST_GMIN_DEFAULT), m_V(0.0), m_state_on(0) { }
@ -136,9 +136,9 @@ class NETLIB_NAME(QBJT_EB) : public NETLIB_NAME(QBJT)
public:
ATTR_COLD NETLIB_NAME(QBJT_EB)()
: NETLIB_NAME(QBJT)(BJT_EB),
m_D_CB(netlist_object_t::ANALOG),
m_D_EB(netlist_object_t::ANALOG),
m_D_EC(netlist_object_t::ANALOG),
m_D_CB(object_t::ANALOG),
m_D_EB(object_t::ANALOG),
m_D_EC(object_t::ANALOG),
m_alpha_f(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:
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)
: netlist_device_t(afamily), m_gfac(1.0) { }
: device_t(afamily), m_gfac(1.0) { }
protected:
virtual void start();
@ -65,14 +65,14 @@ protected:
ATTR_COLD void start_internal(const nl_double def_RI);
netlist_terminal_t m_OP;
netlist_terminal_t m_ON;
terminal_t m_OP;
terminal_t m_ON;
netlist_terminal_t m_IP;
netlist_terminal_t m_IN;
terminal_t m_IP;
terminal_t m_IN;
netlist_terminal_t m_OP1;
netlist_terminal_t m_ON1;
terminal_t m_OP1;
terminal_t m_ON1;
netlist_param_double_t m_G;
netlist_param_double_t m_RI;
@ -163,8 +163,8 @@ protected:
virtual void update_param();
//ATTR_HOT void update();
netlist_terminal_t m_OP2;
netlist_terminal_t m_ON2;
terminal_t m_OP2;
terminal_t m_ON2;
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 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(); }
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);
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();
@ -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++)
{
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 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>
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())
{
@ -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>
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())
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)
{
netlist_analog_net_t *net = m_nets[0];
analog_net_t *net = m_nets[0];
this->build_LE_A();
this->build_LE_RHS(m_RHS);
//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 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);
protected:
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>
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);
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 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);
protected:
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>
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);
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 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);
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>
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);
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();
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 ;
sq += nv * nv;
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()
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_net_other.add(net_other);
@ -82,7 +82,7 @@ ATTR_COLD netlist_matrix_solver_t::~netlist_matrix_solver_t()
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"));
@ -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"));
netlist_analog_net_t *net = nets[k];
analog_net_t *net = nets[k];
net->m_solver = this;
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()));
switch (p->type())
{
case netlist_terminal_t::TERMINAL:
case terminal_t::TERMINAL:
switch (p->netdev().family())
{
case netlist_device_t::CAPACITOR:
case device_t::CAPACITOR:
if (!m_step_devices.contains(&p->netdev()))
m_step_devices.add(&p->netdev());
break;
case netlist_device_t::BJT_EB:
case netlist_device_t::DIODE:
case device_t::BJT_EB:
case device_t::DIODE:
//case netlist_device_t::VCVS:
case netlist_device_t::BJT_SWITCH:
case device_t::BJT_SWITCH:
NL_VERBOSE_OUT(("found BJT/Diode\n"));
if (!m_dynamic_devices.contains(&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;
}
{
netlist_terminal_t *pterm = dynamic_cast<netlist_terminal_t *>(p);
terminal_t *pterm = dynamic_cast<terminal_t *>(p);
add_term(k, pterm);
}
NL_VERBOSE_OUT(("Added terminal\n"));
break;
case netlist_terminal_t::INPUT:
case terminal_t::INPUT:
{
netlist_analog_output_t *net_proxy_output = NULL;
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
// ----------------------------------------------------------------------------------------
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++)
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()
{
netlist_analog_net_t::list_t groups[256];
analog_net_t::list_t groups[256];
int cur_group = -1;
const int gs_threshold = m_gs_threshold.Value();
const bool use_specific = true;
@ -467,7 +467,7 @@ ATTR_COLD void NETLIB_NAME(solver)::post_start()
if (!netlist().m_nets[i]->isRailNet())
{
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))
{
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++)
{
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++)
{
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());
}
}

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

@ -68,11 +68,11 @@ class terms_t
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 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 nl_double *gt() { return m_gt.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_nz; /* all non zero for multiplication */
private:
plist_t<netlist_terminal_t *> m_term;
plist_t<terminal_t *> m_term;
plist_t<int> m_net_other;
plist_t<nl_double> m_go;
plist_t<nl_double> m_gt;
@ -94,11 +94,11 @@ private:
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:
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
{
@ -109,7 +109,7 @@ public:
ATTR_COLD netlist_matrix_solver_t(const eSolverType type, const netlist_solver_parameters_t *params);
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>
void solve_base(C *p);
@ -130,22 +130,22 @@ public:
virtual void start();
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() {};
inline eSolverType type() const { return m_type; }
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();
// should return next time step
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;
int m_stat_calculations;
@ -162,8 +162,8 @@ private:
dev_list_t m_step_devices;
dev_list_t m_dynamic_devices;
netlist_logic_input_t m_fb_sync;
netlist_logic_output_t m_Q_sync;
logic_input_t m_fb_sync;
logic_output_t m_Q_sync;
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:
NETLIB_NAME(solver)()
: netlist_device_t() { }
: device_t() { }
virtual ~NETLIB_NAME(solver)();
@ -193,8 +193,8 @@ protected:
ATTR_HOT void reset();
ATTR_HOT void update_param();
netlist_logic_input_t m_fb_step;
netlist_logic_output_t m_Q_step;
logic_input_t m_fb_step;
logic_output_t m_Q_step;
netlist_param_double_t m_freq;
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;
}
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_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)
: netlist_device_t(afamily)
: device_t(afamily)
{
m_P.m_otherterm = &m_N;
m_N.m_otherterm = &m_P;
}
ATTR_COLD NETLIB_NAME(twoterm)::NETLIB_NAME(twoterm)()
: netlist_device_t(TWOTERM)
: device_t(TWOTERM)
{
m_P.m_otherterm = &m_N;
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
// ----------------------------------------------------------------------------------------
class NETLIB_NAME(twoterm) : public netlist_device_t
class NETLIB_NAME(twoterm) : public device_t
{
public:
ATTR_COLD NETLIB_NAME(twoterm)(const family_t afamily);
ATTR_COLD NETLIB_NAME(twoterm)();
netlist_terminal_t m_P;
netlist_terminal_t m_N;
terminal_t m_P;
terminal_t m_N;
virtual NETLIB_UPDATE_TERMINALSI()
{
@ -256,7 +256,7 @@ public:
/* 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:
nl_double m_Vd;

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

@ -43,7 +43,7 @@ NETLIST_END()
NETLIB_NAMESPACE_DEVICES_START()
void initialize_factory(netlist_factory_list_t &factory)
void initialize_factory(factory_list_t &factory)
{
ENTRY(R, RES, "R")
ENTRY(POT, POT, "R")
@ -150,7 +150,7 @@ NETLIB_NAMESPACE_DEVICES_END()
namespace netlist
{
void initialize_factory(netlist_factory_list_t &factory)
void initialize_factory(factory_list_t &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);
namespace netlist {
void initialize_factory(netlist::netlist_factory_list_t &factory);
void initialize_factory(netlist::factory_list_t &factory);
}
#endif

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

@ -60,7 +60,7 @@ NETLIB_START(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;
}

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

@ -47,18 +47,18 @@ NETLIB_SUBDEVICE(4020_sub,
NETLIB_LOGIC_FAMILY(CD4000)
ATTR_HOT void update_outputs(const UINT16 cnt);
netlist_logic_input_t m_IP;
logic_input_t m_IP;
UINT16 m_cnt;
netlist_logic_output_t m_Q[14];
logic_output_t m_Q[14];
);
NETLIB_DEVICE(4020,
NETLIB_LOGIC_FAMILY(CD4000)
NETLIB_NAME(4020_sub) sub;
NETLIB_NAME(vdd_vss) m_supply;
netlist_logic_input_t m_RESET;
logic_input_t m_RESET;
);
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)
public:
netlist_analog_input_t m_control;
analog_input_t m_control;
NETLIB_NAME(R) m_R;
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)
{
m_clk.set_state(netlist_logic_t::STATE_INP_HL);
m_clk.set_state(logic_t::STATE_INP_HL);
m_Q.initial(0);
m_QQ.initial(1);

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

@ -77,10 +77,10 @@
NETLIB_NAMESPACE_DEVICES_START()
NETLIB_SUBDEVICE(74107Asub,
netlist_logic_input_t m_clk;
logic_input_t m_clk;
netlist_logic_output_t m_Q;
netlist_logic_output_t m_QQ;
logic_output_t m_Q;
logic_output_t m_QQ;
netlist_sig_t m_Q1;
netlist_sig_t m_Q2;
@ -94,9 +94,9 @@ NETLIB_DEVICE(74107A,
public:
NETLIB_NAME(74107Asub) sub;
netlist_logic_input_t m_J;
netlist_logic_input_t m_K;
netlist_logic_input_t m_clrQ;
logic_input_t m_J;
logic_input_t m_K;
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_RN;
netlist_logic_output_t m_RP_Q;
netlist_logic_output_t m_RN_Q;
logic_output_t m_RP_Q;
logic_output_t m_RN_Q;
netlist_logic_input_t m_A;
netlist_logic_input_t m_B;
netlist_logic_input_t m_CLRQ;
netlist_logic_output_t m_Q;
netlist_logic_output_t m_QQ;
logic_input_t m_A;
logic_input_t m_B;
logic_input_t m_CLRQ;
logic_output_t m_Q;
logic_output_t m_QQ;
netlist_analog_input_t m_CV;
analog_input_t m_CV;
netlist_sig_t m_last_trig;
UINT8 m_state;

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

@ -63,10 +63,10 @@
NETLIB_NAMESPACE_DEVICES_START()
NETLIB_SUBDEVICE(74153sub,
netlist_logic_input_t m_C[4];
netlist_logic_input_t m_G;
logic_input_t m_C[4];
logic_input_t m_G;
netlist_logic_output_t m_Y;
logic_output_t m_Y;
int m_chan;
);
@ -74,16 +74,16 @@ NETLIB_SUBDEVICE(74153sub,
NETLIB_DEVICE(74153,
public:
NETLIB_NAME(74153sub) m_sub;
netlist_logic_input_t m_A;
netlist_logic_input_t m_B;
logic_input_t m_A;
logic_input_t m_B;
);
NETLIB_DEVICE(74153_dip,
NETLIB_NAME(74153sub) m_1;
NETLIB_NAME(74153sub) m_2;
netlist_logic_input_t m_A;
netlist_logic_input_t m_B;
logic_input_t m_A;
logic_input_t m_B;
);
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)
{
m_CLK.set_state(netlist_logic_t::STATE_INP_LH);
m_CLK.set_state(logic_t::STATE_INP_LH);
m_clrq = 0;
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,
netlist_logic_input_t m_CLK;
netlist_logic_output_t m_Q[4];
netlist_logic_output_t m_QQ[4];
logic_input_t m_CLK;
logic_output_t m_Q[4];
logic_output_t m_QQ[4];
netlist_sig_t m_clrq;
UINT8 m_data;
@ -58,8 +58,8 @@ NETLIB_SUBDEVICE(74175_sub,
NETLIB_DEVICE(74175,
NETLIB_NAME(74175_sub) m_sub;
netlist_logic_input_t m_D[4];
netlist_logic_input_t m_CLRQ;
logic_input_t m_D[4];
logic_input_t m_CLRQ;
);
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();
NETLIB_NAME(9316_subABCD) m_ABCD;
netlist_logic_input_t m_CLEAR;
netlist_logic_input_t m_LOADQ;
netlist_logic_input_t m_CU;
netlist_logic_input_t m_CD;
logic_input_t m_CLEAR;
logic_input_t m_LOADQ;
logic_input_t m_CU;
logic_input_t m_CD;
INT8 m_cnt;
UINT8 m_last_CU;
UINT8 m_last_CD;
netlist_logic_output_t m_Q[4];
netlist_logic_output_t m_BORROWQ;
netlist_logic_output_t m_CARRYQ;
logic_output_t m_Q[4];
logic_output_t m_BORROWQ;
logic_output_t m_CARRYQ;
);
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,
ATTR_HOT void update_outputs();
netlist_logic_input_t m_A;
netlist_logic_input_t m_B;
netlist_logic_input_t m_C;
netlist_logic_input_t m_D;
netlist_logic_input_t m_CLEAR;
netlist_logic_input_t m_LOADQ;
netlist_logic_input_t m_CU;
netlist_logic_input_t m_CD;
logic_input_t m_A;
logic_input_t m_B;
logic_input_t m_C;
logic_input_t m_D;
logic_input_t m_CLEAR;
logic_input_t m_LOADQ;
logic_input_t m_CU;
logic_input_t m_CD;
INT8 m_cnt;
UINT8 m_last_CU;
UINT8 m_last_CD;
netlist_logic_output_t m_Q[4];
netlist_logic_output_t m_BORROWQ;
netlist_logic_output_t m_CARRYQ;
logic_output_t m_Q[4];
logic_output_t m_BORROWQ;
logic_output_t m_CARRYQ;
);
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);
static const UINT8 tab7448[16][7];
netlist_logic_input_t m_A;
netlist_logic_input_t m_B;
netlist_logic_input_t m_C;
netlist_logic_input_t m_D;
netlist_logic_input_t m_RBIQ;
logic_input_t m_A;
logic_input_t m_B;
logic_input_t m_C;
logic_input_t m_D;
logic_input_t m_RBIQ;
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:
NETLIB_NAME(7448_sub) sub;
netlist_logic_input_t m_LTQ;
netlist_logic_input_t m_BIQ;
logic_input_t m_LTQ;
logic_input_t m_BIQ;
);
#endif

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

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

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

@ -85,7 +85,7 @@ NETLIB_START(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;
/* 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_SUBDEVICE(7474sub,
netlist_logic_input_t m_CLK;
logic_input_t m_CLK;
INT8 m_nextD;
netlist_logic_output_t m_Q;
netlist_logic_output_t m_QQ;
logic_output_t m_Q;
logic_output_t m_QQ;
ATTR_HOT inline void newstate(const UINT8 stateQ, const UINT8 stateQQ);
);
@ -70,9 +70,9 @@ NETLIB_DEVICE(7474,
public:
NETLIB_NAME(7474sub) sub;
netlist_logic_input_t m_D;
netlist_logic_input_t m_CLRQ;
netlist_logic_input_t m_PREQ;
logic_input_t m_D;
logic_input_t m_CLRQ;
logic_input_t m_PREQ;
);
NETLIB_DEVICE(7474_dip,

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

@ -47,23 +47,23 @@
NETLIB_NAMESPACE_DEVICES_START()
NETLIB_DEVICE(7483,
netlist_logic_input_t m_C0;
netlist_logic_input_t m_A1;
netlist_logic_input_t m_A2;
netlist_logic_input_t m_A3;
netlist_logic_input_t m_A4;
netlist_logic_input_t m_B1;
netlist_logic_input_t m_B2;
netlist_logic_input_t m_B3;
netlist_logic_input_t m_B4;
logic_input_t m_C0;
logic_input_t m_A1;
logic_input_t m_A2;
logic_input_t m_A3;
logic_input_t m_A4;
logic_input_t m_B1;
logic_input_t m_B2;
logic_input_t m_B3;
logic_input_t m_B4;
UINT8 m_lastr;
netlist_logic_output_t m_S1;
netlist_logic_output_t m_S2;
netlist_logic_output_t m_S3;
netlist_logic_output_t m_S4;
netlist_logic_output_t m_C4;
logic_output_t m_S1;
logic_output_t m_S2;
logic_output_t m_S3;
logic_output_t m_S4;
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,
ATTR_HOT void update_outputs();
netlist_logic_input_t m_R1;
netlist_logic_input_t m_R2;
netlist_logic_input_t m_R91;
netlist_logic_input_t m_R92;
netlist_logic_input_t m_A;
netlist_logic_input_t m_B;
logic_input_t m_R1;
logic_input_t m_R2;
logic_input_t m_R91;
logic_input_t m_R92;
logic_input_t m_A;
logic_input_t m_B;
UINT8 m_cnt;
UINT8 m_last_A;
UINT8 m_last_B;
netlist_logic_output_t m_Q[4];
logic_output_t m_Q[4];
);
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_state = 0;
m_I.set_state(netlist_logic_t::STATE_INP_HL);
m_I.set_state(logic_t::STATE_INP_HL);
}
NETLIB_UPDATE(7493ff)

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

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

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

@ -38,8 +38,8 @@
NETLIB_NAMESPACE_DEVICES_START()
NETLIB_SUBDEVICE(SN74LS629clk,
netlist_logic_input_t m_FB;
netlist_logic_output_t m_Y;
logic_input_t m_FB;
logic_output_t m_Y;
netlist_time m_inc;
netlist_sig_t m_enableq;
@ -52,9 +52,9 @@ public:
NETLIB_NAME(R_base) m_R_FC;
NETLIB_NAME(R_base) m_R_RNG;
netlist_logic_input_t m_ENQ;
netlist_analog_input_t m_RNG;
netlist_analog_input_t m_FC;
logic_input_t m_ENQ;
analog_input_t m_RNG;
analog_input_t m_FC;
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,
netlist_logic_input_t m_A[8];
netlist_logic_input_t m_CE1Q;
netlist_logic_input_t m_CE2Q;
netlist_logic_input_t m_CE3Q;
netlist_logic_input_t m_WEQ;
netlist_logic_input_t m_DIN;
netlist_logic_output_t m_DOUTQ;
logic_input_t m_A[8];
logic_input_t m_CE1Q;
logic_input_t m_CE2Q;
logic_input_t m_CE3Q;
logic_input_t m_WEQ;
logic_input_t m_DIN;
logic_output_t m_DOUTQ;
//netlist_state_t<UINT8[256]> m_ram;
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)
{
m_CLK.set_state(netlist_logic_t::STATE_INP_LH);
m_CLK.set_state(logic_t::STATE_INP_LH);
m_cnt = 0;
m_loadq = 1;
m_ent = 1;

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

@ -65,10 +65,10 @@
NETLIB_NAMESPACE_DEVICES_START()
NETLIB_SUBDEVICE(9310_subABCD,
netlist_logic_input_t m_A;
netlist_logic_input_t m_B;
netlist_logic_input_t m_C;
netlist_logic_input_t m_D;
logic_input_t m_A;
logic_input_t m_B;
logic_input_t m_C;
logic_input_t m_D;
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(const UINT8 cnt);
netlist_logic_input_t m_CLK;
logic_input_t m_CLK;
UINT8 m_cnt;
NETLIB_NAME(9310_subABCD) *m_ABCD;
netlist_sig_t m_loadq;
netlist_sig_t m_ent;
netlist_logic_output_t m_QA;
netlist_logic_output_t m_QB;
netlist_logic_output_t m_QC;
netlist_logic_output_t m_QD;
netlist_logic_output_t m_RC;
logic_output_t m_QA;
logic_output_t m_QB;
logic_output_t m_QC;
logic_output_t m_QD;
logic_output_t m_RC;
);
NETLIB_DEVICE(9310,
NETLIB_NAME(9310_sub) sub;
NETLIB_NAME(9310_subABCD) subABCD;
netlist_logic_input_t m_ENP;
netlist_logic_input_t m_ENT;
netlist_logic_input_t m_CLRQ;
netlist_logic_input_t m_LOADQ;
logic_input_t m_ENP;
logic_input_t m_ENT;
logic_input_t m_CLRQ;
logic_input_t m_LOADQ;
);
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)
{
m_CLK.set_state(netlist_logic_t::STATE_INP_LH);
m_CLK.set_state(logic_t::STATE_INP_LH);
m_cnt = 0;
m_loadq = 1;
m_ent = 1;

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

@ -69,10 +69,10 @@
NETLIB_NAMESPACE_DEVICES_START()
NETLIB_SUBDEVICE(9316_subABCD,
netlist_logic_input_t m_A;
netlist_logic_input_t m_B;
netlist_logic_input_t m_C;
netlist_logic_input_t m_D;
logic_input_t m_A;
logic_input_t m_B;
logic_input_t m_C;
logic_input_t m_D;
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(const UINT8 cnt);
netlist_logic_input_t m_CLK;
logic_input_t m_CLK;
netlist_logic_output_t m_QA;
netlist_logic_output_t m_QB;
netlist_logic_output_t m_QC;
netlist_logic_output_t m_QD;
netlist_logic_output_t m_RC;
logic_output_t m_QA;
logic_output_t m_QB;
logic_output_t m_QC;
logic_output_t m_QD;
logic_output_t m_RC;
UINT8 m_cnt;
NETLIB_NAME(9316_subABCD) *m_ABCD;
@ -103,10 +103,10 @@ NETLIB_SUBDEVICE(9316_sub,
NETLIB_DEVICE(9316,
NETLIB_NAME(9316_sub) sub;
NETLIB_NAME(9316_subABCD) subABCD;
netlist_logic_input_t m_ENP;
netlist_logic_input_t m_ENT;
netlist_logic_input_t m_CLRQ;
netlist_logic_input_t m_LOADQ;
logic_input_t m_ENP;
logic_input_t m_ENT;
logic_input_t m_CLRQ;
logic_input_t m_LOADQ;
);
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()
class nld_vdd_vss : public netlist_device_t
class nld_vdd_vss : public device_t
{
public:
nld_vdd_vss ()
: netlist_device_t()
: device_t()
{ }
netlist_analog_input_t m_vdd;
netlist_analog_input_t m_vss;
analog_input_t m_vdd;
analog_input_t m_vss;
protected:
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,
netlist_logic_input_t m_S;
netlist_logic_input_t m_R;
logic_input_t m_S;
logic_input_t m_R;
netlist_logic_output_t m_Q;
netlist_logic_output_t m_QQ;
logic_output_t m_Q;
logic_output_t m_QQ;
);
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_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_NAME(log)();
netlist_analog_input_t m_I;
analog_input_t m_I;
protected:
void * m_file;
);
@ -39,13 +39,13 @@ protected:
NET_CONNECT(_name, I2, _I2)
NETLIB_DEVICE_DERIVED(logD, log,
netlist_analog_input_t m_I2;
analog_input_t m_I2;
);
#if 0
NETLIB_DEVICE(wav,
~NETLIB_NAME(wav)();
netlist_analog_input_t m_I;
analog_input_t m_I;
private:
// FIXME: rewrite sound/wavwrite.h to be an object ...
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_RDIS;
netlist_logic_input_t m_RESET;
netlist_analog_input_t m_THRES;
netlist_analog_input_t m_TRIG;
logic_input_t m_RESET;
analog_input_t m_THRES;
analog_input_t m_TRIG;
netlist_analog_output_t m_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>
class net_signal_t : public netlist_device_t
class net_signal_t : public device_t
{
public:
net_signal_t()
: netlist_device_t(), m_active(1)
: device_t(), m_active(1)
{
}
@ -109,8 +109,8 @@ public:
}
public:
netlist_logic_input_t m_I[_numdev];
netlist_logic_output_t m_Q[1];
logic_input_t m_I[_numdev];
logic_output_t m_Q[1];
INT32 m_active;
};

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

@ -81,12 +81,12 @@ public:
NETLIB_DEVICE_WITH_PARAMS(mainclock,
public:
netlist_logic_output_t m_Q;
logic_output_t m_Q;
netlist_param_double_t m_freq;
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,
netlist_logic_input_t m_feedback;
netlist_logic_output_t m_Q;
logic_input_t m_feedback;
logic_output_t m_Q;
netlist_param_double_t m_freq;
netlist_time m_inc;
@ -106,8 +106,8 @@ NETLIB_DEVICE_WITH_PARAMS(clock,
// -----------------------------------------------------------------------------
NETLIB_DEVICE_WITH_PARAMS(extclock,
netlist_logic_input_t m_feedback;
netlist_logic_output_t m_Q;
logic_input_t m_feedback;
logic_output_t m_Q;
netlist_param_double_t m_freq;
netlist_param_str_t m_pattern;
@ -124,7 +124,7 @@ NETLIB_DEVICE_WITH_PARAMS(extclock,
// -----------------------------------------------------------------------------
NETLIB_DEVICE_WITH_PARAMS(ttl_input,
netlist_logic_output_t m_Q;
logic_output_t m_Q;
netlist_param_logic_t m_IN;
);
@ -139,11 +139,11 @@ NETLIB_DEVICE_WITH_PARAMS(analog_input,
// nld_gnd
// -----------------------------------------------------------------------------
class NETLIB_NAME(gnd) : public netlist_device_t
class NETLIB_NAME(gnd) : public device_t
{
public:
NETLIB_NAME(gnd)()
: netlist_device_t(GND) { }
: device_t(GND) { }
virtual ~NETLIB_NAME(gnd)() {}
@ -172,11 +172,11 @@ private:
// nld_dummy_input
// -----------------------------------------------------------------------------
class NETLIB_NAME(dummy_input) : public netlist_device_t
class NETLIB_NAME(dummy_input) : public device_t
{
public:
NETLIB_NAME(dummy_input)()
: netlist_device_t(DUMMY) { }
: device_t(DUMMY) { }
virtual ~NETLIB_NAME(dummy_input)() {}
@ -196,7 +196,7 @@ protected:
}
private:
netlist_analog_input_t m_I;
analog_input_t m_I;
};
@ -204,11 +204,11 @@ private:
// nld_frontier
// -----------------------------------------------------------------------------
class NETLIB_NAME(frontier) : public netlist_device_t
class NETLIB_NAME(frontier) : public device_t
{
public:
NETLIB_NAME(frontier)()
: netlist_device_t(DUMMY) { }
: device_t(DUMMY) { }
virtual ~NETLIB_NAME(frontier)() {}
@ -244,7 +244,7 @@ protected:
private:
NETLIB_NAME(twoterm) m_RIN;
NETLIB_NAME(twoterm) m_ROUT;
netlist_analog_input_t m_I;
analog_input_t m_I;
netlist_analog_output_t m_Q;
netlist_param_double_t m_p_RIN;
@ -255,17 +255,17 @@ private:
// nld_res_sw
// -----------------------------------------------------------------------------
class NETLIB_NAME(res_sw) : public netlist_device_t
class NETLIB_NAME(res_sw) : public device_t
{
public:
NETLIB_NAME(res_sw)()
: netlist_device_t() { }
: device_t() { }
virtual ~NETLIB_NAME(res_sw)() {}
netlist_param_double_t m_RON;
netlist_param_double_t m_ROFF;
netlist_logic_input_t m_I;
logic_input_t m_I;
NETLIB_NAME(R) m_R;
protected:
@ -283,11 +283,11 @@ private:
// nld_base_proxy
// -----------------------------------------------------------------------------
class nld_base_proxy : public netlist_device_t
class nld_base_proxy : public device_t
{
public:
nld_base_proxy(netlist_logic_t *inout_proxied, netlist_core_terminal_t *proxy_inout)
: netlist_device_t()
nld_base_proxy(logic_t *inout_proxied, core_terminal_t *proxy_inout)
: device_t()
{
m_logic_family = inout_proxied->logic_family();
m_term_proxied = inout_proxied;
@ -296,20 +296,20 @@ public:
virtual ~nld_base_proxy() {}
netlist_logic_t &term_proxied() const { return *m_term_proxied; }
netlist_core_terminal_t &proxy_term() const { return *m_proxy_term; }
logic_t &term_proxied() const { return *m_term_proxied; }
core_terminal_t &proxy_term() const { return *m_proxy_term; }
protected:
virtual const netlist_logic_family_desc_t &logic_family() const
virtual const logic_family_desc_t &logic_family() const
{
return *m_logic_family;
}
private:
const netlist_logic_family_desc_t *m_logic_family;
netlist_logic_t *m_term_proxied;
netlist_core_terminal_t *m_proxy_term;
const logic_family_desc_t *m_logic_family;
logic_t *m_term_proxied;
core_terminal_t *m_proxy_term;
};
// -----------------------------------------------------------------------------
@ -319,15 +319,15 @@ private:
class nld_a_to_d_proxy : public nld_base_proxy
{
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)
{
}
virtual ~nld_a_to_d_proxy() {}
netlist_analog_input_t m_I;
netlist_logic_output_t m_Q;
analog_input_t m_I;
logic_output_t m_Q;
protected:
void start()
@ -363,10 +363,10 @@ class nld_base_d_to_a_proxy : public nld_base_proxy
public:
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:
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)
{
}
@ -376,7 +376,7 @@ protected:
register_input("I", m_I);
}
netlist_logic_input_t m_I;
logic_input_t m_I;
private:
};
@ -384,7 +384,7 @@ private:
class nld_d_to_a_proxy : public nld_base_d_to_a_proxy
{
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)
, m_RV(TWOTERM)
, 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
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);
m_outs[nstate] = val;
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++)
{
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_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>
class nld_truthtable_t : public netlist_device_t
class nld_truthtable_t : public device_t
{
public:
@ -107,7 +107,7 @@ public:
};
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 )
{
@ -118,7 +118,7 @@ public:
}
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;
}
@ -275,8 +275,8 @@ public:
}
}
netlist_logic_input_t m_I[m_NI];
netlist_logic_output_t m_Q[m_NO];
logic_input_t m_I[m_NI];
logic_output_t m_Q[m_NO];
private:
@ -288,13 +288,13 @@ private:
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)
public:
netlist_base_factory_truthtable_t(const pstring &name, const pstring &classname,
const pstring &def_param)
: netlist_base_factory_t(name, classname, def_param)
: base_factory_t(name, classname, def_param)
{}
pstring_list_t m_desc;
};
@ -309,10 +309,10 @@ public:
const pstring &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;
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);
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
nl_fatalerror::nl_fatalerror(const char *format, ...)
fatalerror_e::fatalerror_e(const char *format, ...)
{
va_list ap;
va_start(ap, format);
@ -34,7 +34,7 @@ nl_fatalerror::nl_fatalerror(const char *format, ...)
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);
}
@ -43,7 +43,7 @@ nl_fatalerror::nl_fatalerror(const char *format, va_list ap)
// 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:
netlist_logic_family_ttl_t()
@ -56,14 +56,14 @@ public:
m_R_low = 1.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);
}
};
//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:
netlist_logic_family_cd4000_t()
@ -76,22 +76,22 @@ public:
m_R_low = 1.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);
}
};
const netlist_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_TTL = netlist_logic_family_ttl_t();
const logic_family_desc_t &netlist_family_CD4000 = netlist_logic_family_cd4000_t();
// ----------------------------------------------------------------------------------------
// netlist_queue_t
// ----------------------------------------------------------------------------------------
netlist_queue_t::netlist_queue_t(netlist_base_t &nl)
: netlist_timed_queue<netlist_net_t *, netlist_time>(512)
, netlist_object_t(QUEUE, GENERIC)
queue_t::queue_t(netlist_t &nl)
: netlist_timed_queue<net_t *, netlist_time>(512)
, object_t(QUEUE, GENERIC)
, pstate_callback_t()
, m_qsize(0)
, m_times(512)
@ -100,7 +100,7 @@ netlist_queue_t::netlist_queue_t(netlist_base_t &nl)
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"));
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);
}
void netlist_queue_t::on_pre_save()
void queue_t::on_pre_save()
{
NL_VERBOSE_OUT(("on_pre_save\n"));
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();
NL_VERBOSE_OUT(("current time %f qsize %d\n", netlist().time().as_double(), m_qsize));
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(("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
// ----------------------------------------------------------------------------------------
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_family(afamily)
, 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_name = aname;
save_register();
}
ATTR_COLD const pstring &netlist_object_t::name() const
ATTR_COLD const pstring &object_t::name() const
{
if (m_name == "")
netlist().error("object not initialized");
@ -170,17 +170,17 @@ ATTR_COLD const pstring &netlist_object_t::name() const
// 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)
: netlist_object_t(atype, afamily)
: object_t(atype, afamily)
, 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)
{
netlist_object_t::init_object(dev.netlist(), aname);
object_t::init_object(dev.netlist(), aname);
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_object_t(NETLIST, GENERIC), pstate_manager_t(),
netlist_t::netlist_t()
: object_t(NETLIST, GENERIC), pstate_manager_t(),
m_stop(netlist_time::zero),
m_time(netlist_time::zero),
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++)
{
@ -218,19 +218,19 @@ netlist_base_t::~netlist_base_t()
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(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();
}
ATTR_COLD void netlist_base_t::start()
ATTR_COLD void netlist_t::start()
{
/* find the main clock and solver ... */
@ -256,14 +256,14 @@ ATTR_COLD void netlist_base_t::start()
NL_VERBOSE_OUT(("Initializing devices ...\n"));
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)
dev->start_dev();
}
}
ATTR_COLD void netlist_base_t::stop()
ATTR_COLD void netlist_t::stop()
{
/* 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++)
{
@ -286,7 +286,7 @@ ATTR_COLD netlist_net_t *netlist_base_t::find_net(const pstring &name)
return NULL;
}
ATTR_COLD void netlist_base_t::rebuild_lists()
ATTR_COLD void netlist_t::rebuild_lists()
{
//printf("Rebuild Lists\n");
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_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;
@ -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()))
{
const netlist_queue_t::entry_t e = *m_queue.pop();
const queue_t::entry_t e = *m_queue.pop();
m_time = e.exec_time();
e.object()->update_devs();
@ -346,7 +346,7 @@ ATTR_HOT void netlist_base_t::process_queue(const netlist_time &delta)
m_time = m_stop;
} 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;
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);
}
const netlist_queue_t::entry_t e = *m_queue.pop();
const queue_t::entry_t e = *m_queue.pop();
m_time = e.exec_time();
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_start(ap, format);
@ -385,7 +385,7 @@ ATTR_COLD void netlist_base_t::error(const char *format, ...) const
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_start(ap, format);
@ -393,7 +393,7 @@ ATTR_COLD void netlist_base_t::warning(const char *format, ...) const
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_start(ap, format);
@ -412,8 +412,8 @@ ATTR_COLD void netlist_base_t::log(const char *format, ...) const
// net_core_device_t
// ----------------------------------------------------------------------------------------
ATTR_COLD netlist_core_device_t::netlist_core_device_t(const family_t afamily)
: netlist_object_t(DEVICE, afamily), netlist_logic_family_t()
ATTR_COLD core_device_t::core_device_t(const family_t afamily)
: object_t(DEVICE, afamily), logic_family_t()
#if (NL_KEEP_STATISTICS)
, stat_total_time(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());
init_object(anetlist, name);
#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;
#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));
#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
}
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)
netlist().m_started_devices.add(this, false);
@ -450,16 +450,16 @@ ATTR_COLD void netlist_core_device_t::start_dev()
start();
}
ATTR_COLD void netlist_core_device_t::stop_dev()
ATTR_COLD void core_device_t::stop_dev()
{
#if (NL_KEEP_STATISTICS)
#endif
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();
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_core_device_t(GENERIC),
device_t::device_t()
: core_device_t(GENERIC),
m_terminals(20)
{
}
netlist_device_t::netlist_device_t(const family_t afamily)
: netlist_core_device_t(afamily),
device_t::device_t(const family_t afamily)
: core_device_t(afamily),
m_terminals(20)
{
}
netlist_device_t::~netlist_device_t()
device_t::~device_t()
{
//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();
}
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);
// 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();
}
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;
// everything already fully qualified
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);
}
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);
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());
}
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());
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());
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());
setup().register_object(*this, name, inp);
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());
setup().register_object(*this, name, inp);
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 */
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>
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;
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);
}
template ATTR_COLD void netlist_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 netlist_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 netlist_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 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_double_t &param, const double initialVal);
template ATTR_COLD void 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_int_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 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 pstring &initialVal);
template ATTR_COLD void device_t::register_param(const pstring &sname, netlist_param_model_t &param, const char * const initialVal);
// ----------------------------------------------------------------------------------------
// netlist_net_t
// ----------------------------------------------------------------------------------------
ATTR_COLD netlist_net_t::netlist_net_t(const family_t afamily)
: netlist_object_t(NET, afamily)
ATTR_COLD net_t::net_t(const family_t afamily)
: object_t(NET, afamily)
, m_new_Q(0)
, m_cur_Q (0)
, 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())
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);
}
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_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--;
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();
}
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);
m_railterminal = &mr;
}
ATTR_COLD void netlist_net_t::rebuild_list()
ATTR_COLD void net_t::rebuild_list()
{
/* rebuild m_list */
unsigned cnt = 0;
m_list_active.clear();
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]);
cnt++;
@ -671,7 +671,7 @@ ATTR_COLD void netlist_net_t::rebuild_list()
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_active));
@ -679,10 +679,10 @@ ATTR_COLD void netlist_net_t::save_register()
save(NLNAME(m_cur_Analog));
save(NLNAME(m_cur_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);
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);
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_cur_Q = m_new_Q;
#if 0
netlist_core_terminal_t * t[256];
netlist_core_terminal_t *p = m_list_active.first();
core_terminal_t * t[256];
core_terminal_t *p = m_list_active.first();
int cnt = 0;
while (p != NULL)
{
@ -714,7 +714,7 @@ ATTR_HOT /* inline */ void netlist_net_t::update_devs()
for (int i=0; i<cnt; i++)
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)
{
@ -723,7 +723,7 @@ ATTR_HOT /* inline */ void netlist_net_t::update_devs()
}
#else
netlist_core_terminal_t *p = m_list_active.first();
core_terminal_t *p = m_list_active.first();
while (p != NULL)
{
@ -733,7 +733,7 @@ ATTR_HOT /* inline */ void netlist_net_t::update_devs()
#endif
}
ATTR_COLD void netlist_net_t::reset()
ATTR_COLD void net_t::reset()
{
m_time = netlist_time::zero;
m_active = 0;
@ -753,32 +753,32 @@ ATTR_COLD void netlist_net_t::reset()
m_core_terms[i]->do_reset();
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++;
}
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);
m_core_terms.add(&terminal);
if (terminal.state() != netlist_logic_t::STATE_INP_PASSIVE)
if (terminal.state() != logic_t::STATE_INP_PASSIVE)
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++)
{
netlist_core_terminal_t *p = m_core_terms[i];
core_terminal_t *p = m_core_terms[i];
dest_net->register_con(*p);
}
m_core_terms.clear(); // FIXME: othernet needs to be free'd from memory
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"));
if (othernet == NULL)
@ -809,47 +809,47 @@ ATTR_COLD void netlist_net_t::merge_net(netlist_net_t *othernet)
// netlist_logic_net_t
// ----------------------------------------------------------------------------------------
ATTR_COLD netlist_logic_net_t::netlist_logic_net_t()
: netlist_net_t(LOGIC)
ATTR_COLD logic_net_t::logic_net_t()
: 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
// ----------------------------------------------------------------------------------------
ATTR_COLD netlist_analog_net_t::netlist_analog_net_t()
: netlist_net_t(ANALOG)
ATTR_COLD analog_net_t::analog_net_t()
: net_t(ANALOG)
, m_DD_n_m_1(0.0)
, m_h_n_m_1(1e-6)
, 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_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())
return true;
@ -861,7 +861,7 @@ ATTR_COLD bool netlist_analog_net_t::already_processed(list_t *groups, int cur_g
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)
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);
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()));
if (p->isType(netlist_terminal_t::TERMINAL))
if (p->isType(terminal_t::TERMINAL))
{
//SOLVER_VERBOSE_OUT(("isterminal\n"));
netlist_terminal_t *pt = static_cast<netlist_terminal_t *>(p);
netlist_analog_net_t *other_net = &pt->m_otherterm->net().as_analog();
terminal_t *pt = static_cast<terminal_t *>(p);
analog_net_t *other_net = &pt->m_otherterm->net().as_analog();
if (!other_net->already_processed(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
// ----------------------------------------------------------------------------------------
ATTR_COLD netlist_core_terminal_t::netlist_core_terminal_t(const type_t atype, const family_t afamily)
: netlist_owned_object_t(atype, afamily)
, plinkedlist_element_t<netlist_core_terminal_t>()
ATTR_COLD core_terminal_t::core_terminal_t(const type_t atype, const family_t afamily)
: owned_object_t(atype, afamily)
, plinkedlist_element_t<core_terminal_t>()
, m_net(NULL)
, 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;
}
@ -905,8 +905,8 @@ ATTR_COLD void netlist_core_terminal_t::set_net(netlist_net_t &anet)
// netlist_terminal_t
// ----------------------------------------------------------------------------------------
ATTR_COLD netlist_terminal_t::netlist_terminal_t()
: netlist_core_terminal_t(TERMINAL, ANALOG)
ATTR_COLD terminal_t::terminal_t()
: core_terminal_t(TERMINAL, ANALOG)
, m_Idr1(NULL)
, m_go1(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.
if (net().as_analog().solver() != NULL)
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.
if (net().as_analog().solver() != NULL)
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_ptr(m_Idr1, 0.0);
@ -936,12 +936,12 @@ ATTR_COLD void netlist_terminal_t::reset()
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_go1));
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
// ----------------------------------------------------------------------------------------
ATTR_COLD netlist_logic_output_t::netlist_logic_output_t()
: netlist_logic_t(OUTPUT)
ATTR_COLD logic_output_t::logic_output_t()
: logic_t(OUTPUT)
{
set_state(STATE_OUT);
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().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);
}
@ -990,9 +990,9 @@ ATTR_COLD netlist_analog_output_t::netlist_analog_output_t()
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().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)
: netlist_owned_object_t(PARAM, ANALOG)
: owned_object_t(PARAM, ANALOG)
, m_param_type(atype)
{
}
@ -1099,7 +1099,7 @@ NETLIB_NAMESPACE_DEVICES_START()
// 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.update_devs();
@ -1125,7 +1125,7 @@ NETLIB_UPDATE_PARAM(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 ...
net.toggle_new_Q();
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)
#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) \
class NETLIB_NAME(_name) : public netlist_device_t \
class NETLIB_NAME(_name) : public device_t \
{ \
public: \
NETLIB_NAME(_name) () \
: netlist_device_t() \
: device_t() \
{ } \
/*protected:*/ \
ATTR_HOT void update(); \
@ -234,7 +234,7 @@
}
#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(); \
, _priv)
@ -244,7 +244,7 @@
, _priv)
#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; \
}
@ -255,11 +255,11 @@ virtual const netlist_logic_family_desc_t *default_logic_family() \
//============================================================
#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
#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
#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
//============================================================
class nl_fatalerror : public std::exception
class fatalerror_e : public std::exception
{
public:
nl_fatalerror(const char *format, ...) ATTR_PRINTF(2,3);
nl_fatalerror(const char *format, va_list ap);
virtual ~nl_fatalerror() throw() {}
fatalerror_e(const char *format, ...) ATTR_PRINTF(2,3);
fatalerror_e(const char *format, va_list ap);
virtual ~fatalerror_e() throw() {}
const pstring &text() { return m_text; }
private:
pstring m_text;
};
class netlist_logic_output_t;
class netlist_analog_net_t;
class netlist_logic_net_t;
class netlist_net_t;
class logic_output_t;
class analog_net_t;
class logic_net_t;
class net_t;
class netlist_setup_t;
class netlist_base_t;
class netlist_core_device_t;
class netlist_t;
class core_device_t;
// -----------------------------------------------------------------------------
// netlist_output_family_t
// -----------------------------------------------------------------------------
class netlist_logic_family_desc_t
class logic_family_desc_t
{
public:
virtual ~netlist_logic_family_desc_t() {}
virtual devices::nld_base_d_to_a_proxy *create_d_a_proxy(netlist_logic_output_t *proxied) const = 0;
virtual ~logic_family_desc_t() {}
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_high_thresh_V;
@ -325,17 +325,17 @@ namespace netlist
nl_double m_R_high;
};
class netlist_logic_family_t
class logic_family_t
{
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_COLD void set_logic_family(const netlist_logic_family_desc_t *fam) { m_logic_family = fam; }
ATTR_HOT const logic_family_desc_t *logic_family() const { return m_logic_family; }
ATTR_COLD void set_logic_family(const logic_family_desc_t *fam) { m_logic_family = fam; }
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
@ -345,17 +345,17 @@ namespace netlist
* Only devices of type GENERIC should have a family description entry
*/
extern const netlist_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_TTL;
extern const logic_family_desc_t &netlist_family_CD4000;
// -----------------------------------------------------------------------------
// netlist_object_t
// -----------------------------------------------------------------------------
class netlist_object_t
class object_t
{
NETLIST_PREVENT_COPYING(netlist_object_t)
NETLIST_PREVENT_COPYING(object_t)
public:
enum type_t {
TERMINAL = 0,
@ -387,11 +387,11 @@ namespace netlist
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 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 isFamily(const family_t afamily) const { return (m_family == afamily); }
ATTR_HOT netlist_base_t & netlist() { return *m_netlist; }
ATTR_HOT const netlist_base_t & netlist() const { return *m_netlist; }
ATTR_HOT netlist_t & netlist() { return *m_netlist; }
ATTR_HOT const netlist_t & netlist() const { return *m_netlist; }
ATTR_COLD void do_reset()
{
@ -422,36 +422,36 @@ namespace netlist
pstring m_name;
const type_t m_objtype;
const family_t m_family;
netlist_base_t * m_netlist;
netlist_t * m_netlist;
};
// -----------------------------------------------------------------------------
// 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:
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:
netlist_core_device_t * m_netdev;
core_device_t * m_netdev;
};
// -----------------------------------------------------------------------------
// 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:
typedef plist_t<netlist_core_terminal_t *> list_t;
typedef plist_t<core_terminal_t *> list_t;
/* 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 set_net(netlist_net_t &anet);
ATTR_COLD void set_net(net_t &anet);
ATTR_COLD void clear_net() { 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 netlist_net_t & net() { return *m_net;}
ATTR_HOT const net_t & net() const { 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 state_e state() const { return m_state; }
@ -491,22 +491,22 @@ namespace netlist
virtual void save_register()
{
save(NLNAME(m_state));
netlist_owned_object_t::save_register();
owned_object_t::save_register();
}
private:
netlist_net_t * m_net;
net_t * m_net;
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:
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_go1; // conductance for Voltage from other term
@ -536,7 +536,7 @@ namespace netlist
ATTR_HOT void schedule_solve();
ATTR_HOT void schedule_after(const netlist_time &after);
netlist_terminal_t *m_otherterm;
terminal_t *m_otherterm;
protected:
virtual void save_register();
@ -557,13 +557,13 @@ namespace netlist
// 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:
ATTR_COLD netlist_logic_t(const type_t atype)
: netlist_core_terminal_t(atype, LOGIC), netlist_logic_family_t(),
ATTR_COLD logic_t(const type_t atype)
: core_terminal_t(atype, LOGIC), logic_family_t(),
m_proxy(NULL)
{
}
@ -578,13 +578,13 @@ namespace netlist
devices::nld_base_proxy *m_proxy;
};
class netlist_analog_t : public netlist_core_terminal_t
class netlist_analog_t : public core_terminal_t
{
public:
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
// -----------------------------------------------------------------------------
class netlist_logic_input_t : public netlist_logic_t
class logic_input_t : public logic_t
{
public:
ATTR_COLD netlist_logic_input_t()
: netlist_logic_t(INPUT)
ATTR_COLD logic_input_t()
: logic_t(INPUT)
{
set_state(STATE_INP_ACTIVE);
}
@ -627,10 +627,10 @@ namespace netlist
// netlist_analog_input_t
// -----------------------------------------------------------------------------
class netlist_analog_input_t : public netlist_analog_t
class analog_input_t : public netlist_analog_t
{
public:
ATTR_COLD netlist_analog_input_t()
ATTR_COLD analog_input_t()
: netlist_analog_t(INPUT)
{
set_state(STATE_INP_ACTIVE);
@ -650,27 +650,27 @@ namespace netlist
// 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:
typedef plist_t<netlist_net_t *> list_t;
typedef plist_t<net_t *> list_t;
ATTR_COLD netlist_net_t(const family_t afamily);
virtual ~netlist_net_t();
ATTR_COLD net_t(const family_t afamily);
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 merge_net(netlist_net_t *othernet);
ATTR_COLD void register_railterminal(netlist_core_terminal_t &mr);
ATTR_COLD void register_con(core_terminal_t &terminal);
ATTR_COLD void merge_net(net_t *othernet);
ATTR_COLD void register_railterminal(core_terminal_t &mr);
ATTR_HOT netlist_logic_net_t & as_logic();
ATTR_HOT const netlist_logic_net_t & as_logic() const;
ATTR_HOT logic_net_t & as_logic();
ATTR_HOT const logic_net_t & as_logic() const;
ATTR_HOT netlist_analog_net_t & as_analog();
ATTR_HOT const netlist_analog_net_t & as_analog() const;
ATTR_HOT analog_net_t & as_analog();
ATTR_HOT const analog_net_t & as_analog() const;
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 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 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 void inc_active(netlist_core_terminal_t &term);
ATTR_HOT void dec_active(netlist_core_terminal_t &term);
ATTR_HOT void inc_active(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 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)
{
@ -715,8 +715,8 @@ namespace netlist
private:
netlist_core_terminal_t * m_railterminal;
plinkedlist_t<netlist_core_terminal_t> m_list_active;
core_terminal_t * m_railterminal;
plinkedlist_t<core_terminal_t> m_list_active;
netlist_time m_time;
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:
typedef plist_t<netlist_logic_net_t *> list_t;
typedef plist_t<logic_net_t *> list_t;
ATTR_COLD netlist_logic_net_t();
virtual ~netlist_logic_net_t() { };
ATTR_COLD logic_net_t();
virtual ~logic_net_t() { };
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:
typedef plist_t<netlist_analog_net_t *> list_t;
typedef plist_t<analog_net_t *> list_t;
ATTR_COLD netlist_analog_net_t();
virtual ~netlist_analog_net_t() { };
ATTR_COLD analog_net_t();
virtual ~analog_net_t() { };
ATTR_HOT nl_double Q_Analog() const
{
@ -835,14 +835,14 @@ namespace netlist
// 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:
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()
{
set_state(STATE_OUT);
@ -856,7 +856,7 @@ namespace netlist
}
private:
netlist_logic_net_t m_my_net;
logic_net_t m_my_net;
};
class netlist_analog_output_t : public netlist_analog_t
@ -866,7 +866,7 @@ namespace netlist
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()
{
set_state(STATE_OUT);
@ -876,17 +876,17 @@ namespace netlist
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:
netlist_analog_net_t m_my_net;
analog_net_t m_my_net;
};
// -----------------------------------------------------------------------------
// 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)
public:
@ -998,18 +998,18 @@ namespace netlist
// 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:
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 void update_dev()
@ -1029,23 +1029,23 @@ namespace netlist
ATTR_COLD void start_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());
nl_assert(inp.state() != netlist_logic_t::STATE_INP_PASSIVE);
nl_assert(inp.state() != logic_t::STATE_INP_PASSIVE);
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);
}
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)
{
@ -1071,7 +1071,7 @@ namespace netlist
ATTR_HOT virtual void update() { }
virtual void start() { }
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;
}
@ -1079,9 +1079,9 @@ namespace netlist
private:
#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))
typedef MEMBER_ABI void (*net_update_delegate)(netlist_core_device_t *);
typedef MEMBER_ABI void (*net_update_delegate)(core_device_t *);
#endif
#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:
ATTR_COLD netlist_device_t();
ATTR_COLD netlist_device_t(const family_t afamily);
ATTR_COLD device_t();
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 void register_sub(const pstring &name, netlist_device_t &dev);
ATTR_COLD void register_subalias(const pstring &name, netlist_core_terminal_t &term);
ATTR_COLD void register_terminal(const pstring &name, netlist_terminal_t &port);
ATTR_COLD void register_sub(const pstring &name, device_t &dev);
ATTR_COLD void register_subalias(const pstring &name, core_terminal_t &term);
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_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, netlist_logic_input_t &in);
ATTR_COLD void register_output(const pstring &name, logic_output_t &out);
ATTR_COLD void register_input(const pstring &name, analog_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;
@ -1133,12 +1133,12 @@ namespace netlist
// netlist_queue_t
// -----------------------------------------------------------------------------
class netlist_queue_t : public netlist_timed_queue<netlist_net_t *, netlist_time>,
public netlist_object_t,
class queue_t : public netlist_timed_queue<net_t *, netlist_time>,
public object_t,
public pstate_callback_t
{
public:
netlist_queue_t(netlist_base_t &nl);
queue_t(netlist_t &nl);
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:
netlist_base_t();
virtual ~netlist_base_t();
netlist_t();
virtual ~netlist_t();
ATTR_COLD void start();
ATTR_COLD void stop();
ATTR_HOT const netlist_queue_t &queue() const { return m_queue; }
ATTR_HOT netlist_queue_t &queue() { return m_queue; }
ATTR_HOT const queue_t &queue() const { return m_queue; }
ATTR_HOT queue_t &queue() { return m_queue; }
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(gnd) *gnd() const { return m_gnd; }
ATTR_HOT nl_double gmin() const;
ATTR_HOT void push_to_queue(netlist_net_t &out, const netlist_time &attime);
ATTR_HOT void remove_from_queue(netlist_net_t &out);
ATTR_HOT void push_to_queue(net_t &out, const netlist_time &attime);
ATTR_HOT void remove_from_queue(net_t &out);
ATTR_HOT void process_queue(const netlist_time &delta);
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 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 warning(const char *format, ...) const ATTR_PRINTF(2,3);
@ -1239,10 +1239,10 @@ namespace netlist
return ret;
}
pnamedlist_t<netlist_device_t *> m_devices;
netlist_net_t::list_t m_nets;
pnamedlist_t<device_t *> m_devices;
net_t::list_t m_nets;
#if (NL_KEEP_STATISTICS)
pnamedlist_t<netlist_core_device_t *> m_started_devices;
pnamedlist_t<core_device_t *> m_started_devices;
#endif
protected:
@ -1274,7 +1274,7 @@ namespace netlist
netlist_time m_time;
bool m_use_deactivate;
netlist_queue_t m_queue;
queue_t m_queue;
devices::NETLIB_NAME(mainclock) * m_mainclock;
@ -1290,7 +1290,7 @@ namespace netlist
// 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)
{
@ -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);
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);
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);
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);
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)))
{
@ -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))
{
@ -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))
{
@ -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))
{
@ -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))
{
@ -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())
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();
}
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();
}
@ -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);
}
}
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_ */

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

@ -18,7 +18,7 @@ namespace netlist
// 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("+"))
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();
}
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("-"))
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++)
{
netlist_base_factory_t *p = m_list[i];
base_factory_t *p = m_list[i];
pfree(p);
}
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++)
{
netlist_base_factory_t *p = m_list[i];
base_factory_t *p = m_list[i];
if (p->classname() == classname)
{
netlist_device_t *ret = p->Create();
device_t *ret = p->Create();
return ret;
}
p++;
@ -64,17 +64,17 @@ netlist_device_t *netlist_factory_list_t::new_device_by_classname(const pstring
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();
}
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++)
{
netlist_base_factory_t *p = m_list[i];
base_factory_t *p = m_list[i];
if (p->name() == name)
{
return p;

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

@ -17,82 +17,82 @@
namespace netlist
{
// -----------------------------------------------------------------------------
// net_dev class factory
// -----------------------------------------------------------------------------
// -----------------------------------------------------------------------------
// net_dev class factory
// -----------------------------------------------------------------------------
class netlist_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()
class base_factory_t
{
netlist_device_t *r = palloc(C);
//r->init(setup, name);
return r;
}
};
NETLIST_PREVENT_COPYING(base_factory_t)
public:
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
{
public:
typedef plist_t<netlist_base_factory_t *> list_t;
virtual ~base_factory_t() {}
netlist_factory_list_t();
~netlist_factory_list_t();
virtual device_t *Create() = 0;
template<class _C>
ATTR_COLD void register_device(const pstring &name, const pstring &classname,
const pstring &def_param)
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 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;
ATTR_COLD netlist_device_t *new_device_by_name(const pstring &name, netlist_setup_t &setup) const;
ATTR_COLD netlist_base_factory_t * factory_by_name(const pstring &name, netlist_setup_t &setup) const;
factory_list_t();
~factory_list_t();
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:
list_t m_list;
ATTR_COLD void register_device(base_factory_t *factory)
{
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)
{
pstring devname;
netlist_base_factory_t *f = m_setup.factory().factory_by_name(dev_type, m_setup);
netlist_device_t *dev;
base_factory_t *f = m_setup.factory().factory_by_name(dev_type, m_setup);
device_t *dev;
pstring_list_t termlist = f->term_param_list();
pstring_list_t def_params = f->def_params();

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

@ -40,7 +40,7 @@ public:
protected:
/* 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);
private:

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

@ -40,12 +40,12 @@ NETLIST_END()
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_proxy_cnt(0)
{
netlist->set_setup(this);
m_factory = palloc(netlist_factory_list_t);
m_factory = palloc(factory_list_t);
}
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);
@ -103,9 +103,9 @@ netlist_device_t *netlist_setup_t::register_dev(netlist_device_t *dev, const pst
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)
netlist().error("Class %s not found!\n", classname.cstr());
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)
{
netlist_device_t *dev = netlist().m_devices.find_by_name(name);
device_t *dev = netlist().m_devices.find_by_name(name);
pstring temp = name + ".";
if (dev == NULL)
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);
}
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())
{
case netlist_terminal_t::TERMINAL:
case terminal_t::TERMINAL:
return "TERMINAL";
case netlist_terminal_t::INPUT:
case terminal_t::INPUT:
return "INPUT";
case netlist_terminal_t::OUTPUT:
case terminal_t::OUTPUT:
return "OUTPUT";
case netlist_terminal_t::NET:
case terminal_t::NET:
return "NET";
case netlist_terminal_t::PARAM:
case terminal_t::PARAM:
return "PARAM";
case netlist_terminal_t::DEVICE:
case terminal_t::DEVICE:
return "DEVICE";
case netlist_terminal_t::NETLIST:
case terminal_t::NETLIST:
return "NETLIST";
case netlist_terminal_t::QUEUE:
case terminal_t::QUEUE:
return "QUEUE";
}
// FIXME: noreturn
@ -176,20 +176,20 @@ pstring netlist_setup_t::objtype_as_astr(netlist_object_t &in) const
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())
{
case netlist_terminal_t::TERMINAL:
case netlist_terminal_t::INPUT:
case netlist_terminal_t::OUTPUT:
case terminal_t::TERMINAL:
case terminal_t::INPUT:
case terminal_t::OUTPUT:
{
netlist_core_terminal_t &term = dynamic_cast<netlist_core_terminal_t &>(obj);
if (obj.isType(netlist_terminal_t::OUTPUT))
core_terminal_t &term = dynamic_cast<core_terminal_t &>(obj);
if (obj.isType(terminal_t::OUTPUT))
{
if (obj.isFamily(netlist_terminal_t::LOGIC))
dynamic_cast<netlist_logic_output_t &>(term).init_object(dev, dev.name() + "." + name);
else if (obj.isFamily(netlist_terminal_t::ANALOG))
if (obj.isFamily(terminal_t::LOGIC))
dynamic_cast<logic_output_t &>(term).init_object(dev, dev.name() + "." + name);
else if (obj.isFamily(terminal_t::ANALOG))
dynamic_cast<netlist_analog_output_t &>(term).init_object(dev, dev.name() + "." + name);
else
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()));
}
break;
case netlist_terminal_t::NET:
case terminal_t::NET:
break;
case netlist_terminal_t::PARAM:
case terminal_t::PARAM:
{
netlist_param_t &param = dynamic_cast<netlist_param_t &>(obj);
//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());
}
break;
case netlist_terminal_t::DEVICE:
case terminal_t::DEVICE:
netlist().error("Device registration not yet supported - %s\n", name.cstr());
break;
case netlist_terminal_t::NETLIST:
case terminal_t::NETLIST:
netlist().error("Netlist registration not yet supported - %s\n", name.cstr());
break;
case netlist_terminal_t::QUEUE:
case terminal_t::QUEUE:
netlist().error("QUEUE registration not yet supported - %s\n", name.cstr());
break;
}
@ -321,7 +321,7 @@ void netlist_setup_t::register_frontier(const pstring attach, const double r_IN,
static int frontier_cnt = 0;
pstring frontier_name = pstring::sprintf("frontier_%d", 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 + ".ROUT", r_OUT);
register_link(frontier_name + ".G", "GND");
@ -375,10 +375,10 @@ const pstring netlist_setup_t::resolve_alias(const pstring &name) const
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);
netlist_core_terminal_t *ret;
core_terminal_t *ret;
ret = m_terminals.find_by_name(tname);
/* look for default */
@ -395,14 +395,14 @@ netlist_core_terminal_t *netlist_setup_t::find_terminal(const pstring &terminal_
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);
netlist_core_terminal_t *ret;
core_terminal_t *ret;
ret = m_terminals.find_by_name(tname);
/* look for default */
if (ret == NULL && atype == netlist_object_t::OUTPUT)
if (ret == NULL && atype == object_t::OUTPUT)
{
/* look for ".Q" std output */
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
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());;
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();
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++)
{
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 ...
if (!connect(new_proxy->proxy_term(), *p))
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;
}
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);
incast.set_proxy(proxy);
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);
}
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);
@ -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);
}
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"));
devices::nld_a_to_d_proxy *proxy = palloc(devices::nld_a_to_d_proxy, &incast);
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()));
/* 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
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"));
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(out.isType(netlist_terminal_t::TERMINAL));
@ -588,7 +588,7 @@ void netlist_setup_t::connect_terminals(netlist_core_terminal_t &t1, netlist_cor
else
{
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);
//m_netlist.solver()->m_nets.add(anet);
// 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())
return out.get_proxy()->proxy_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;
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++)
{
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)*/)
{
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++)
{
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)*/)
{
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()));
netlist_core_terminal_t &t1 = resolve_proxy(t1_in);
netlist_core_terminal_t &t2 = resolve_proxy(t2_in);
core_terminal_t &t1 = resolve_proxy(t1_in);
core_terminal_t &t2 = resolve_proxy(t2_in);
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())
netlist().error("Input %s already connected\n", t2.name().cstr());
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())
netlist().error("Input %s already connected\n", t1.name().cstr());
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);
}
@ -720,8 +720,8 @@ void netlist_setup_t::resolve_inputs()
{
const pstring t1s = m_links[li].e1;
const pstring t2s = m_links[li].e2;
netlist_core_terminal_t *t1 = find_terminal(t1s);
netlist_core_terminal_t *t2 = find_terminal(t2s);
core_terminal_t *t1 = find_terminal(t1s);
core_terminal_t *t2 = find_terminal(t2s);
if (connect(*t1, *t2))
{
@ -746,7 +746,7 @@ void netlist_setup_t::resolve_inputs()
// 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++)
{
@ -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()));
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];
register_dev(nc, name);
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
class netlist_factory_list_t;
class factory_list_t;
class netlist_setup_t
@ -129,21 +129,21 @@ public:
typedef pnamedlist_t<link_t> tagmap_nstring_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;
netlist_setup_t(netlist_base_t *netlist);
netlist_setup_t(netlist_t *netlist);
~netlist_setup_t();
void init();
netlist_base_t &netlist() { return *m_netlist; }
const netlist_base_t &netlist() const { return *m_netlist; }
netlist_t &netlist() { return *m_netlist; }
const netlist_t &netlist() const { return *m_netlist; }
pstring build_fqn(const pstring &obj_name) const;
netlist_device_t *register_dev(netlist_device_t *dev, const pstring &name);
netlist_device_t *register_dev(const pstring &classname, const pstring &name);
device_t *register_dev(device_t *dev, const pstring &name);
device_t *register_dev(const pstring &classname, const pstring &name);
void remove_dev(const pstring &name);
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 remove_connections(const pstring attach);
void register_object(netlist_device_t &dev, const pstring &name, netlist_object_t &obj);
bool connect(netlist_core_terminal_t &t1, netlist_core_terminal_t &t2);
void register_object(device_t &dev, const pstring &name, object_t &obj);
bool connect(core_terminal_t &t1, core_terminal_t &t2);
netlist_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, 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);
@ -181,8 +181,8 @@ public:
void register_source(source_t *src) { m_sources.add(src); }
netlist_factory_list_t &factory() { return *m_factory; }
const netlist_factory_list_t &factory() const { return *m_factory; }
factory_list_t &factory() { return *m_factory; }
const factory_list_t &factory() const { return *m_factory; }
/* not ideal, but needed for save_state */
tagmap_terminal_t m_terminals;
@ -193,14 +193,14 @@ protected:
private:
netlist_base_t *m_netlist;
netlist_t *m_netlist;
tagmap_nstring_t m_alias;
tagmap_param_t m_params;
tagmap_link_t m_links;
tagmap_nstring_t m_params_temp;
netlist_factory_list_t *m_factory;
factory_list_t *m_factory;
plist_t<pstring> m_models;
@ -210,17 +210,17 @@ private:
source_t::list_t m_sources;
void connect_terminals(netlist_core_terminal_t &in, netlist_core_terminal_t &out);
void connect_input_output(netlist_core_terminal_t &in, netlist_core_terminal_t &out);
void connect_terminal_output(netlist_terminal_t &in, netlist_core_terminal_t &out);
void connect_terminal_input(netlist_terminal_t &term, netlist_core_terminal_t &inp);
bool connect_input_input(netlist_core_terminal_t &t1, netlist_core_terminal_t &t2);
void connect_terminals(core_terminal_t &in, core_terminal_t &out);
void connect_input_output(core_terminal_t &in, core_terminal_t &out);
void connect_terminal_output(terminal_t &in, core_terminal_t &out);
void connect_terminal_input(terminal_t &term, core_terminal_t &inp);
bool connect_input_input(core_terminal_t &t1, core_terminal_t &t2);
// 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;
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>
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:
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;
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().include("dummy");
@ -304,8 +304,8 @@ static void listdevices()
list[i]->name().cstr() );
pstring terms("");
netlist::netlist_base_factory_t *f = list[i];
netlist::netlist_device_t *d = f->Create();
netlist::base_factory_t *f = list[i];
netlist::device_t *d = f->Create();
d->init(nt, pstring::sprintf("dummy%d", i));
d->start_dev();