public void run(netlist_state_t nlstate)
{
foreach (var net in nlstate.nets())
{
nlstate.log().verbose.op("processing {0}", net.name());
if (!net.is_rail_net() && !nlstate.core_terms(net).empty())
{
nlstate.log().verbose.op(" ==> not a rail net");
// Must be an analog net
var n = (analog_net_t)net; //auto &n = dynamic_cast<analog_net_t &>(*net);
if (!already_processed(n))
{
groupspre.emplace_back(new nld_solver_net_list_t());
process_net(nlstate, n);
}
}
}
foreach (var g in groupspre)
{
if (!g.empty())
{
groups.push_back(g);
}
}
}
public override device_t Create(netlist_state_t anetlist, string name)
{
throw new emu_unimplemented();
#if false
return(plib::owned_ptr <device_t>::Create <NETLIB_NAME(wrapper)>(anetlist, name));
#endif
}
protected nld_base_proxy(netlist_state_t anetlist, string name, logic_t inout_proxied)
: base(anetlist, name, inout_proxied.logic_family())
{
m_tp = null;
m_tn = null;
if (logic_family() == null)
{
throw new nl_exception(MF_NULLPTR_FAMILY_NP("nld_base_proxy"));
}
bool f = false;
foreach (var pwr_sym in power_syms)
{
string devname = inout_proxied.device().name();
var tp_ct = anetlist.setup().find_terminal(devname + "." + pwr_sym.first,
/*detail::terminal_type::INPUT,*/ false);
var tp_cn = anetlist.setup().find_terminal(devname + "." + pwr_sym.second,
/*detail::terminal_type::INPUT,*/ false);
if (tp_ct != null && tp_cn != null)
{
if (!tp_ct.is_analog())
{
throw new nl_exception(new plib.pfmt("Not an analog terminal: {0}").op(tp_ct.name()));
}
if (!tp_cn.is_analog())
{
throw new nl_exception(new plib.pfmt("Not an analog terminal: {0}").op(tp_cn.name()));
}
var tp_t = (analog_t)tp_ct;
var tn_t = (analog_t)tp_cn;
if (f && (tp_t != null && tn_t != null))
{
log().warning.op(MI_MULTIPLE_POWER_TERMINALS_ON_DEVICE(inout_proxied.device().name(),
m_tp.name(), m_tn.name(),
tp_t != null ? tp_t.name() : "",
tn_t != null ? tn_t.name() : ""));
}
else if (tp_t != null && tn_t != null)
{
m_tp = tp_t;
m_tn = tn_t;
f = true;
}
}
}
if (!f)
{
throw new nl_exception(MF_NO_POWER_TERMINALS_ON_DEVICE_2(name, anetlist.setup().de_alias(inout_proxied.device().name())));
}
log().verbose.op("D/A Proxy: Found power terminals on device {0}", inout_proxied.device().name());
}
//template<>
public static core_device_t bselect(bool b, netlist_state_t d1, core_device_t d2)
{
//plib::unused_var(d1);
if (b)
{
throw new nl_exception("bselect with netlist and b==true");
}
return(d2);
}
public override void macro_actions(netlist_state_t anetlist, string name)
{
throw new emu_unimplemented();
#if false
anetlist.setup().namespace_push(name);
anetlist.setup().include(this.name());
anetlist.setup().namespace_pop();
#endif
}
//NETLIB_CONSTRUCTOR_DERIVED(C, twoterm)
//detail.family_setter_t m_famsetter;
//template <class CLASS>
public nld_C(netlist_state_t owner, string name)
: base(owner, name)
{
m_C = new param_double_t(this, "C", 1e-6);
m_GParallel = 0.0;
//register_term("1", m_P);
//register_term("2", m_N);
}
protected net_t(netlist_state_t nl, string aname, core_terminal_t railterminal = null)
: base(nl.exec(), aname)
{
m_new_Q = new state_var <netlist_sig_t>(this, "m_new_Q", (netlist_sig_t)0);
m_cur_Q = new state_var <netlist_sig_t>(this, "m_cur_Q", (netlist_sig_t)0);
m_in_queue = new state_var <queue_status>(this, "m_in_queue", queue_status.DELIVERED);
m_next_scheduled_time = new state_var <netlist_time_ext>(this, "m_time", netlist_time_ext.zero());
m_railterminal = railterminal;
object_t_props.add(this, ""); //props::add(this, props::value_type());
}
//plib::owned_ptr<device_t> Create(netlist_t &anetlist, const pstring &name) override { return plib::owned_ptr<device_t>::Create<C>(anetlist, name); }
public override device_t Create(netlist_state_t anetlist, string name)
{
Type type = typeof(C);
if (type == typeof(nld_sound_in))
{
return(new nld_sound_in(anetlist, name));
}
else if (type == typeof(nld_sound_out))
{
return(new nld_sound_out(anetlist, name));
}
else if (type == typeof(analog.nld_C))
{
return(new analog.nld_C(anetlist, name));
}
else if (type == typeof(analog.nld_POT))
{
return(new analog.nld_POT(anetlist, name));
}
else if (type == typeof(analog.nld_R))
{
return(new analog.nld_R(anetlist, name));
}
else if (type == typeof(devices.nld_analog_input))
{
return(new devices.nld_analog_input(anetlist, name));
}
else if (type == typeof(devices.nld_gnd))
{
return(new devices.nld_gnd(anetlist, name));
}
else if (type == typeof(devices.nld_logic_input))
{
return(new devices.nld_logic_input(anetlist, name));
}
else if (type == typeof(devices.nld_netlistparams))
{
return(new devices.nld_netlistparams(anetlist, name));
}
else if (type == typeof(devices.nld_solver))
{
return(new devices.nld_solver(anetlist, name));
}
else
{
throw new emu_fatalerror("type {0} not handled yet. add it to switch statement here", type);
}
}
public nld_d_to_a_proxy(netlist_state_t anetlist, string name, logic_output_t out_proxied)
: base(anetlist, name, out_proxied)
{
m_I = new logic_input_t(this, "I", input);
m_RP = new analog.nld_twoterm(this, "RP");
m_RN = new analog.nld_twoterm(this, "RN");
m_last_state = new state_var <netlist_sig_t>(this, "m_last_var", terminal_t.OUT_TRISTATE());
register_subalias("Q", "RN.1");
connect(m_RN.N(), m_tn);
connect(m_RP.P(), m_tp);
connect(m_RN.P(), m_RP.N());
}
void process_net(netlist_state_t nlstate, analog_net_t n)
{
// ignore empty nets. FIXME: print a warning message
nlstate.log().verbose.op("Net {0}", n.name());
if (!nlstate.core_terms(n).empty())
{
// add the net
groupspre.back().push_back(n);
// process all terminals connected to this net
foreach (var term in nlstate.core_terms(n))
{
nlstate.log().verbose.op("Term {0} {1}", term.name(), (int)term.type());
// only process analog terminals
if (term.is_type(detail.terminal_type.TERMINAL))
{
var pt = (terminal_t)term; //auto &pt = dynamic_cast<terminal_t &>(*term);
// check the connected terminal
var connected_terminals = nlstate.setup().get_connected_terminals(pt);
foreach (var ct in connected_terminals) //for (auto ct = connected_terminals->begin(); *ct != nullptr; ct++)
{
if (ct == default)
{
continue;
}
analog_net_t connected_net = ct.net();
nlstate.log().verbose.op(" Connected net {0}", connected_net.name());
if (!check_if_processed_and_join(connected_net))
{
process_net(nlstate, connected_net);
}
}
}
}
}
}
} //: element_t(name, std::move(properties(props).set_type(element_type::MACRO)))
public override core_device_t make_device(device_arena pool, netlist_state_t anetlist, string name) //dev_uptr make_device(device_arena &pool, netlist_state_t &anetlist, const pstring &name) override;
{
return(new nld_wrapper(anetlist, name)); //return plib::make_unique<NETLIB_NAME(wrapper)>(pool, anetlist, name);
}
protected nld_base_d_to_a_proxy(netlist_state_t anetlist, string name, logic_output_t out_proxied)
: base(anetlist, name, out_proxied)
{
}
public nld_wrapper(netlist_state_t anetlist, string name) //NETLIB_NAME(wrapper)(netlist_state_t &anetlist, const pstring &name)
: base(anetlist, name)
{
}
public nld_a_to_d_proxy(netlist_state_t anetlist, string name, logic_input_t in_proxied)
: base(anetlist, name, in_proxied)
{
m_Q = new logic_output_t(this, "Q");
m_I = new analog_input_t(this, "I", input);
}
public abstract device_t Create(netlist_state_t anetlist, string name); //virtual plib::owned_ptr<device_t> Create(netlist_state_t &anetlist, const pstring &name) = 0;
public override core_device_t make_device(device_arena pool, netlist_state_t anetlist, string name)
{
return(make_device(pool, anetlist, name, m_args));
}
//template <std::size_t... Is>
//dev_uptr make_device(device_arena &pool,
// netlist_state_t &anetlist,
// const pstring &name, std::tuple<Args...>& args, std::index_sequence<Is...>)
//{
// return plib::make_unique<C>(pool, anetlist, name, std::forward<Args>(std::get<Is>(args))...);
//}
//dev_uptr make_device(device_arena &pool,
// netlist_state_t &anetlist,
// const pstring &name, std::tuple<Args...>& args)
//{
// return make_device(pool, anetlist, name, args, std::index_sequence_for<Args...>{});
//}
//dev_uptr make_device(device_arena &pool,
// netlist_state_t &anetlist,
// const pstring &name) override
//{
// return make_device(pool, anetlist, name, m_args);
// //return pool.make_unique<C>(anetlist, name);
//}
public core_device_t make_device(device_arena pool, netlist_state_t anetlist, string name, object [] args)
{
//return plib::make_unique<C>(pool, anetlist, name, std::forward<Args>(std::get<Is>(args))...);
////return anetlist.make_pool_object<C>(anetlist, name, std::forward<Args>(std::get<Is>(args))...);
if (typeof(C) == typeof(analog.nld_C))
{
return(new analog.nld_C(anetlist, name));
}
else if (typeof(C) == typeof(analog.nld_D))
{
return(new analog.nld_D(anetlist, name));
}
else if (typeof(C) == typeof(analog.nld_opamp))
{
return(new analog.nld_opamp(anetlist, name));
}
else if (typeof(C) == typeof(analog.nld_POT))
{
return(new analog.nld_POT(anetlist, name));
}
else if (typeof(C) == typeof(analog.nld_QBJT_EB))
{
return(new analog.nld_QBJT_EB(anetlist, name));
}
else if (typeof(C) == typeof(analog.nld_QBJT_switch))
{
return(new analog.nld_QBJT_switch(anetlist, name));
}
else if (typeof(C) == typeof(analog.nld_R))
{
return(new analog.nld_R(anetlist, name));
}
else if (typeof(C) == typeof(analog.nld_switch2))
{
return(new analog.nld_switch2(anetlist, name));
}
else if (typeof(C) == typeof(analog.nld_Z))
{
return(new analog.nld_Z(anetlist, name));
}
else if (typeof(C) == typeof(devices.nld_74107))
{
return(new devices.nld_74107(anetlist, name));
}
else if (typeof(C) == typeof(devices.nld_74153))
{
return(new devices.nld_74153(anetlist, name));
}
else if (typeof(C) == typeof(devices.nld_7448))
{
return(new devices.nld_7448(anetlist, name));
}
else if (typeof(C) == typeof(devices.nld_7450))
{
return(new devices.nld_7450(anetlist, name));
}
else if (typeof(C) == typeof(devices.nld_7474))
{
return(new devices.nld_7474(anetlist, name));
}
else if (typeof(C) == typeof(devices.nld_7483))
{
return(new devices.nld_7483(anetlist, name));
}
else if (typeof(C) == typeof(devices.nld_7490))
{
return(new devices.nld_7490(anetlist, name));
}
else if (typeof(C) == typeof(devices.nld_7493))
{
return(new devices.nld_7493(anetlist, name));
}
else if (typeof(C) == typeof(devices.nld_9316))
{
return(new devices.nld_9316(anetlist, name));
}
else if (typeof(C) == typeof(devices.nld_analog_input))
{
return(new devices.nld_analog_input(anetlist, name));
}
else if (typeof(C) == typeof(devices.nld_CD4066_GATE))
{
return(new devices.nld_CD4066_GATE(anetlist, name));
}
else if (typeof(C) == typeof(devices.nld_clock))
{
return(new devices.nld_clock(anetlist, name));
}
else if (typeof(C) == typeof(devices.nld_frontier))
{
return(new devices.nld_frontier(anetlist, name));
}
else if (typeof(C) == typeof(devices.nld_gnd))
{
return(new devices.nld_gnd(anetlist, name));
}
else if (typeof(C) == typeof(devices.nld_logic_input))
{
return(new devices.nld_logic_input(anetlist, name));
}
else if (typeof(C) == typeof(devices.nld_mainclock))
{
return(new devices.nld_mainclock(anetlist, name));
}
else if (typeof(C) == typeof(devices.nld_NE555))
{
return(new devices.nld_NE555(anetlist, name));
}
else if (typeof(C) == typeof(devices.nld_netlistparams))
{
return(new devices.nld_netlistparams(anetlist, name));
}
else if (typeof(C) == typeof(devices.nld_solver))
{
return(new devices.nld_solver(anetlist, name));
}
else if (typeof(C) == typeof(devices.nld_sys_dsw1))
{
return(new devices.nld_sys_dsw1(anetlist, name));
}
else if (typeof(C) == typeof(devices.nld_sys_noise <mt19937_64, plib.normal_distribution_t, plib.distribution_ops_normal>))
{
return(new devices.nld_sys_noise <mt19937_64, plib.normal_distribution_t, plib.distribution_ops_normal>(anetlist, name));
}
else if (typeof(C) == typeof(interface_.nld_analog_callback))
{
assert(args.Length == 2); return(new interface_.nld_analog_callback(anetlist, name, (nl_fptype)args[0], (interface_.nld_analog_callback.FUNC)args[1]));
}
else if (typeof(C) == typeof(interface_.nld_logic_callback))
{
assert(args.Length == 1); return(new interface_.nld_logic_callback(anetlist, name, (interface_.nld_logic_callback.FUNC)args[0]));
}
else if (typeof(C) == typeof(nld_sound_in))
{
return(new nld_sound_in(anetlist, name));
}
else
{
throw new emu_unimplemented();
}
}
//~element_t() { }
//PCOPYASSIGNMOVE(element_t, default)
public abstract core_device_t make_device(device_arena pool, netlist_state_t anetlist, string name); //virtual dev_uptr make_device(device_arena &pool, netlist_state_t &anetlist, const pstring &name) = 0;
public abstract device_t Create(netlist_state_t anetlist, string name); //virtual plib::owned_ptr<device_t> Create(netlist_state_t &anetlist, const pstring &name) = 0;
public virtual void macro_actions(netlist_state_t anetlist, string name)
{
}
protected nld_base_a_to_d_proxy(netlist_state_t anetlist, string name, logic_input_t in_proxied)
: base(anetlist, name, in_proxied)
{
}
