diff options
Diffstat (limited to 'src')
47 files changed, 622 insertions, 567 deletions
diff --git a/src/devices/machine/netlist.cpp b/src/devices/machine/netlist.cpp index b44264478c2..a3936b9e5d4 100644 --- a/src/devices/machine/netlist.cpp +++ b/src/devices/machine/netlist.cpp @@ -100,7 +100,7 @@ void netlist_mame_analog_output_t::custom_netlist_additions(netlist::setup_t &se pstring dname = "OUT_" + m_in; m_delegate.bind_relative_to(owner()->machine().root_device()); - powned_ptr<netlist::device_t> dev = powned_ptr<netlist::device_t>::Create<NETLIB_NAME(analog_callback)>(setup.netlist(), setup.build_fqn(dname)); + plib::powned_ptr<netlist::device_t> dev = plib::powned_ptr<netlist::device_t>::Create<NETLIB_NAME(analog_callback)>(setup.netlist(), setup.build_fqn(dname)); static_cast<NETLIB_NAME(analog_callback) *>(dev.get())->register_callback(m_delegate); setup.register_dev(std::move(dev)); setup.register_link(dname + ".IN", m_in); @@ -175,11 +175,11 @@ void netlist_mame_stream_input_t::custom_netlist_additions(netlist::setup_t &set if (!setup.device_exists("STREAM_INPUT")) setup.register_dev("NETDEV_SOUND_IN", "STREAM_INPUT"); - pstring sparam = pfmt("STREAM_INPUT.CHAN{1}")(m_channel); + pstring sparam = plib::pfmt("STREAM_INPUT.CHAN{1}")(m_channel); setup.register_param(sparam, m_param_name); - sparam = pfmt("STREAM_INPUT.MULT{1}")(m_channel); + sparam = plib::pfmt("STREAM_INPUT.MULT{1}")(m_channel); setup.register_param(sparam, m_mult); - sparam = pfmt("STREAM_INPUT.OFFSET{1}")(m_channel); + sparam = plib::pfmt("STREAM_INPUT.OFFSET{1}")(m_channel); setup.register_param(sparam, m_offset); } @@ -210,7 +210,7 @@ void netlist_mame_stream_output_t::device_start() void netlist_mame_stream_output_t::custom_netlist_additions(netlist::setup_t &setup) { //NETLIB_NAME(sound_out) *snd_out; - pstring sname = pfmt("STREAM_OUT_{1}")(m_channel); + pstring sname = plib::pfmt("STREAM_OUT_{1}")(m_channel); //snd_out = dynamic_cast<NETLIB_NAME(sound_out) *>(setup.register_dev("nld_sound_out", sname)); setup.register_dev("NETDEV_SOUND_OUT", sname); @@ -226,28 +226,28 @@ void netlist_mame_stream_output_t::custom_netlist_additions(netlist::setup_t &se // netlist_mame_t // ---------------------------------------------------------------------------------------- -void netlist_mame_t::vlog(const plog_level &l, const pstring &ls) const +void netlist_mame_t::vlog(const plib::plog_level &l, const pstring &ls) const { pstring errstr = ls; switch (l) { - case plog_level::DEBUG: + case plib::plog_level::DEBUG: m_parent.logerror("netlist DEBUG: %s\n", errstr.cstr()); break; - case plog_level::INFO: + case plib::plog_level::INFO: m_parent.logerror("netlist INFO: %s\n", errstr.cstr()); break; - case plog_level::VERBOSE: + case plib::plog_level::VERBOSE: m_parent.logerror("netlist VERBOSE: %s\n", errstr.cstr()); break; - case plog_level::WARNING: + case plib::plog_level::WARNING: m_parent.logerror("netlist WARNING: %s\n", errstr.cstr()); break; - case plog_level::ERROR: + case plib::plog_level::ERROR: m_parent.logerror("netlist ERROR: %s\n", errstr.cstr()); break; - case plog_level::FATAL: + case plib::plog_level::FATAL: emu_fatalerror error("netlist ERROR: %s\n", errstr.cstr()); throw error; } @@ -404,42 +404,42 @@ ATTR_COLD void netlist_mame_device_t::save_state() netlist().log().debug("saving state for {1}\n", s->m_name.cstr()); switch (s->m_dt) { - case DT_DOUBLE: + case pstate_data_type_e::DT_DOUBLE: { double *td = s->resolved<double>(); if (td != nullptr) save_pointer(td, s->m_name.cstr(), s->m_count); } break; - case DT_FLOAT: + case pstate_data_type_e::DT_FLOAT: { float *td = s->resolved<float>(); if (td != nullptr) save_pointer(td, s->m_name.cstr(), s->m_count); } break; #if (PHAS_INT128) - case DT_INT128: + case pstate_data_type_e::DT_INT128: // FIXME: we are cheating here save_pointer((char *) s->m_ptr, s->m_name.cstr(), s->m_count * sizeof(INT128)); break; #endif - case DT_INT64: + case pstate_data_type_e::DT_INT64: save_pointer((INT64 *) s->m_ptr, s->m_name.cstr(), s->m_count); break; - case DT_INT16: + case pstate_data_type_e::DT_INT16: save_pointer((INT16 *) s->m_ptr, s->m_name.cstr(), s->m_count); break; - case DT_INT8: + case pstate_data_type_e::DT_INT8: save_pointer((INT8 *) s->m_ptr, s->m_name.cstr(), s->m_count); break; - case DT_INT: + case pstate_data_type_e::DT_INT: save_pointer((int *) s->m_ptr, s->m_name.cstr(), s->m_count); break; - case DT_BOOLEAN: + case pstate_data_type_e::DT_BOOLEAN: save_pointer((bool *) s->m_ptr, s->m_name.cstr(), s->m_count); break; - case DT_CUSTOM: + case pstate_data_type_e::DT_CUSTOM: break; - case NOT_SUPPORTED: + case pstate_data_type_e::NOT_SUPPORTED: default: netlist().log().fatal("found unsupported save element %s\n", s->m_name); break; @@ -566,7 +566,7 @@ void netlist_mame_sound_device_t::device_start() // Configure outputs - pvector_t<nld_sound_out *> outdevs = netlist().get_device_list<nld_sound_out>(); + plib::pvector_t<nld_sound_out *> outdevs = netlist().get_device_list<nld_sound_out>(); if (outdevs.size() == 0) fatalerror("No output devices"); @@ -592,7 +592,7 @@ void netlist_mame_sound_device_t::device_start() m_num_inputs = 0; m_in = nullptr; - pvector_t<nld_sound_in *> indevs = netlist().get_device_list<nld_sound_in>(); + plib::pvector_t<nld_sound_in *> indevs = netlist().get_device_list<nld_sound_in>(); if (indevs.size() > 1) fatalerror("A maximum of one input device is allowed!"); if (indevs.size() == 1) @@ -650,9 +650,9 @@ bool netlist_source_memregion_t::parse(netlist::setup_t &setup, const pstring &n { // FIXME: preprocessor should be a stream! memory_region *mem = downcast<netlist_mame_t &>(setup.netlist()).machine().root_device().memregion(m_name.cstr()); - pimemstream istrm(mem->base(),mem->bytes() ); - pomemstream ostrm; + plib::pimemstream istrm(mem->base(),mem->bytes() ); + plib::pomemstream ostrm; - pimemstream istrm2(ppreprocessor().process(istrm, ostrm)); + plib::pimemstream istrm2(plib::ppreprocessor().process(istrm, ostrm)); return netlist::parser_t(istrm2, setup).parse(name); } diff --git a/src/devices/machine/netlist.h b/src/devices/machine/netlist.h index d3d850454bf..5340c792573 100644 --- a/src/devices/machine/netlist.h +++ b/src/devices/machine/netlist.h @@ -97,7 +97,7 @@ public: protected: - void vlog(const plog_level &l, const pstring &ls) const override; + void vlog(const plib::plog_level &l, const pstring &ls) const override; private: netlist_mame_device_t &m_parent; @@ -636,9 +636,9 @@ public: for (int i = 0; i < MAX_INPUT_CHANNELS; i++) { - m_param_name[i] = std::make_unique<netlist::param_str_t>(*this, pfmt("CHAN{1}")(i), ""); - m_param_mult[i] = std::make_unique<netlist::param_double_t>(*this, pfmt("MULT{1}")(i), 1.0); - m_param_offset[i] = std::make_unique<netlist::param_double_t>(*this, pfmt("OFFSET{1}")(i), 0.0); + m_param_name[i] = std::make_unique<netlist::param_str_t>(*this, plib::pfmt("CHAN{1}")(i), ""); + m_param_mult[i] = std::make_unique<netlist::param_double_t>(*this, plib::pfmt("MULT{1}")(i), 1.0); + m_param_offset[i] = std::make_unique<netlist::param_double_t>(*this, plib::pfmt("OFFSET{1}")(i), 0.0); } m_num_channel = 0; } diff --git a/src/lib/netlist/devices/nld_log.cpp b/src/lib/netlist/devices/nld_log.cpp index 8e57f1313cb..501b6e862e5 100644 --- a/src/lib/netlist/devices/nld_log.cpp +++ b/src/lib/netlist/devices/nld_log.cpp @@ -15,7 +15,7 @@ NETLIB_NAMESPACE_DEVICES_START() NETLIB_UPDATE(log) { /* use pstring::sprintf, it is a LOT faster */ - m_strm->writeline(pfmt("{1} {2}").e(netlist().time().as_double(),".9").e((nl_double) INPANALOG(m_I))); + m_strm->writeline(plib::pfmt("{1} {2}").e(netlist().time().as_double(),".9").e((nl_double) INPANALOG(m_I))); } NETLIB_NAME(log)::~NETLIB_NAME(log)() @@ -25,7 +25,7 @@ NETLIB_NAME(log)::~NETLIB_NAME(log)() NETLIB_UPDATE(logD) { - m_strm->writeline(pfmt("{1} {2}").e(netlist().time().as_double(),".9").e((nl_double) (INPANALOG(m_I) - INPANALOG(m_I2)))); + m_strm->writeline(plib::pfmt("{1} {2}").e(netlist().time().as_double(),".9").e((nl_double) (INPANALOG(m_I) - INPANALOG(m_I2)))); } // FIXME: Implement wav later, this must be clock triggered device where the input to be written diff --git a/src/lib/netlist/devices/nld_log.h b/src/lib/netlist/devices/nld_log.h index c2e05784913..5210d8496b2 100644 --- a/src/lib/netlist/devices/nld_log.h +++ b/src/lib/netlist/devices/nld_log.h @@ -41,15 +41,15 @@ NETLIB_OBJECT(log) { enregister("I", m_I); - pstring filename = pfmt("{1}.log")(this->name()); - m_strm = pmake_unique<pofilestream>(filename); + pstring filename = plib::pfmt("{1}.log")(this->name()); + m_strm = plib::pmake_unique<plib::pofilestream>(filename); } NETLIB_DESTRUCTOR(log); NETLIB_UPDATEI(); NETLIB_RESETI() { } protected: analog_input_t m_I; - std::unique_ptr<pofilestream> m_strm; + std::unique_ptr<plib::pofilestream> m_strm; }; NETLIB_OBJECT_DERIVED(logD, log) diff --git a/src/lib/netlist/devices/nld_system.h b/src/lib/netlist/devices/nld_system.h index 4ca2a8cf84e..0c153292088 100644 --- a/src/lib/netlist/devices/nld_system.h +++ b/src/lib/netlist/devices/nld_system.h @@ -183,7 +183,7 @@ NETLIB_OBJECT(extclock) connect_late(m_feedback, m_Q); { netlist_time base = netlist_time::from_hz(m_freq.Value()*2); - pstring_vector_t pat(m_pattern.Value(),","); + plib::pstring_vector_t pat(m_pattern.Value(),","); m_off = netlist_time::from_double(m_offset.Value()); int pati[256]; @@ -369,9 +369,9 @@ NETLIB_OBJECT(function) enregister("Q", m_Q); for (int i=0; i < m_N; i++) - enregister(pfmt("A{1}")(i), m_I[i]); + enregister(plib::pfmt("A{1}")(i), m_I[i]); - pstring_vector_t cmds(m_func.Value(), " "); + plib::pstring_vector_t cmds(m_func.Value(), " "); m_precompiled.clear(); for (std::size_t i=0; i < cmds.size(); i++) @@ -434,7 +434,7 @@ private: analog_output_t m_Q; analog_input_t m_I[10]; - pvector_t<rpn_inst> m_precompiled; + plib::pvector_t<rpn_inst> m_precompiled; }; // ----------------------------------------------------------------------------- @@ -631,9 +631,9 @@ public: pstring m_dev_name; }; - powned_ptr<device_t> Create(netlist_t &anetlist, const pstring &name) override + plib::powned_ptr<device_t> Create(netlist_t &anetlist, const pstring &name) override { - return powned_ptr<device_t>::Create<wrapper>(this->name(), anetlist, name); + return plib::powned_ptr<device_t>::Create<wrapper>(this->name(), anetlist, name); } private: diff --git a/src/lib/netlist/devices/nld_truthtable.cpp b/src/lib/netlist/devices/nld_truthtable.cpp index 6440ad0a2db..15d390c12bc 100644 --- a/src/lib/netlist/devices/nld_truthtable.cpp +++ b/src/lib/netlist/devices/nld_truthtable.cpp @@ -64,7 +64,7 @@ UINT32 truthtable_desc_t::get_ignored_extended(UINT32 i) * may change the output */ UINT32 bits = (1<<count_bits(nign)); - parray_t<int> t(bits); + plib::array_t<int> t(bits); for (UINT32 j=1; j<bits; j++) { @@ -99,8 +99,8 @@ UINT32 truthtable_desc_t::get_ignored_extended(UINT32 i) // desc // ---------------------------------------------------------------------------------------- -void truthtable_desc_t::help(unsigned cur, pstring_vector_t list, - UINT64 state,UINT16 val, parray_t<UINT8> &timing_index) +void truthtable_desc_t::help(unsigned cur, plib::pstring_vector_t list, + UINT64 state,UINT16 val, plib::array_t<UINT8> &timing_index) { pstring elem = list[cur].trim(); int start = 0; @@ -135,7 +135,7 @@ void truthtable_desc_t::help(unsigned cur, pstring_vector_t list, { // cutoff previous inputs and outputs for ignore if (m_outs[nstate] != ~0U && m_outs[nstate] != val) - fatalerror_e(pfmt("Error in truthtable: State {1} already set, {2} != {3}\n") + fatalerror_e(plib::pfmt("Error in truthtable: State {1} already set, {2} != {3}\n") .x(nstate,"04")(m_outs[nstate])(val) ); m_outs[nstate] = val; for (unsigned j=0; j<m_NO; j++) @@ -144,7 +144,7 @@ void truthtable_desc_t::help(unsigned cur, pstring_vector_t list, } } -void truthtable_desc_t::setup(const pstring_vector_t &truthtable, UINT32 disabled_ignore) +void truthtable_desc_t::setup(const plib::pstring_vector_t &truthtable, UINT32 disabled_ignore) { unsigned line = 0; @@ -164,18 +164,18 @@ void truthtable_desc_t::setup(const pstring_vector_t &truthtable, UINT32 disable while (!ttline.equals("")) { - pstring_vector_t io(ttline,"|"); + plib::pstring_vector_t io(ttline,"|"); // checks nl_assert_always(io.size() == 3, "io.count mismatch"); - pstring_vector_t inout(io[0], ","); + plib::pstring_vector_t inout(io[0], ","); nl_assert_always(inout.size() == m_num_bits, "number of bits not matching"); - pstring_vector_t out(io[1], ","); + plib::pstring_vector_t out(io[1], ","); nl_assert_always(out.size() == m_NO, "output count not matching"); - pstring_vector_t times(io[2], ","); + plib::pstring_vector_t times(io[2], ","); nl_assert_always(times.size() == m_NO, "timing count not matching"); UINT16 val = 0; - parray_t<UINT8> tindex(m_NO); + plib::array_t<UINT8> tindex(m_NO); for (unsigned j=0; j<m_NO; j++) { @@ -201,7 +201,7 @@ void truthtable_desc_t::setup(const pstring_vector_t &truthtable, UINT32 disable } // determine ignore - parray_t<UINT32> ign(m_size); + plib::array_t<UINT32> ign(m_size); for (UINT32 j=0; j < m_size; j++) ign[j] = ~0U; @@ -234,7 +234,7 @@ void truthtable_desc_t::setup(const pstring_vector_t &truthtable, UINT32 disable for (UINT32 i=0; i<m_size; i++) { if (m_outs[i] == ~0U) - throw fatalerror_e(pfmt("truthtable: found element not set {1}\n").x(i) ); + throw fatalerror_e(plib::pfmt("truthtable: found element not set {1}\n").x(i) ); m_outs[i] |= ((ign[i] & ~disabled_ignore) << m_NO); } *m_initialized = true; @@ -243,13 +243,13 @@ void truthtable_desc_t::setup(const pstring_vector_t &truthtable, UINT32 disable #define ENTRYX(_n,_m,_h) case (_n * 1000 + _m * 10 + _h): \ { using xtype = netlist_factory_truthtable_t<_n,_m,_h>; \ - return powned_ptr<netlist_base_factory_truthtable_t>::Create<xtype>(name,classname,def_param); } break + return plib::powned_ptr<netlist_base_factory_truthtable_t>::Create<xtype>(name,classname,def_param); } break #define ENTRYY(_n,_m) ENTRYX(_n,_m,0); ENTRYX(_n,_m,1) #define ENTRY(_n) ENTRYY(_n, 1); ENTRYY(_n, 2); ENTRYY(_n, 3); ENTRYY(_n, 4); ENTRYY(_n, 5); ENTRYY(_n, 6) -powned_ptr<netlist_base_factory_truthtable_t> nl_tt_factory_create(const unsigned ni, const unsigned no, +plib::powned_ptr<netlist_base_factory_truthtable_t> nl_tt_factory_create(const unsigned ni, const unsigned no, const unsigned has_state, const pstring &name, const pstring &classname, const pstring &def_param) @@ -267,7 +267,7 @@ powned_ptr<netlist_base_factory_truthtable_t> nl_tt_factory_create(const unsigne ENTRY(9); ENTRY(10); default: - pstring msg = pfmt("unable to create truthtable<{1},{2},{3}>")(ni)(no)(has_state); + pstring msg = plib::pfmt("unable to create truthtable<{1},{2},{3}>")(ni)(no)(has_state); nl_assert_always(false, msg); } //return nullptr; diff --git a/src/lib/netlist/devices/nld_truthtable.h b/src/lib/netlist/devices/nld_truthtable.h index e9270db2faa..bfb60c07dab 100644 --- a/src/lib/netlist/devices/nld_truthtable.h +++ b/src/lib/netlist/devices/nld_truthtable.h @@ -66,11 +66,11 @@ struct truthtable_desc_t { } - void setup(const pstring_vector_t &desc, UINT32 disabled_ignore); + void setup(const plib::pstring_vector_t &desc, UINT32 disabled_ignore); private: - void help(unsigned cur, pstring_vector_t list, - UINT64 state,UINT16 val, parray_t<UINT8> &timing_index); + void help(unsigned cur, plib::pstring_vector_t list, + UINT64 state,UINT16 val, plib::array_t<UINT8> &timing_index); static unsigned count_bits(UINT32 v); static UINT32 set_bits(UINT32 v, UINT32 b); UINT32 get_ignored_simple(UINT32 i); @@ -133,7 +133,7 @@ public: template <class C> nld_truthtable_t(C &owner, const pstring &name, const logic_family_desc_t *fam, - truthtable_t *ttbl, const pstring_vector_t &desc) + truthtable_t *ttbl, const plib::pstring_vector_t &desc) : device_t(owner, name) , m_fam(*this, fam) , m_last_state(0) @@ -149,12 +149,12 @@ public: { pstring header = m_desc[0]; - pstring_vector_t io(header,"|"); + plib::pstring_vector_t io(header,"|"); // checks nl_assert_always(io.size() == 2, "too many '|'"); - pstring_vector_t inout(io[0], ","); + plib::pstring_vector_t inout(io[0], ","); nl_assert_always(inout.size() == m_num_bits, "bitcount wrong"); - pstring_vector_t out(io[1], ","); + plib::pstring_vector_t out(io[1], ","); nl_assert_always(out.size() == m_NO, "output count wrong"); for (unsigned i=0; i < m_NI; i++) @@ -311,7 +311,7 @@ private: INT32 m_active; truthtable_t *m_ttp; - pstring_vector_t m_desc; + plib::pstring_vector_t m_desc; }; class netlist_base_factory_truthtable_t : public base_factory_t @@ -327,7 +327,7 @@ public: { } - pstring_vector_t m_desc; + plib::pstring_vector_t m_desc; const logic_family_desc_t *m_family; }; @@ -341,16 +341,16 @@ public: const pstring &def_param) : netlist_base_factory_truthtable_t(name, classname, def_param) { } - powned_ptr<device_t> Create(netlist_t &anetlist, const pstring &name) override + plib::powned_ptr<device_t> Create(netlist_t &anetlist, const pstring &name) override { typedef nld_truthtable_t<m_NI, m_NO, has_state> tt_type; - return powned_ptr<device_t>::Create<tt_type>(anetlist, name, m_family, &m_ttbl, m_desc); + return plib::powned_ptr<device_t>::Create<tt_type>(anetlist, name, m_family, &m_ttbl, m_desc); } private: typename nld_truthtable_t<m_NI, m_NO, has_state>::truthtable_t m_ttbl; }; -powned_ptr<netlist_base_factory_truthtable_t> nl_tt_factory_create(const unsigned ni, const unsigned no, +plib::powned_ptr<netlist_base_factory_truthtable_t> nl_tt_factory_create(const unsigned ni, const unsigned no, const unsigned has_state, const pstring &name, const pstring &classname, const pstring &def_param); diff --git a/src/lib/netlist/nl_base.cpp b/src/lib/netlist/nl_base.cpp index 5085f38d53b..f7629065ff4 100644 --- a/src/lib/netlist/nl_base.cpp +++ b/src/lib/netlist/nl_base.cpp @@ -64,9 +64,9 @@ public: m_R_low = 1.0; m_R_high = 130.0; } - virtual powned_ptr<devices::nld_base_d_to_a_proxy> create_d_a_proxy(netlist_t &anetlist, const pstring &name, logic_output_t *proxied) const override + virtual plib::powned_ptr<devices::nld_base_d_to_a_proxy> create_d_a_proxy(netlist_t &anetlist, const pstring &name, logic_output_t *proxied) const override { - return powned_ptr<devices::nld_base_d_to_a_proxy>::Create<devices::nld_d_to_a_proxy>(anetlist, name, proxied); + return plib::powned_ptr<devices::nld_base_d_to_a_proxy>::Create<devices::nld_d_to_a_proxy>(anetlist, name, proxied); } }; @@ -84,9 +84,9 @@ public: m_R_low = 10.0; m_R_high = 10.0; } - virtual powned_ptr<devices::nld_base_d_to_a_proxy> create_d_a_proxy(netlist_t &anetlist, const pstring &name, logic_output_t *proxied) const override + virtual plib::powned_ptr<devices::nld_base_d_to_a_proxy> create_d_a_proxy(netlist_t &anetlist, const pstring &name, logic_output_t *proxied) const override { - return powned_ptr<devices::nld_base_d_to_a_proxy>::Create<devices::nld_d_to_a_proxy>(anetlist, name, proxied); + return plib::powned_ptr<devices::nld_base_d_to_a_proxy>::Create<devices::nld_d_to_a_proxy>(anetlist, name, proxied); } }; @@ -108,14 +108,14 @@ const logic_family_desc_t *family_CD4XXX() queue_t::queue_t(netlist_t &nl) : timed_queue<net_t *, netlist_time>(512) , object_t(nl, "QUEUE", QUEUE) - , pstate_callback_t() + , plib::pstate_callback_t() , m_qsize(0) , m_times(512) , m_names(512) { } -void queue_t::register_state(pstate_manager_t &manager, const pstring &module) +void queue_t::register_state(plib::pstate_manager_t &manager, const pstring &module) { netlist().log().debug("register_state\n"); manager.save_item(m_qsize, this, module + "." + "qsize"); @@ -228,7 +228,7 @@ netlist_t::netlist_t(const pstring &aname) m_log(this), m_lib(nullptr) { - save_item(static_cast<pstate_callback_t &>(m_queue), this, "m_queue"); + save_item(static_cast<plib::pstate_callback_t &>(m_queue), this, "m_queue"); save_item(m_time, this, "m_time"); } @@ -253,7 +253,7 @@ ATTR_COLD void netlist_t::start() pstring libpath = nl_util::environment("NL_BOOSTLIB", nl_util::buildpath({".", "nlboost.so"})); - m_lib = palloc<plib::dynlib>(libpath); + m_lib = plib::palloc<plib::dynlib>(libpath); /* make sure the solver and parameters are started first! */ @@ -264,7 +264,7 @@ ATTR_COLD void netlist_t::start() || setup().factory().is_class<devices::NETLIB_NAME(gnd)>(e.second) || setup().factory().is_class<devices::NETLIB_NAME(netlistparams)>(e.second)) { - auto dev = powned_ptr<device_t>(e.second->Create(*this, e.first)); + auto dev = plib::powned_ptr<device_t>(e.second->Create(*this, e.first)); setup().register_dev_s(std::move(dev)); } } @@ -287,7 +287,7 @@ ATTR_COLD void netlist_t::start() && !setup().factory().is_class<devices::NETLIB_NAME(gnd)>(e.second) && !setup().factory().is_class<devices::NETLIB_NAME(netlistparams)>(e.second)) { - auto dev = powned_ptr<device_t>(e.second->Create(*this, e.first)); + auto dev = plib::powned_ptr<device_t>(e.second->Create(*this, e.first)); setup().register_dev_s(std::move(dev)); } } @@ -495,7 +495,7 @@ ATTR_COLD core_device_t::core_device_t(core_device_t &owner, const pstring &name if (logic_family() == nullptr) set_logic_family(family_TTL()); init_object(owner.netlist(), owner.name() + "." + name); - owner.netlist().m_devices.push_back(powned_ptr<core_device_t>(this, false)); + owner.netlist().m_devices.push_back(plib::powned_ptr<core_device_t>(this, false)); } ATTR_COLD core_device_t::~core_device_t() @@ -514,7 +514,7 @@ ATTR_COLD void core_device_t::set_delegate_pointer() void (core_device_t::* pFunc)() = &core_device_t::update; m_static_update = reinterpret_cast<net_update_delegate>((this->*pFunc)); #elif (NL_PMF_TYPE == NL_PMF_TYPE_INTERNAL) - m_static_update = pmfp::get_mfp<net_update_delegate>(&core_device_t::update, this); + m_static_update = plib::mfp::get_mfp<net_update_delegate>(&core_device_t::update, this); #endif } @@ -866,7 +866,7 @@ ATTR_COLD void analog_net_t::save_register() net_t::save_register(); } -ATTR_COLD bool analog_net_t::already_processed(pvector_t<list_t> &groups) +ATTR_COLD bool analog_net_t::already_processed(plib::pvector_t<list_t> &groups) { if (isRailNet()) return true; @@ -878,7 +878,7 @@ ATTR_COLD bool analog_net_t::already_processed(pvector_t<list_t> &groups) return false; } -ATTR_COLD void analog_net_t::process_net(pvector_t<list_t> &groups) +ATTR_COLD void analog_net_t::process_net(plib::pvector_t<list_t> &groups) { if (num_cons() == 0) return; diff --git a/src/lib/netlist/nl_base.h b/src/lib/netlist/nl_base.h index 458dde6d3c8..cae0b1ae629 100644 --- a/src/lib/netlist/nl_base.h +++ b/src/lib/netlist/nl_base.h @@ -250,11 +250,11 @@ class NETLIB_NAME(_name) : public device_t //============================================================ #if defined(MAME_DEBUG) -#define nl_assert(x) do { if (1) if (!(x)) throw fatalerror_e(pfmt("assert: {1}:{2}: {3}")(__FILE__)(__LINE__)(#x) ); } while (0) +#define nl_assert(x) do { if (1) if (!(x)) throw fatalerror_e(plib::pfmt("assert: {1}:{2}: {3}")(__FILE__)(__LINE__)(#x) ); } while (0) #else -#define nl_assert(x) do { if (0) if (!(x)) throw fatalerror_e(pfmt("assert: {1}:{2}: {3}")(__FILE__)(__LINE__)(#x) ); } while (0) +#define nl_assert(x) do { if (0) if (!(x)) throw fatalerror_e(plib::pfmt("assert: {1}:{2}: {3}")(__FILE__)(__LINE__)(#x) ); } while (0) #endif -#define nl_assert_always(x, msg) do { if (!(x)) throw fatalerror_e(pfmt("Fatal error: {1}\nCaused by assert: {2}:{3}: {4}")(msg)(__FILE__)(__LINE__)(#x)); } while (0) +#define nl_assert_always(x, msg) do { if (!(x)) throw fatalerror_e(plib::pfmt("Fatal error: {1}\nCaused by assert: {2}:{3}: {4}")(msg)(__FILE__)(__LINE__)(#x)); } while (0) // ----------------------------------------------------------------------------- @@ -282,10 +282,10 @@ namespace netlist // Exceptions //============================================================ - class fatalerror_e : public pexception + class fatalerror_e : public plib::pexception { public: - fatalerror_e(const pstring &text) : pexception(text) { } + fatalerror_e(const pstring &text) : plib::pexception(text) { } virtual ~fatalerror_e() throw() {} }; @@ -302,7 +302,7 @@ namespace netlist // model_map_t // ----------------------------------------------------------------------------- - using model_map_t = phashmap_t<pstring, pstring>; + using model_map_t = plib::hashmap_t<pstring, pstring>; // ----------------------------------------------------------------------------- // logic_family_t @@ -313,7 +313,7 @@ namespace netlist public: logic_family_desc_t() {} virtual ~logic_family_desc_t() {} - virtual powned_ptr<devices::nld_base_d_to_a_proxy> create_d_a_proxy(netlist_t &anetlist, const pstring &name, + virtual plib::powned_ptr<devices::nld_base_d_to_a_proxy> create_d_a_proxy(netlist_t &anetlist, const pstring &name, logic_output_t *proxied) const = 0; nl_double m_low_thresh_V; @@ -354,7 +354,7 @@ namespace netlist // object_t // ----------------------------------------------------------------------------- - class object_t : public pstate_interface_t<object_t> + class object_t : public plib::pstate_interface_t<object_t> { P_PREVENT_COPYING(object_t) public: @@ -379,7 +379,7 @@ namespace netlist ATTR_COLD const pstring &name() const; - ATTR_COLD inline pstate_manager_t *state_manager(); + ATTR_COLD inline plib::pstate_manager_t *state_manager(); ATTR_HOT type_t type() const { return m_objtype; } @@ -433,12 +433,12 @@ namespace netlist // core_terminal_t // ----------------------------------------------------------------------------- - class core_terminal_t : public device_object_t, public plinkedlist_element_t<core_terminal_t> + class core_terminal_t : public device_object_t, public plib::plinkedlist_element_t<core_terminal_t> { P_PREVENT_COPYING(core_terminal_t) public: - using list_t = pvector_t<core_terminal_t *>; + using list_t = plib::pvector_t<core_terminal_t *>; /* needed here ... */ @@ -519,7 +519,7 @@ namespace netlist P_PREVENT_COPYING(terminal_t) public: - using list_t = pvector_t<terminal_t *>; + using list_t = plib::pvector_t<terminal_t *>; ATTR_COLD terminal_t(); @@ -668,7 +668,7 @@ namespace netlist public: using ptr_t = net_t *; - using list_t = pvector_t<std::shared_ptr<net_t>>; + using list_t = plib::pvector_t<std::shared_ptr<net_t>>; ATTR_COLD net_t(); virtual ~net_t(); @@ -708,7 +708,7 @@ namespace netlist ATTR_COLD void move_connections(net_t *new_net); - pvector_t<core_terminal_t *> m_core_terms; // save post-start m_list ... + plib::pvector_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) { @@ -731,7 +731,7 @@ namespace netlist private: core_terminal_t * m_railterminal; - plinkedlist_t<core_terminal_t> m_list_active; + plib::linkedlist_t<core_terminal_t> m_list_active; netlist_time m_time; INT32 m_active; @@ -750,7 +750,7 @@ namespace netlist P_PREVENT_COPYING(logic_net_t) public: - using list_t = pvector_t<logic_net_t *>; + using list_t = plib::pvector_t<logic_net_t *>; ATTR_COLD logic_net_t(); virtual ~logic_net_t() { }; @@ -810,7 +810,7 @@ namespace netlist P_PREVENT_COPYING(analog_net_t) public: - using list_t = pvector_t<analog_net_t *>; + using list_t = plib::pvector_t<analog_net_t *>; ATTR_COLD analog_net_t(); ATTR_COLD analog_net_t(netlist_t &nl, const pstring &aname); @@ -829,8 +829,8 @@ namespace netlist ATTR_HOT devices::matrix_solver_t *solver() { return m_solver; } - ATTR_COLD bool already_processed(pvector_t<list_t> &groups); - ATTR_COLD void process_net(pvector_t<list_t> &groups); + ATTR_COLD bool already_processed(plib::pvector_t<list_t> &groups); + ATTR_COLD void process_net(plib::pvector_t<list_t> &groups); protected: @@ -982,7 +982,7 @@ namespace netlist P_PREVENT_COPYING(core_device_t) public: - using list_t = pvector_t<core_device_t *>; + using list_t = plib::pvector_t<core_device_t *>; ATTR_COLD core_device_t(netlist_t &owner, const pstring &name); ATTR_COLD core_device_t(core_device_t &owner, const pstring &name); @@ -1039,7 +1039,7 @@ namespace netlist #if (NL_KEEP_STATISTICS) /* stats */ - pticks_t stat_total_time; + plib::ticks_t stat_total_time; INT32 stat_update_count; INT32 stat_call_count; #endif @@ -1124,7 +1124,7 @@ namespace netlist ATTR_COLD void connect_late(core_terminal_t &t1, core_terminal_t &t2); ATTR_COLD void connect_post_start(core_terminal_t &t1, core_terminal_t &t2); - pvector_t<pstring> m_terminals; + plib::pvector_t<pstring> m_terminals; protected: @@ -1166,7 +1166,7 @@ namespace netlist class queue_t : public timed_queue<net_t *, netlist_time>, public object_t, - public pstate_callback_t + public plib::pstate_callback_t { public: queue_t(netlist_t &nl); @@ -1175,15 +1175,15 @@ namespace netlist void reset() override {} - void register_state(pstate_manager_t &manager, const pstring &module) override; + void register_state(plib::pstate_manager_t &manager, const pstring &module) override; void on_pre_save() override; void on_post_load() override; private: struct names_t { char m_buf[64]; }; int m_qsize; - parray_t<netlist_time::INTERNALTYPE> m_times; - parray_t<names_t> m_names; + plib::array_t<netlist_time::INTERNALTYPE> m_times; + plib::array_t<names_t> m_names; }; // ----------------------------------------------------------------------------- @@ -1191,7 +1191,7 @@ namespace netlist // ----------------------------------------------------------------------------- - class netlist_t : public pstate_manager_t, public plog_dispatch_intf //, public device_owner_t + class netlist_t : public plib::pstate_manager_t, public plib::plog_dispatch_intf //, public device_owner_t { P_PREVENT_COPYING(netlist_t) public: @@ -1227,9 +1227,9 @@ namespace netlist ATTR_COLD net_t *find_net(const pstring &name); template<class _device_class> - ATTR_COLD pvector_t<_device_class *> get_device_list() + ATTR_COLD plib::pvector_t<_device_class *> get_device_list() { - pvector_t<_device_class *> tmp; + plib::pvector_t<_device_class *> tmp; for (auto &d : m_devices) { _device_class *dev = dynamic_cast<_device_class *>(d.get()); @@ -1261,8 +1261,8 @@ namespace netlist pvector_t<core_device_t *> m_started_devices; #endif - ATTR_COLD plog_base<NL_DEBUG> &log() { return m_log; } - ATTR_COLD const plog_base<NL_DEBUG> &log() const { return m_log; } + ATTR_COLD plib::plog_base<NL_DEBUG> &log() { return m_log; } + ATTR_COLD const plib::plog_base<NL_DEBUG> &log() const { return m_log; } virtual void reset(); @@ -1270,7 +1270,7 @@ namespace netlist void print_stats() const; - pvector_t<powned_ptr<core_device_t>> m_devices; + plib::pvector_t<plib::powned_ptr<core_device_t>> m_devices; /* sole use is to manage lifetime of net objects */ net_t::list_t m_nets; @@ -1302,7 +1302,7 @@ protected: pstring m_name; setup_t *m_setup; - plog_base<NL_DEBUG> m_log; + plib::plog_base<NL_DEBUG> m_log; plib::dynlib *m_lib; // external lib needs to be loaded as long as netlist exists }; @@ -1310,7 +1310,7 @@ protected: // inline implementations // ----------------------------------------------------------------------------- - ATTR_COLD inline pstate_manager_t *object_t::state_manager() + ATTR_COLD inline plib::pstate_manager_t *object_t::state_manager() { return m_netlist; } @@ -1478,7 +1478,7 @@ protected: } -NETLIST_SAVE_TYPE(netlist::core_terminal_t::state_e, DT_INT); +NETLIST_SAVE_TYPE(netlist::core_terminal_t::state_e, pstate_data_type_e::DT_INT); #endif /* NLBASE_H_ */ diff --git a/src/lib/netlist/nl_config.h b/src/lib/netlist/nl_config.h index 19648777922..6405c1b356a 100644 --- a/src/lib/netlist/nl_config.h +++ b/src/lib/netlist/nl_config.h @@ -112,7 +112,7 @@ //============================================================ #define NL_DEBUG (false) -#define NL_KEEP_STATISTICS (1) +#define NL_KEEP_STATISTICS (0) //============================================================ // General Macros @@ -129,11 +129,10 @@ //============================================================ #if NL_KEEP_STATISTICS -#include "eminline.h" #define add_to_stat(v,x) do { v += (x); } while (0) #define inc_stat(v) add_to_stat(v, 1) -#define begin_timing(v) do { v -= pprofile_ticks(); } while (0) -#define end_timing(v) do { v += pprofile_ticks(); } while (0) +#define begin_timing(v) do { v -= plib::profile_ticks(); } while (0) +#define end_timing(v) do { v += plib::profile_ticks(); } while (0) #else #define add_to_stat(v,x) do { } while (0) #define inc_stat(v) add_to_stat(v, 1) diff --git a/src/lib/netlist/nl_factory.cpp b/src/lib/netlist/nl_factory.cpp index 8a101f91e68..0b59d0afef4 100644 --- a/src/lib/netlist/nl_factory.cpp +++ b/src/lib/netlist/nl_factory.cpp @@ -18,20 +18,20 @@ namespace netlist // net_device_t_base_factory // ---------------------------------------------------------------------------------------- -ATTR_COLD const pstring_vector_t base_factory_t::term_param_list() +ATTR_COLD const plib::pstring_vector_t base_factory_t::term_param_list() { if (m_def_param.startsWith("+")) - return pstring_vector_t(m_def_param.substr(1), ","); + return plib::pstring_vector_t(m_def_param.substr(1), ","); else - return pstring_vector_t(); + return plib::pstring_vector_t(); } -ATTR_COLD const pstring_vector_t base_factory_t::def_params() +ATTR_COLD const plib::pstring_vector_t base_factory_t::def_params() { if (m_def_param.startsWith("+") || m_def_param.equals("-")) - return pstring_vector_t(); + return plib::pstring_vector_t(); else - return pstring_vector_t(m_def_param, ","); + return plib::pstring_vector_t(m_def_param, ","); } @@ -67,7 +67,7 @@ void factory_list_t::error(const pstring &s) m_setup.log().fatal("{1}", s); } -powned_ptr<device_t> factory_list_t::new_device_by_name(const pstring &devname, netlist_t &anetlist, const pstring &name) +plib::powned_ptr<device_t> factory_list_t::new_device_by_name(const pstring &devname, netlist_t &anetlist, const pstring &name) { base_factory_t *f = factory_by_name(devname); return f->Create(anetlist, name); diff --git a/src/lib/netlist/nl_factory.h b/src/lib/netlist/nl_factory.h index a0a4dcdf214..0da6dfd9cc4 100644 --- a/src/lib/netlist/nl_factory.h +++ b/src/lib/netlist/nl_factory.h @@ -32,13 +32,13 @@ namespace netlist virtual ~base_factory_t() {} - virtual powned_ptr<device_t> Create(netlist_t &anetlist, const pstring &name) = 0; + virtual plib::powned_ptr<device_t> Create(netlist_t &anetlist, const pstring &name) = 0; const pstring &name() const { return m_name; } const pstring &classname() const { return m_classname; } const pstring ¶m_desc() const { return m_def_param; } - const pstring_vector_t term_param_list(); - const pstring_vector_t def_params(); + const plib::pstring_vector_t term_param_list(); + const plib::pstring_vector_t def_params(); protected: pstring m_name; /* device name */ @@ -55,14 +55,14 @@ namespace netlist const pstring &def_param) : base_factory_t(name, classname, def_param) { } - powned_ptr<device_t> Create(netlist_t &anetlist, const pstring &name) override + plib::powned_ptr<device_t> Create(netlist_t &anetlist, const pstring &name) override { - return powned_ptr<device_t>::Create<_device_class>(anetlist, name); + return plib::powned_ptr<device_t>::Create<_device_class>(anetlist, name); } }; - class factory_list_t : public pvector_t<powned_ptr<base_factory_t>> + class factory_list_t : public plib::pvector_t<plib::powned_ptr<base_factory_t>> { public: factory_list_t(setup_t &m_setup); @@ -72,10 +72,10 @@ namespace netlist void register_device(const pstring &name, const pstring &classname, const pstring &def_param) { - register_device(powned_ptr<base_factory_t>::Create<factory_t<_device_class>>(name, classname, def_param)); + register_device(plib::powned_ptr<base_factory_t>::Create<factory_t<_device_class>>(name, classname, def_param)); } - void register_device(powned_ptr<base_factory_t> factory) + void register_device(plib::powned_ptr<base_factory_t> factory) { for (auto & e : *this) if (e->name() == factory->name()) @@ -85,7 +85,7 @@ namespace netlist //ATTR_COLD device_t *new_device_by_classname(const pstring &classname) const; // FIXME: legacy, should use factory_by_name - powned_ptr<device_t> new_device_by_name(const pstring &devname, netlist_t &anetlist, const pstring &name); + plib::powned_ptr<device_t> new_device_by_name(const pstring &devname, netlist_t &anetlist, const pstring &name); base_factory_t * factory_by_name(const pstring &devname); template <class _class> diff --git a/src/lib/netlist/nl_lists.h b/src/lib/netlist/nl_lists.h index 6eaca97906f..519a0b55106 100644 --- a/src/lib/netlist/nl_lists.h +++ b/src/lib/netlist/nl_lists.h @@ -167,7 +167,7 @@ namespace netlist volatile std::atomic<int> m_lock; #endif entry_t * m_end; - parray_t<entry_t> m_list; + plib::array_t<entry_t> m_list; }; } diff --git a/src/lib/netlist/nl_parser.cpp b/src/lib/netlist/nl_parser.cpp index 41060df73e6..2aa4366b0ba 100644 --- a/src/lib/netlist/nl_parser.cpp +++ b/src/lib/netlist/nl_parser.cpp @@ -158,7 +158,7 @@ void parser_t::net_truthtable_start() pstring def_param = get_string(); require_token(m_tok_param_right); - powned_ptr<netlist::devices::netlist_base_factory_truthtable_t> ttd = netlist::devices::nl_tt_factory_create(ni, no, hs, + plib::powned_ptr<netlist::devices::netlist_base_factory_truthtable_t> ttd = netlist::devices::nl_tt_factory_create(ni, no, hs, name, name, "+" + def_param); while (true) @@ -287,14 +287,14 @@ void parser_t::net_c() if (n.is(m_tok_param_right)) break; if (!n.is(m_tok_comma)) - error(pfmt("expected a comma, found <{1}>")(n.str()) ); + error(plib::pfmt("expected a comma, found <{1}>")(n.str()) ); } } void parser_t::dippins() { - pstring_vector_t pins; + plib::pstring_vector_t pins; pins.push_back(get_identifier()); require_token(m_tok_comma); @@ -307,15 +307,15 @@ void parser_t::dippins() if (n.is(m_tok_param_right)) break; if (!n.is(m_tok_comma)) - error(pfmt("expected a comma, found <{1}>")(n.str()) ); + error(plib::pfmt("expected a comma, found <{1}>")(n.str()) ); } if ((pins.size() % 2) == 1) error("You must pass an equal number of pins to DIPPINS"); unsigned n = pins.size(); for (unsigned i = 0; i < n / 2; i++) { - m_setup.register_alias(pfmt("{1}")(i+1), pins[i*2]); - m_setup.register_alias(pfmt("{1}")(n-i), pins[i*2 + 1]); + m_setup.register_alias(plib::pfmt("{1}")(i+1), pins[i*2]); + m_setup.register_alias(plib::pfmt("{1}")(n-i), pins[i*2 + 1]); } } @@ -352,8 +352,8 @@ void parser_t::device(const pstring &dev_type) else { base_factory_t *f = m_setup.factory().factory_by_name(dev_type); - pstring_vector_t termlist = f->term_param_list(); - pstring_vector_t def_params = f->def_params(); + plib::pstring_vector_t termlist = f->term_param_list(); + plib::pstring_vector_t def_params = f->def_params(); std::size_t cnt; diff --git a/src/lib/netlist/nl_parser.h b/src/lib/netlist/nl_parser.h index 2a6cc79ad2b..dc30ff056a0 100644 --- a/src/lib/netlist/nl_parser.h +++ b/src/lib/netlist/nl_parser.h @@ -14,12 +14,12 @@ namespace netlist { - class parser_t : public ptokenizer + class parser_t : public plib::ptokenizer { P_PREVENT_COPYING(parser_t) public: - parser_t(pistream &strm, setup_t &setup) - : ptokenizer(strm), m_setup(setup), m_buf(nullptr) {} + parser_t(plib::pistream &strm, setup_t &setup) + : plib::ptokenizer(strm), m_setup(setup), m_buf(nullptr) {} bool parse(const pstring nlname = ""); diff --git a/src/lib/netlist/nl_setup.cpp b/src/lib/netlist/nl_setup.cpp index 67948034bc8..4c8832cb59d 100644 --- a/src/lib/netlist/nl_setup.cpp +++ b/src/lib/netlist/nl_setup.cpp @@ -100,7 +100,7 @@ void setup_t::namespace_pop() } -void setup_t::register_dev(powned_ptr<device_t> dev) +void setup_t::register_dev(plib::powned_ptr<device_t> dev) { for (auto & d : netlist().m_devices) if (d->name() == dev->name()) @@ -171,14 +171,14 @@ void setup_t::register_alias(const pstring &alias, const pstring &out) void setup_t::register_dippins_arr(const pstring &terms) { - pstring_vector_t list(terms,", "); + plib::pstring_vector_t list(terms,", "); if (list.size() == 0 || (list.size() % 2) == 1) log().fatal("You must pass an equal number of pins to DIPPINS"); unsigned n = list.size(); for (unsigned i = 0; i < n / 2; i++) { - register_alias(pfmt("{1}")(i+1), list[i * 2]); - register_alias(pfmt("{1}")(n-i), list[i * 2 + 1]); + register_alias(plib::pfmt("{1}")(i+1), list[i * 2]); + register_alias(plib::pfmt("{1}")(n-i), list[i * 2 + 1]); } } @@ -307,7 +307,7 @@ void setup_t::register_object(device_t &dev, const pstring &name, object_t &obj) void setup_t::register_link_arr(const pstring &terms) { - pstring_vector_t list(terms,", "); + plib::pstring_vector_t list(terms,", "); if (list.size() < 2) log().fatal("You must pass at least 2 terminals to NET_C"); for (std::size_t i = 1; i < list.size(); i++) @@ -351,7 +351,7 @@ void setup_t::remove_connections(const pstring pin) void setup_t::register_frontier(const pstring attach, const double r_IN, const double r_OUT) { - pstring frontier_name = pfmt("frontier_{1}")(m_frontier_cnt); + pstring frontier_name = plib::pfmt("frontier_{1}")(m_frontier_cnt); m_frontier_cnt++; register_dev("FRONTIER_DEV", frontier_name); register_param(frontier_name + ".RIN", r_IN); @@ -382,7 +382,7 @@ void setup_t::register_frontier(const pstring attach, const double r_IN, const d void setup_t::register_param(const pstring ¶m, const double value) { // FIXME: there should be a better way - register_param(param, pfmt("{1}").e(value,".9")); + register_param(param, plib::pfmt("{1}").e(value,".9")); } void setup_t::register_param(const pstring ¶m, const pstring &value) @@ -496,7 +496,7 @@ devices::nld_base_proxy *setup_t::get_d_a_proxy(core_terminal_t &out) if (proxy == nullptr) { // create a new one ... - pstring x = pfmt("proxy_da_{1}_{2}")(out.name())(m_proxy_cnt); + pstring x = plib::pfmt("proxy_da_{1}_{2}")(out.name())(m_proxy_cnt); auto new_proxy = out_cast.logic_family()->create_d_a_proxy(netlist(), x, &out_cast); m_proxy_cnt++; @@ -528,8 +528,8 @@ void setup_t::connect_input_output(core_terminal_t &in, core_terminal_t &out) if (out.is_analog() && in.is_logic()) { logic_input_t &incast = dynamic_cast<logic_input_t &>(in); - pstring x = pfmt("proxy_ad_{1}_{2}")(in.name())( m_proxy_cnt); - auto proxy = powned_ptr<devices::nld_a_to_d_proxy>::Create(netlist(), x, &incast); + pstring x = plib::pfmt("proxy_ad_{1}_{2}")(in.name())( m_proxy_cnt); + auto proxy = plib::powned_ptr<devices::nld_a_to_d_proxy>::Create(netlist(), x, &incast); incast.set_proxy(proxy.get()); m_proxy_cnt++; @@ -566,8 +566,8 @@ void setup_t::connect_terminal_input(terminal_t &term, core_terminal_t &inp) { logic_input_t &incast = dynamic_cast<logic_input_t &>(inp); log().debug("connect_terminal_input: connecting proxy\n"); - pstring x = pfmt("proxy_ad_{1}_{2}")(inp.name())(m_proxy_cnt); - auto proxy = powned_ptr<devices::nld_a_to_d_proxy>::Create(netlist(), x, &incast); + pstring x = plib::pfmt("proxy_ad_{1}_{2}")(inp.name())(m_proxy_cnt); + auto proxy = plib::powned_ptr<devices::nld_a_to_d_proxy>::Create(netlist(), x, &incast); incast.set_proxy(proxy.get()); m_proxy_cnt++; @@ -632,7 +632,7 @@ void setup_t::connect_terminals(core_terminal_t &t1, core_terminal_t &t2) { log().debug("adding analog net ...\n"); // FIXME: Nets should have a unique name - analog_net_t::ptr_t anet = palloc<analog_net_t>(netlist(),"net." + t1.name()); + analog_net_t::ptr_t anet = plib::palloc<analog_net_t>(netlist(),"net." + t1.name()); t1.set_net(anet); anet->register_con(t2); anet->register_con(t1); @@ -802,7 +802,7 @@ void setup_t::resolve_inputs() if (!term->has_net() && dynamic_cast< devices::NETLIB_NAME(dummy_input) *>(&term->device()) != nullptr) log().warning("Found dummy terminal {1} without connections", term->name()); else if (!term->has_net()) - errstr += pfmt("Found terminal {1} without a net\n")(term->name()); + errstr += plib::pfmt("Found terminal {1} without a net\n")(term->name()); else if (term->net().num_cons() == 0) log().warning("Found terminal {1} without connections", term->name()); } @@ -849,7 +849,7 @@ void setup_t::start_devices() if (env != "") { log().debug("Creating dynamic logs ...\n"); - pstring_vector_t loglist(env, ":"); + plib::pstring_vector_t loglist(env, ":"); for (pstring ll : loglist) { pstring name = "log_" + ll; @@ -872,10 +872,10 @@ class logic_family_std_proxy_t : public logic_family_desc_t { public: logic_family_std_proxy_t() { } - virtual powned_ptr<devices::nld_base_d_to_a_proxy> create_d_a_proxy(netlist_t &anetlist, + virtual plib::powned_ptr<devices::nld_base_d_to_a_proxy> create_d_a_proxy(netlist_t &anetlist, const pstring &name, logic_output_t *proxied) const override { - return powned_ptr<devices::nld_base_d_to_a_proxy>::Create<devices::nld_d_to_a_proxy>(anetlist, name, proxied); + return plib::powned_ptr<devices::nld_base_d_to_a_proxy>::Create<devices::nld_d_to_a_proxy>(anetlist, name, proxied); } }; @@ -893,7 +893,7 @@ const logic_family_desc_t *setup_t::family_from_model(const pstring &model) if (e.first == model) return e.second.get(); - auto ret = make_unique_base<logic_family_desc_t, logic_family_std_proxy_t>(); + auto ret = plib::make_unique_base<logic_family_desc_t, logic_family_std_proxy_t>(); ret->m_low_thresh_V = setup_t::model_value(map, "IVL"); ret->m_high_thresh_V = setup_t::model_value(map, "IVH"); @@ -952,7 +952,7 @@ void setup_t::model_parse(const pstring &model_in, model_map_t &map) log().fatal("Model error {1}\n", model); remainder = remainder.left(remainder.len() - 1); - pstring_vector_t pairs(remainder," ", true); + plib::pstring_vector_t pairs(remainder," ", true); for (pstring &pe : pairs) { int pose = pe.find("="); @@ -994,7 +994,7 @@ nl_double setup_t::model_value(model_map_t &map, const pstring &entity) case 'a': factor = 1e-18; break; default: if (numfac < "0" || numfac > "9") - fatalerror_e(pfmt("Unknown number factor <{1}> in: {2}")(numfac)(entity)); + fatalerror_e(plib::pfmt("Unknown number factor <{1}> in: {2}")(numfac)(entity)); } if (factor != NL_FCONST(1.0)) tmp = tmp.left(tmp.len() - 1); @@ -1021,28 +1021,28 @@ void setup_t::include(const pstring &netlist_name) bool source_string_t::parse(setup_t &setup, const pstring &name) { - pimemstream istrm(m_str.cstr(), m_str.len()); - pomemstream ostrm; + plib::pimemstream istrm(m_str.cstr(), m_str.len()); + plib::pomemstream ostrm; - pimemstream istrm2(ppreprocessor().process(istrm, ostrm)); + plib::pimemstream istrm2(plib::ppreprocessor().process(istrm, ostrm)); return parser_t(istrm2, setup).parse(name); } bool source_mem_t::parse(setup_t &setup, const pstring &name) { - pimemstream istrm(m_str.cstr(), m_str.len()); - pomemstream ostrm; + plib::pimemstream istrm(m_str.cstr(), m_str.len()); + plib::pomemstream ostrm; - pimemstream istrm2(ppreprocessor().process(istrm, ostrm)); + plib::pimemstream istrm2(plib::ppreprocessor().process(istrm, ostrm)); return parser_t(istrm2, setup).parse(name); } bool source_file_t::parse(setup_t &setup, const pstring &name) { - pifilestream istrm(m_filename); - pomemstream ostrm; + plib::pifilestream istrm(m_filename); + plib::pomemstream ostrm; - pimemstream istrm2(ppreprocessor().process(istrm, ostrm)); + plib::pimemstream istrm2(plib::ppreprocessor().process(istrm, ostrm)); return parser_t(istrm2, setup).parse(name); } diff --git a/src/lib/netlist/nl_setup.h b/src/lib/netlist/nl_setup.h index c795cba818b..4b9df80cc69 100644 --- a/src/lib/netlist/nl_setup.h +++ b/src/lib/netlist/nl_setup.h @@ -90,7 +90,7 @@ namespace netlist class source_t { public: - using list_t = pvector_t<std::shared_ptr<source_t>>; + using list_t = plib::pvector_t<std::shared_ptr<source_t>>; source_t() {} @@ -116,13 +116,13 @@ namespace netlist void register_object(device_t &dev, const pstring &name, object_t &obj); template<class NETLIST_X> - void register_dev_s(powned_ptr<NETLIST_X> dev) + void register_dev_s(plib::powned_ptr<NETLIST_X> dev) { register_dev(std::move(dev)); } - void register_dev(powned_ptr<device_t> dev); + void register_dev(plib::powned_ptr<device_t> dev); void register_dev(const pstring &classname, const pstring &name); void register_lib_entry(const pstring &name); @@ -183,10 +183,10 @@ namespace netlist void model_parse(const pstring &model, model_map_t &map); - plog_base<NL_DEBUG> &log() { return netlist().log(); } - const plog_base<NL_DEBUG> &log() const { return netlist().log(); } + plib::plog_base<NL_DEBUG> &log() { return netlist().log(); } + const plib::plog_base<NL_DEBUG> &log() const { return netlist().log(); } - pvector_t<std::pair<pstring, base_factory_t *>> m_device_factory; + plib::pvector_t<std::pair<pstring, base_factory_t *>> m_device_factory; protected: @@ -209,23 +209,23 @@ namespace netlist netlist_t &m_netlist; - phashmap_t<pstring, pstring> m_alias; - phashmap_t<pstring, param_ref_t> m_params; - phashmap_t<pstring, pstring> m_param_values; - phashmap_t<pstring, core_terminal_t *> m_terminals; + plib::hashmap_t<pstring, pstring> m_alias; + plib::hashmap_t<pstring, param_ref_t> m_params; + plib::hashmap_t<pstring, pstring> m_param_values; + plib::hashmap_t<pstring, core_terminal_t *> m_terminals; - pvector_t<link_t> m_links; + plib::pvector_t<link_t> m_links; factory_list_t m_factory; - phashmap_t<pstring, pstring> m_models; + plib::hashmap_t<pstring, pstring> m_models; int m_proxy_cnt; int m_frontier_cnt; std::stack<pstring> m_namespace_stack; source_t::list_t m_sources; - pvector_t<pstring> m_lib; + plib::pvector_t<pstring> m_lib; }; diff --git a/src/lib/netlist/nl_time.h b/src/lib/netlist/nl_time.h index fed3bc48cb1..bacd15f6768 100644 --- a/src/lib/netlist/nl_time.h +++ b/src/lib/netlist/nl_time.h @@ -37,7 +37,7 @@ namespace netlist static const pstate_data_type_e STATETYPE = DT_INT128; #else using INTERNALTYPE = UINT64; - static const pstate_data_type_e STATETYPE = DT_INT64; + static const pstate_data_type_e STATETYPE = pstate_data_type_e::DT_INT64; #endif static const INTERNALTYPE RESOLUTION = NETLIST_INTERNAL_RES; @@ -137,10 +137,11 @@ namespace netlist } +PLIB_NAMESPACE_START() template<> ATTR_COLD inline void pstate_manager_t::save_item(netlist::netlist_time &nlt, const void *owner, const pstring &stname) { save_state_ptr(stname, netlist::netlist_time::STATETYPE, owner, sizeof(netlist::netlist_time::INTERNALTYPE), 1, nlt.get_internaltype_ptr(), false); } - +PLIB_NAMESPACE_END() #endif /* NLTIME_H_ */ diff --git a/src/lib/netlist/nl_util.h b/src/lib/netlist/nl_util.h index f25a0d13320..41eb7d2169f 100644 --- a/src/lib/netlist/nl_util.h +++ b/src/lib/netlist/nl_util.h @@ -123,89 +123,6 @@ public: }; -template <typename _SC> -class powned_ptr -{ -private: - powned_ptr() - : m_ptr(nullptr), m_is_owned(true) { } -public: - powned_ptr(_SC *p, bool owned) - : m_ptr(p), m_is_owned(owned) - { } - powned_ptr(const powned_ptr &r) = delete; - powned_ptr & operator =(const powned_ptr &r) = delete; - - powned_ptr(powned_ptr &&r) - { - m_is_owned = r.m_is_owned; - m_ptr = r.m_ptr; - r.m_is_owned = false; - r.m_ptr = nullptr; - } - - template<typename _DC> - powned_ptr(powned_ptr<_DC> &&r) - { - _SC *dest_ptr = &dynamic_cast<_SC &>(*r.get()); - bool o = r.is_owned(); - r.release(); - m_is_owned = o; - m_ptr = dest_ptr; - } - - ~powned_ptr() - { - if (m_is_owned) - delete m_ptr; - } - template<typename _DC, typename... _Args> - static powned_ptr Create(_Args&&... __args) - { - powned_ptr a; - _DC *x = new _DC(std::forward<_Args>(__args)...); - a.m_ptr = static_cast<_SC *>(x); - return a; - } - - template<typename... _Args> - static powned_ptr Create(_Args&&... __args) - { - powned_ptr a; - a.m_ptr = new _SC(std::forward<_Args>(__args)...); - return a; - } - void release() - { - m_is_owned = false; - m_ptr = nullptr; - } - - bool is_owned() const { return m_is_owned; } - - template<typename _DC> - powned_ptr<_DC> & operator =(powned_ptr<_DC> &r) - { - m_is_owned = r.m_is_owned; - m_ptr = r.m_ptr; - r.m_is_owned = false; - r.m_ptr = nullptr; - return *this; - } - _SC * operator ->() { return m_ptr; } - _SC & operator *() { return *m_ptr; } - _SC * get() const { return m_ptr; } -private: - _SC *m_ptr; - bool m_is_owned; -}; - -template<typename _BC, typename _DC, typename... _Args> -static std::unique_ptr<_BC> make_unique_base(_Args&&... __args) -{ - std::unique_ptr<_BC> ret(new _DC(std::forward<_Args>(__args)...)); - return ret; -} #endif /* NL_UTIL_H_ */ diff --git a/src/lib/netlist/plib/palloc.cpp b/src/lib/netlist/plib/palloc.cpp index eeaeb99293f..c3d674f7519 100644 --- a/src/lib/netlist/plib/palloc.cpp +++ b/src/lib/netlist/plib/palloc.cpp @@ -9,6 +9,9 @@ #include "pconfig.h" #include "palloc.h" + +PLIB_NAMESPACE_START() + //============================================================ // Exceptions //============================================================ @@ -91,3 +94,5 @@ void pmempool::free(void *ptr) } b->m_num_alloc--; } + +PLIB_NAMESPACE_END() diff --git a/src/lib/netlist/plib/palloc.h b/src/lib/netlist/plib/palloc.h index 4d0870e525a..bd994466226 100644 --- a/src/lib/netlist/plib/palloc.h +++ b/src/lib/netlist/plib/palloc.h @@ -16,6 +16,28 @@ #include "pconfig.h" #include "pstring.h" +#if (PSTANDALONE) +#include <cstddef> +#include <new> + +#if defined(__GNUC__) && (__GNUC__ > 4) || ((__GNUC__ == 4) && (__GNUC_MINOR__ >= 3)) +#if !defined(__ppc__) && !defined (__PPC__) && !defined(__ppc64__) && !defined(__PPC64__) +#define ATTR_ALIGN __attribute__ ((aligned(64))) +#else +#define ATTR_ALIGN +#endif +#else +#define ATTR_ALIGN +#endif + +#else + +#define ATTR_ALIGN + +#endif + +PLIB_NAMESPACE_START() + //============================================================ // exception base //============================================================ @@ -36,29 +58,6 @@ private: // Memory allocation //============================================================ -#if (PSTANDALONE) -#include <cstddef> -#include <new> - -#if defined(__GNUC__) && (__GNUC__ > 4) || ((__GNUC__ == 4) && (__GNUC_MINOR__ >= 3)) -#if !defined(__ppc__) && !defined (__PPC__) && !defined(__ppc64__) && !defined(__PPC64__) -#define ATTR_ALIGN __attribute__ ((aligned(64))) -#else -#define ATTR_ALIGN -#endif -#else -#define ATTR_ALIGN -#endif - -#define palloc(T) new T -#define pfree(_ptr) delete _ptr - -#define palloc_array(T, N) new T[N] -#define pfree_array(_ptr) delete[] _ptr -#else - -#define ATTR_ALIGN - template<typename T, typename... Args> T *palloc(Args&&... args) { @@ -77,13 +76,95 @@ inline T* palloc_array(std::size_t num) template<typename T> void pfree_array(T *ptr) { delete [] ptr; } -#endif - template<typename T, typename... Args> std::unique_ptr<T> pmake_unique(Args&&... args) { return std::unique_ptr<T>(new T(std::forward<Args>(args)...)); } +template<typename BC, typename DC, typename... Args> +static std::unique_ptr<BC> make_unique_base(Args&&... args) +{ + std::unique_ptr<BC> ret(new DC(std::forward<Args>(args)...)); + return ret; +} + +template <typename SC> +class powned_ptr +{ +private: + powned_ptr() + : m_ptr(nullptr), m_is_owned(true) { } +public: + powned_ptr(SC *p, bool owned) + : m_ptr(p), m_is_owned(owned) + { } + powned_ptr(const powned_ptr &r) = delete; + powned_ptr & operator =(const powned_ptr &r) = delete; + + powned_ptr(powned_ptr &&r) + { + m_is_owned = r.m_is_owned; + m_ptr = r.m_ptr; + r.m_is_owned = false; + r.m_ptr = nullptr; + } + + template<typename DC> + powned_ptr(powned_ptr<DC> &&r) + { + SC *dest_ptr = &dynamic_cast<SC &>(*r.get()); + bool o = r.is_owned(); + r.release(); + m_is_owned = o; + m_ptr = dest_ptr; + } + + ~powned_ptr() + { + if (m_is_owned) + delete m_ptr; + } + template<typename DC, typename... Args> + static powned_ptr Create(Args&&... args) + { + powned_ptr a; + DC *x = new DC(std::forward<Args>(args)...); + a.m_ptr = static_cast<SC *>(x); + return a; + } + + template<typename... Args> + static powned_ptr Create(Args&&... args) + { + powned_ptr a; + a.m_ptr = new SC(std::forward<Args>(args)...); + return a; + } + void release() + { + m_is_owned = false; + m_ptr = nullptr; + } + + bool is_owned() const { return m_is_owned; } + + template<typename DC> + powned_ptr<DC> & operator =(powned_ptr<DC> &r) + { + m_is_owned = r.m_is_owned; + m_ptr = r.m_ptr; + r.m_is_owned = false; + r.m_ptr = nullptr; + return *this; + } + SC * operator ->() { return m_ptr; } + SC & operator *() { return *m_ptr; } + SC * get() const { return m_ptr; } +private: + SC *m_ptr; + bool m_is_owned; +}; + class pmempool { private: @@ -117,5 +198,6 @@ public: std::vector<block> m_blocks; }; +PLIB_NAMESPACE_END() -#endif /* NLCONFIG_H_ */ +#endif /* PALLOC_H_ */ diff --git a/src/lib/netlist/plib/pconfig.h b/src/lib/netlist/plib/pconfig.h index 787bcede422..647918aefc8 100644 --- a/src/lib/netlist/plib/pconfig.h +++ b/src/lib/netlist/plib/pconfig.h @@ -139,27 +139,30 @@ typedef int64_t INT64; #endif -using pticks_t = INT64; +PLIB_NAMESPACE_START() -inline pticks_t pticks() +using ticks_t = INT64; + +static inline ticks_t ticks() { return std::chrono::high_resolution_clock::now().time_since_epoch().count(); } -inline pticks_t pticks_per_second() +static inline ticks_t ticks_per_second() { return std::chrono::high_resolution_clock::period::den / std::chrono::high_resolution_clock::period::num; } -#if 1 && defined(__x86_64__) +#if defined(__x86_64__) && !defined(__clang__) && !defined(_MSC_VER) && (__GNUC__ > 4 || (__GNUC__ == 4 && __GNUC_MINOR__ > 6)) -static inline pticks_t pprofile_ticks() +static inline ticks_t profile_ticks() { unsigned hi, lo; __asm__ __volatile__ ("rdtsc" : "=a"(lo), "=d"(hi)); return ( (unsigned long long)lo)|( ((unsigned long long)hi)<<32 ); } + #else -inline pticks_t pprofile_ticks() { return pticks(); } +static inline ticks_t profile_ticks() { return ticks(); } #endif /* @@ -168,7 +171,7 @@ inline pticks_t pprofile_ticks() { return pticks(); } */ #if (PHAS_PMF_INTERNAL) -class pmfp +class mfp { public: // construct from any member function pointer @@ -176,10 +179,10 @@ public: using generic_function = void (*)(); template<typename _MemberFunctionType> - pmfp(_MemberFunctionType mfp) + mfp(_MemberFunctionType mftp) : m_function(0), m_this_delta(0) { - *reinterpret_cast<_MemberFunctionType *>(this) = mfp; + *reinterpret_cast<_MemberFunctionType *>(this) = mftp; } // binding helper @@ -190,9 +193,9 @@ public: convert_to_generic(reinterpret_cast<generic_class *>(object))); } template<typename _FunctionType, typename _MemberFunctionType, typename _ObjectType> - static _FunctionType get_mfp(_MemberFunctionType mfp, _ObjectType *object) + static _FunctionType get_mfp(_MemberFunctionType mftp, _ObjectType *object) { - pmfp mfpo(mfp); + mfp mfpo(mftp); return mfpo.update_after_bind<_FunctionType>(object); } @@ -218,6 +221,9 @@ private: // if odd, it's the byte offset into the vtable int m_this_delta; // delta to apply to the 'this' pointer }; + +PLIB_NAMESPACE_END() + #endif #endif /* PCONFIG_H_ */ diff --git a/src/lib/netlist/plib/pfmtlog.cpp b/src/lib/netlist/plib/pfmtlog.cpp index d2388efad73..90e743b8125 100644 --- a/src/lib/netlist/plib/pfmtlog.cpp +++ b/src/lib/netlist/plib/pfmtlog.cpp @@ -16,6 +16,8 @@ #include "pfmtlog.h" #include "palloc.h" +PLIB_NAMESPACE_START() + pfmt::pfmt(const pstring &fmt) : m_str(m_str_buf), m_allocated(0), m_arg(0) { @@ -161,4 +163,7 @@ void pfmt::format_element(const char *f, const char *l, const char *fmt_spec, . } va_end(ap); } + +PLIB_NAMESPACE_END() + #endif diff --git a/src/lib/netlist/plib/pfmtlog.h b/src/lib/netlist/plib/pfmtlog.h index d72bdc6ce6b..118d7a1f598 100644 --- a/src/lib/netlist/plib/pfmtlog.h +++ b/src/lib/netlist/plib/pfmtlog.h @@ -14,6 +14,8 @@ #include "pstring.h" #include "ptypes.h" +PLIB_NAMESPACE_START() + template <typename T> struct ptype_treats { @@ -293,4 +295,7 @@ void plog_channel<L, build_enabled>::vdowrite(const pstring &ls) const m_base->vlog(L, ls); } +PLIB_NAMESPACE_END() + + #endif /* _PSTRING_H_ */ diff --git a/src/lib/netlist/plib/plists.h b/src/lib/netlist/plib/plists.h index a33d3c27737..c2a4f44565a 100644 --- a/src/lib/netlist/plib/plists.h +++ b/src/lib/netlist/plib/plists.h @@ -19,22 +19,24 @@ #include "palloc.h" #include "pstring.h" +PLIB_NAMESPACE_START() + // ---------------------------------------------------------------------------------------- // parray_t: dynamic array // ---------------------------------------------------------------------------------------- -template <class _ListClass> -class parray_t +template <class LC> +class array_t { public: - ATTR_COLD parray_t(std::size_t numElements) + ATTR_COLD array_t(std::size_t numElements) : m_list(0), m_capacity(0) { set_capacity(numElements); } - ATTR_COLD parray_t(const parray_t &rhs) + ATTR_COLD array_t(const array_t &rhs) : m_list(0), m_capacity(0) { set_capacity(rhs.size()); @@ -42,7 +44,7 @@ public: m_list[i] = rhs[i]; } - ATTR_COLD parray_t &operator=(const parray_t &rhs) + ATTR_COLD array_t &operator=(const array_t &rhs) { set_capacity(rhs.size()); for (std::size_t i=0; i<m_capacity; i++) @@ -50,15 +52,15 @@ public: return *this; } - ~parray_t() + ~array_t() { if (m_list != nullptr) pfree_array(m_list); m_list = nullptr; } - ATTR_HOT _ListClass& operator[](const std::size_t index) { return m_list[index]; } - ATTR_HOT const _ListClass& operator[](const std::size_t index) const { return m_list[index]; } + ATTR_HOT LC& operator[](const std::size_t index) { return m_list[index]; } + ATTR_HOT const LC& operator[](const std::size_t index) const { return m_list[index]; } ATTR_HOT std::size_t size() const { return m_capacity; } @@ -73,7 +75,7 @@ protected: if (m_list != nullptr) pfree_array(m_list); if (new_capacity > 0) - m_list = palloc_array<_ListClass>(new_capacity); + m_list = palloc_array<LC>(new_capacity); else m_list = nullptr; m_capacity = new_capacity; @@ -81,7 +83,7 @@ protected: private: - _ListClass * m_list; + LC * m_list; int m_capacity; }; @@ -89,32 +91,32 @@ private: // plist_t: a simple list // ---------------------------------------------------------------------------------------- -template <typename _ListClass> -class pvector_t : public std::vector<_ListClass> +template <typename LC> +class pvector_t : public std::vector<LC> { public: - pvector_t() : std::vector<_ListClass>() {} + pvector_t() : std::vector<LC>() {} void clear_and_free() { - for (_ListClass i : *this) + for (LC i : *this) { pfree(i); } this->clear(); } - bool contains(const _ListClass &elem) const + bool contains(const LC &elem) const { return (std::find(this->begin(), this->end(), elem) != this->end()); } - void remove(const _ListClass &elem) + void remove(const LC &elem) { this->erase(std::remove(this->begin(), this->end(), elem), this->end()); } - ATTR_HOT void insert_at(const std::size_t index, const _ListClass &elem) + ATTR_HOT void insert_at(const std::size_t index, const LC &elem) { this->insert(this->begin() + index, elem); } @@ -124,7 +126,7 @@ public: this->erase(this->begin() + pos); } - int indexof(const _ListClass &elem) const + int indexof(const LC &elem) const { for (unsigned i = 0; i < this->size(); i++) { @@ -141,33 +143,33 @@ public: // the list allows insertions / deletions if used properly // ---------------------------------------------------------------------------------------- -template <class _ListClass> -class plinkedlist_t; +template <class LC> +class linkedlist_t; #if 1 -template <class _ListClass> +template <class LC> struct plinkedlist_element_t { public: - friend class plinkedlist_t<_ListClass>; + friend class linkedlist_t<LC>; plinkedlist_element_t() : m_next(nullptr) {} - _ListClass *next() const { return m_next; } + LC *next() const { return m_next; } //private: - _ListClass * m_next; + LC * m_next; }; -template <class _ListClass> -class plinkedlist_t +template <class LC> +class linkedlist_t { public: - plinkedlist_t() : m_head(nullptr) {} + linkedlist_t() : m_head(nullptr) {} #if 0 - ATTR_HOT void insert(const _ListClass &before, _ListClass &elem) + ATTR_HOT void insert(const LC &before, LC &elem) { if (m_head == &before) { @@ -176,7 +178,7 @@ public: } else { - _ListClass *p = m_head; + LC *p = m_head; while (p != nullptr) { if (p->m_next == &before) @@ -191,15 +193,15 @@ public: } } #endif - ATTR_HOT void insert(_ListClass &elem) + ATTR_HOT void insert(LC &elem) { elem.m_next = m_head; m_head = &elem; } - ATTR_HOT void add(_ListClass &elem) + ATTR_HOT void add(LC &elem) { - _ListClass **p = &m_head; + LC **p = &m_head; while (*p != nullptr) { p = &((*p)->m_next); @@ -208,9 +210,9 @@ public: elem.m_next = nullptr; } - ATTR_HOT void remove(const _ListClass &elem) + ATTR_HOT void remove(const LC &elem) { - _ListClass **p; + LC **p; for (p = &m_head; *p != &elem; p = &((*p)->m_next)) { //nl_assert(*p != nullptr); @@ -218,38 +220,38 @@ public: (*p) = elem.m_next; } - ATTR_HOT _ListClass *first() const { return m_head; } + ATTR_HOT LC *first() const { return m_head; } ATTR_HOT void clear() { m_head = nullptr; } ATTR_HOT bool is_empty() const { return (m_head == nullptr); } //private: - _ListClass *m_head; + LC *m_head; }; #else -template <class _ListClass> +template <class LC> struct plinkedlist_element_t { public: - friend class plinkedlist_t<_ListClass>; + friend class linkedlist_t<LC>; plinkedlist_element_t() : m_next(nullptr), m_prev(nullptr) {} - _ListClass *next() const { return m_next; } + LC *next() const { return m_next; } private: - _ListClass * m_next; - _ListClass * m_prev; + LC * m_next; + LC * m_prev; }; -template <class _ListClass> -class plinkedlist_t +template <class LC> +class linkedlist_t { public: - plinkedlist_t() : m_head(nullptr), m_tail(nullptr) {} + linkedlist_t() : m_head(nullptr), m_tail(nullptr) {} - ATTR_HOT void insert(_ListClass &elem) + ATTR_HOT void insert(LC &elem) { if (m_head != nullptr) m_head->m_prev = &elem; @@ -260,7 +262,7 @@ public: m_tail = &elem; } - ATTR_HOT void add(_ListClass &elem) + ATTR_HOT void add(LC &elem) { if (m_tail != nullptr) m_tail->m_next = &elem; @@ -271,7 +273,7 @@ public: m_head = &elem; } - ATTR_HOT void remove(const _ListClass &elem) + ATTR_HOT void remove(const LC &elem) { if (prev(elem) == nullptr) { @@ -293,17 +295,17 @@ public: } - ATTR_HOT static _ListClass *next(const _ListClass &elem) { return static_cast<_ListClass *>(elem.m_next); } - ATTR_HOT static _ListClass *next(const _ListClass *elem) { return static_cast<_ListClass *>(elem->m_next); } - ATTR_HOT static _ListClass *prev(const _ListClass &elem) { return static_cast<_ListClass *>(elem.m_prev); } - ATTR_HOT static _ListClass *prev(const _ListClass *elem) { return static_cast<_ListClass *>(elem->m_prev); } - ATTR_HOT _ListClass *first() const { return m_head; } + ATTR_HOT static LC *next(const LC &elem) { return static_cast<LC *>(elem.m_next); } + ATTR_HOT static LC *next(const LC *elem) { return static_cast<LC *>(elem->m_next); } + ATTR_HOT static LC *prev(const LC &elem) { return static_cast<LC *>(elem.m_prev); } + ATTR_HOT static LC *prev(const LC *elem) { return static_cast<LC *>(elem->m_prev); } + ATTR_HOT LC *first() const { return m_head; } ATTR_HOT void clear() { m_head = m_tail = nullptr; } ATTR_HOT bool is_empty() const { return (m_head == nullptr); } private: - _ListClass *m_head; - _ListClass *m_tail; + LC *m_head; + LC *m_tail; }; #endif @@ -383,26 +385,28 @@ public: template <class C> -struct phash_functor +struct hash_functor { - phash_functor() + hash_functor() + : m_hash(0) {} - phash_functor(const C &v) + hash_functor(const C &v) + : m_hash(v) { - m_hash = v; } - friend unsigned operator%(const phash_functor &lhs, const unsigned &rhs) { return lhs.m_hash % rhs; } - bool operator==(const phash_functor &lhs) const { return (m_hash == lhs.m_hash); } + friend unsigned operator%(const hash_functor &lhs, const unsigned &rhs) { return lhs.m_hash % rhs; } + bool operator==(const hash_functor &lhs) const { return (m_hash == lhs.m_hash); } private: unsigned m_hash; }; template <> -struct phash_functor<pstring> +struct hash_functor<pstring> { - phash_functor() + hash_functor() + : m_hash(0) {} - phash_functor(const pstring &v) + hash_functor(const pstring &v) { /* modified djb2 */ const pstring::mem_t *string = v.cstr(); @@ -412,9 +416,9 @@ struct phash_functor<pstring> //result = (result*33) ^ c; m_hash = result; } - friend unsigned operator%(const phash_functor<pstring> &lhs, const unsigned &rhs) { return lhs.m_hash % rhs; } + friend unsigned operator%(const hash_functor<pstring> &lhs, const unsigned &rhs) { return lhs.m_hash % rhs; } unsigned operator()() { return m_hash; } - bool operator==(const phash_functor<pstring> &lhs) const { return (m_hash == lhs.m_hash); } + bool operator==(const hash_functor<pstring> &lhs) const { return (m_hash == lhs.m_hash); } private: unsigned m_hash; }; @@ -452,17 +456,17 @@ private: #endif #endif -template <class K, class V, class H = phash_functor<K> > -class phashmap_t +template <class K, class V, class H = hash_functor<K> > +class hashmap_t { public: - phashmap_t() : m_hash(37) + hashmap_t() : m_hash(37) { for (unsigned i=0; i<m_hash.size(); i++) m_hash[i] = -1; } - ~phashmap_t() + ~hashmap_t() { } @@ -593,7 +597,7 @@ private: } pvector_t<element_t> m_values; - parray_t<int> m_hash; + array_t<int> m_hash; }; // ---------------------------------------------------------------------------------------- @@ -601,8 +605,8 @@ private: // elements must support ">" operator. // ---------------------------------------------------------------------------------------- -template<typename Class> -static inline void psort_list(Class &sl) +template<typename T> +static inline void sort_list(T &sl) { for(unsigned i = 0; i < sl.size(); i++) { @@ -613,4 +617,6 @@ static inline void psort_list(Class &sl) } } +PLIB_NAMESPACE_END() + #endif /* PLISTS_H_ */ diff --git a/src/lib/netlist/plib/poptions.h b/src/lib/netlist/plib/poptions.h index 984db395e2f..1665738ebe4 100644 --- a/src/lib/netlist/plib/poptions.h +++ b/src/lib/netlist/plib/poptions.h @@ -15,22 +15,24 @@ #include "pstring.h" #include "plists.h" +PLIB_NAMESPACE_START() + /*************************************************************************** Options ***************************************************************************/ -class poptions; +class options; -class poption +class option { public: - poption() + option() : m_short(""), m_long(""), m_help(""), m_has_argument(false) {} - poption(pstring ashort, pstring along, pstring help, bool has_argument, poptions *parent = nullptr); + option(pstring ashort, pstring along, pstring help, bool has_argument, options *parent = nullptr); - virtual ~poption() + virtual ~option() { } @@ -45,11 +47,11 @@ public: private: }; -class poption_str : public poption +class option_str : public option { public: - poption_str(pstring ashort, pstring along, pstring defval, pstring help, poptions *parent = nullptr) - : poption(ashort, along, help, true, parent), m_val(defval) + option_str(pstring ashort, pstring along, pstring defval, pstring help, options *parent = nullptr) + : option(ashort, along, help, true, parent), m_val(defval) {} virtual int parse(pstring argument) override { m_val = argument; return 0; } @@ -59,11 +61,11 @@ private: pstring m_val; }; -class poption_str_limit : public poption +class option_str_limit : public option { public: - poption_str_limit(pstring ashort, pstring along, pstring defval, pstring limit, pstring help, poptions *parent = nullptr) - : poption(ashort, along, help, true, parent), m_val(defval), m_limit(limit, ":") + option_str_limit(pstring ashort, pstring along, pstring defval, pstring limit, pstring help, options *parent = nullptr) + : option(ashort, along, help, true, parent), m_val(defval), m_limit(limit, ":") {} virtual int parse(pstring argument) override @@ -83,11 +85,11 @@ private: pstring_vector_t m_limit; }; -class poption_bool : public poption +class option_bool : public option { public: - poption_bool(pstring ashort, pstring along, pstring help, poptions *parent = nullptr) - : poption(ashort, along, help, false, parent), m_val(false) + option_bool(pstring ashort, pstring along, pstring help, options *parent = nullptr) + : option(ashort, along, help, false, parent), m_val(false) {} virtual int parse(ATTR_UNUSED pstring argument) override { m_val = true; return 0; } @@ -97,11 +99,11 @@ private: bool m_val; }; -class poption_double : public poption +class option_double : public option { public: - poption_double(pstring ashort, pstring along, double defval, pstring help, poptions *parent = nullptr) - : poption(ashort, along, help, true, parent), m_val(defval) + option_double(pstring ashort, pstring along, double defval, pstring help, options *parent = nullptr) + : option(ashort, along, help, true, parent), m_val(defval) {} virtual int parse(pstring argument) override @@ -116,13 +118,13 @@ private: double m_val; }; -class poptions +class options { public: - poptions() {} + options() {} - poptions(poption *o[]) + options(option *o[]) { int i=0; while (o[i] != nullptr) @@ -132,12 +134,12 @@ public: } } - ~poptions() + ~options() { m_opts.clear(); } - void register_option(poption *opt) + void register_option(option *opt) { m_opts.push_back(opt); } @@ -149,7 +151,7 @@ public: for (int i=1; i<argc; ) { pstring arg(argv[i]); - poption *opt = nullptr; + option *opt = nullptr; if (arg.startsWith("--")) { @@ -182,7 +184,7 @@ public: for (std::size_t i=0; i<m_opts.size(); i++ ) { - poption *opt = m_opts[i]; + option *opt = m_opts[i]; pstring line = ""; if (opt->m_short != "") line += " -" + opt->m_short; @@ -203,7 +205,7 @@ public: private: - poption *getopt_short(pstring arg) + option *getopt_short(pstring arg) { for (std::size_t i=0; i < m_opts.size(); i++) { @@ -212,7 +214,7 @@ private: } return nullptr; } - poption *getopt_long(pstring arg) + option *getopt_long(pstring arg) { for (std::size_t i=0; i < m_opts.size(); i++) { @@ -222,16 +224,17 @@ private: return nullptr; } - pvector_t<poption *> m_opts; + pvector_t<option *> m_opts; pstring m_app; }; -poption::poption(pstring ashort, pstring along, pstring help, bool has_argument, poptions *parent) +option::option(pstring ashort, pstring along, pstring help, bool has_argument, options *parent) : m_short(ashort), m_long(along), m_help(help), m_has_argument(has_argument) { if (parent != nullptr) parent->register_option(this); } +PLIB_NAMESPACE_END() #endif /* POPTIONS_H_ */ diff --git a/src/lib/netlist/plib/pparser.cpp b/src/lib/netlist/plib/pparser.cpp index 70e48ba5c23..1fbd6938ddb 100644 --- a/src/lib/netlist/plib/pparser.cpp +++ b/src/lib/netlist/plib/pparser.cpp @@ -9,6 +9,7 @@ #include "pparser.h" +PLIB_NAMESPACE_START() // ---------------------------------------------------------------------------------------- // A simple tokenizer // ---------------------------------------------------------------------------------------- @@ -468,3 +469,5 @@ postream & ppreprocessor::process_i(pistream &istrm, postream &ostrm) } return ostrm; } + +PLIB_NAMESPACE_END() diff --git a/src/lib/netlist/plib/pparser.h b/src/lib/netlist/plib/pparser.h index cf122fec7f8..3eaf0beea50 100644 --- a/src/lib/netlist/plib/pparser.h +++ b/src/lib/netlist/plib/pparser.h @@ -13,6 +13,8 @@ #include "plists.h" #include "pstream.h" +PLIB_NAMESPACE_START() + class ptokenizer { P_PREVENT_COPYING(ptokenizer) @@ -186,7 +188,7 @@ private: pstring process_line(const pstring &line); - phashmap_t<pstring, define_t> m_defines; + hashmap_t<pstring, define_t> m_defines; pstring_vector_t m_expr_sep; //pstringbuffer m_ret; @@ -195,4 +197,6 @@ private: int m_lineno; }; +PLIB_NAMESPACE_END() + #endif /* PPARSER_H_ */ diff --git a/src/lib/netlist/plib/pstate.cpp b/src/lib/netlist/plib/pstate.cpp index 095c8c812be..f0763d5eab4 100644 --- a/src/lib/netlist/plib/pstate.cpp +++ b/src/lib/netlist/plib/pstate.cpp @@ -7,6 +7,8 @@ #include "pstate.h" +PLIB_NAMESPACE_START() + pstate_manager_t::pstate_manager_t() { } @@ -74,3 +76,5 @@ template<> ATTR_COLD void pstate_manager_t::save_item(pstate_callback_t &state, m_save.push_back(std::move(p)); state.register_state(*this, stname); } + +PLIB_NAMESPACE_END() diff --git a/src/lib/netlist/plib/pstate.h b/src/lib/netlist/plib/pstate.h index 9b88f8f562b..5432c37f327 100644 --- a/src/lib/netlist/plib/pstate.h +++ b/src/lib/netlist/plib/pstate.h @@ -32,19 +32,19 @@ enum pstate_data_type_e { DT_FLOAT }; -template<typename _ItemType> struct pstate_datatype +template<typename ItemType> struct pstate_datatype { static const pstate_data_type_e type = pstate_data_type_e(NOT_SUPPORTED); static const bool is_ptr = false; }; -template<typename _ItemType> struct pstate_datatype<_ItemType *> +template<typename ItemType> struct pstate_datatype<ItemType *> { static const pstate_data_type_e type = pstate_data_type_e(NOT_SUPPORTED); static const bool is_ptr = true; }; -//template<typename _ItemType> struct type_checker<_ItemType*> { static const bool is_atom = false; static const bool is_pointer = true; }; +//template<typename ItemType> struct type_checker<ItemType*> { static const bool is_atom = false; static const bool is_pointer = true; }; #define NETLIST_SAVE_TYPE(TYPE, TYPEDESC) \ template<> struct pstate_datatype<TYPE>{ static const pstate_data_type_e type = pstate_data_type_e(TYPEDESC); static const bool is_ptr = false;}; \ @@ -68,6 +68,8 @@ NETLIST_SAVE_TYPE(UINT16, DT_INT16); NETLIST_SAVE_TYPE(INT16, DT_INT16); //NETLIST_SAVE_TYPE(std::size_t, DT_INT64); +PLIB_NAMESPACE_START() + class pstate_manager_t; class pstate_callback_t @@ -185,5 +187,6 @@ public: } }; +PLIB_NAMESPACE_END() #endif /* PSTATE_H_ */ diff --git a/src/lib/netlist/plib/pstream.cpp b/src/lib/netlist/plib/pstream.cpp index f7448f5a6ae..dd3713499d5 100644 --- a/src/lib/netlist/plib/pstream.cpp +++ b/src/lib/netlist/plib/pstream.cpp @@ -13,6 +13,8 @@ #include "pstream.h" #include "palloc.h" +PLIB_NAMESPACE_START() + // ----------------------------------------------------------------------------- // pistream: input stream // ----------------------------------------------------------------------------- @@ -360,3 +362,5 @@ pstream::pos_type pomemstream::vtell() { return m_pos; } + +PLIB_NAMESPACE_END() diff --git a/src/lib/netlist/plib/pstream.h b/src/lib/netlist/plib/pstream.h index fd749a09cce..a3e16299c76 100644 --- a/src/lib/netlist/plib/pstream.h +++ b/src/lib/netlist/plib/pstream.h @@ -16,6 +16,8 @@ #include "palloc.h" #include "pfmtlog.h" +PLIB_NAMESPACE_START() + // ----------------------------------------------------------------------------- // pstream: things common to all streams // ----------------------------------------------------------------------------- @@ -357,7 +359,7 @@ private: // pstream_fmt_writer_t: writer on top of ostream // ----------------------------------------------------------------------------- -class pstream_fmt_writer_t : public pfmt_writer_t<> +class pstream_fmt_writer_t : public plib::pfmt_writer_t<> { P_PREVENT_COPYING(pstream_fmt_writer_t) public: @@ -375,4 +377,6 @@ private: postream &m_strm; }; +PLIB_NAMESPACE_END() + #endif /* _PSTREAM_H_ */ diff --git a/src/lib/netlist/plib/pstring.cpp b/src/lib/netlist/plib/pstring.cpp index 73117d01b02..82972aac91c 100644 --- a/src/lib/netlist/plib/pstring.cpp +++ b/src/lib/netlist/plib/pstring.cpp @@ -364,7 +364,7 @@ void pstring_t<F>::sfree(pstr_t *s) stk[sn].push(s); } else - pfree_array(((char *)s)); + plib::pfree_array(((char *)s)); //_mm_free(((char *)s)); } } @@ -373,12 +373,12 @@ template<typename F> pstr_t *pstring_t<F>::salloc(int n) { if (stk == nullptr) - stk = palloc_array<std::stack<pstr_t *>>(17); + stk = plib::palloc_array<std::stack<pstr_t *>>(17); pstr_t *p; unsigned sn= ((32 - countleadbits(n)) + 1) / 2; unsigned size = sizeof(pstr_t) + ((UINT64) 1<<(sn * 2)) + 1; if (stk[sn].empty()) - p = (pstr_t *) palloc_array<char>(size); + p = (pstr_t *) plib::palloc_array<char>(size); else { p = stk[sn].top(); @@ -398,11 +398,11 @@ void pstring_t<F>::resetmem() { for (; stk[i].size() > 0; ) { - pfree_array(stk[i].top()); + plib::pfree_array(stk[i].top()); stk[i].pop(); } } - pfree_array(stk); + plib::pfree_array(stk); stk = nullptr; } } @@ -533,7 +533,7 @@ int pstring_t<F>::pcmp(const mem_t *right) const pstringbuffer::~pstringbuffer() { if (m_ptr != nullptr) - pfree_array(m_ptr); + plib::pfree_array(m_ptr); } void pstringbuffer::resize(const std::size_t size) @@ -543,7 +543,7 @@ void pstringbuffer::resize(const std::size_t size) m_size = DEFAULT_SIZE; while (m_size <= size) m_size *= 2; - m_ptr = palloc_array<char>(m_size); + m_ptr = plib::palloc_array<char>(m_size); *m_ptr = 0; m_len = 0; } @@ -551,9 +551,9 @@ void pstringbuffer::resize(const std::size_t size) { while (m_size < size) m_size *= 2; - char *new_buf = palloc_array<char>(m_size); + char *new_buf = plib::palloc_array<char>(m_size); std::memcpy(new_buf, m_ptr, m_len + 1); - pfree_array(m_ptr); + plib::pfree_array(m_ptr); m_ptr = new_buf; } } diff --git a/src/lib/netlist/plib/ptypes.h b/src/lib/netlist/plib/ptypes.h index 5ccfe171ed4..c1fac50bb32 100644 --- a/src/lib/netlist/plib/ptypes.h +++ b/src/lib/netlist/plib/ptypes.h @@ -11,11 +11,13 @@ #include "pconfig.h" #include "pstring.h" +PLIB_NAMESPACE_START() + //============================================================ // penum - strongly typed enumeration //============================================================ -struct penum_base +struct enum_base { protected: static int from_string_int(const char *str, const char *x) @@ -74,8 +76,10 @@ protected: } }; +PLIB_NAMESPACE_END() + #define P_ENUM(_name, ...) \ - struct _name : public penum_base { \ + struct _name : public plib::enum_base { \ enum e { __VA_ARGS__ }; \ _name (e v) : m_v(v) { } \ bool set_from_string (const pstring &s) { \ diff --git a/src/lib/netlist/prg/nltool.cpp b/src/lib/netlist/prg/nltool.cpp index d79e0da14f4..ed96b517192 100644 --- a/src/lib/netlist/prg/nltool.cpp +++ b/src/lib/netlist/prg/nltool.cpp @@ -16,7 +16,7 @@ #endif #endif -#include "plib/poptions.h" +#include <plib/poptions.h> #include "plib/pstring.h" #include "plib/plists.h" #include "plib/ptypes.h" @@ -26,11 +26,11 @@ #include "devices/net_lib.h" #include "tools/nl_convert.h" -class tool_options_t : public poptions +class tool_options_t : public plib::options { public: tool_options_t() : - poptions(), + plib::options(), opt_ttr ("t", "time_to_run", 1.0, "time to run the emulation (seconds)", this), opt_name("n", "name", "", "netlist in file to run; default is first one", this), opt_logs("l", "logs", "", "colon separated list of terminals to log", this), @@ -43,23 +43,23 @@ public: opt_help("h", "help", "display help", this) {} - poption_double opt_ttr; - poption_str opt_name; - poption_str opt_logs; - poption_str opt_file; - poption_str_limit opt_type; - poption_str opt_cmd; - poption_str opt_inp; - poption_bool opt_verb; - poption_bool opt_quiet; - poption_bool opt_help; + plib::option_double opt_ttr; + plib::option_str opt_name; + plib::option_str opt_logs; + plib::option_str opt_file; + plib::option_str_limit opt_type; + plib::option_str opt_cmd; + plib::option_str opt_inp; + plib::option_bool opt_verb; + plib::option_bool opt_quiet; + plib::option_bool opt_help; }; -pstdout pout_strm; -pstderr perr_strm; +plib::pstdout pout_strm; +plib::pstderr perr_strm; -pstream_fmt_writer_t pout(pout_strm); -pstream_fmt_writer_t perr(perr_strm); +plib::pstream_fmt_writer_t pout(pout_strm); +plib::pstream_fmt_writer_t perr(perr_strm); NETLIST_START(dummy) /* Standard stuff */ @@ -85,12 +85,12 @@ public: ~netlist_tool_t() { if (m_setup != nullptr) - pfree(m_setup); + plib::pfree(m_setup); }; void init() { - m_setup = palloc<netlist::setup_t>(*this); + m_setup = plib::palloc<netlist::setup_t>(*this); } void read_netlist(const pstring &filename, const pstring &name) @@ -111,7 +111,7 @@ public: void log_setup() { log().debug("Creating dynamic logs ...\n"); - pstring_vector_t ll(m_opts ? m_opts->opt_logs() : "" , ":"); + plib::pstring_vector_t ll(m_opts ? m_opts->opt_logs() : "" , ":"); for (unsigned i=0; i < ll.size(); i++) { pstring name = "log_" + ll[i]; @@ -124,10 +124,10 @@ public: protected: - void vlog(const plog_level &l, const pstring &ls) const override + void vlog(const plib::plog_level &l, const pstring &ls) const override { pout("{}: {}\n", l.name().cstr(), ls.cstr()); - if (l == plog_level::FATAL) + if (l == plib::plog_level::FATAL) throw; } @@ -160,7 +160,7 @@ struct input_t double t; int e = sscanf(line.cstr(), "%lf,%[^,],%lf", &t, buf, &m_value); if ( e!= 3) - throw netlist::fatalerror_e(pfmt("error {1} scanning line {2}\n")(e)(line)); + throw netlist::fatalerror_e(plib::pfmt("error {1} scanning line {2}\n")(e)(line)); m_time = netlist::netlist_time::from_double(t); m_param = netlist->setup().find_param(buf, true); } @@ -171,7 +171,7 @@ struct input_t { case netlist::param_t::MODEL: case netlist::param_t::STRING: - throw netlist::fatalerror_e(pfmt("param {1} is not numeric\n")(m_param->name())); + throw netlist::fatalerror_e(plib::pfmt("param {1} is not numeric\n")(m_param->name())); case netlist::param_t::DOUBLE: static_cast<netlist::param_double_t*>(m_param)->setTo(m_value); break; @@ -190,12 +190,12 @@ struct input_t }; -pvector_t<input_t> *read_input(netlist::netlist_t *netlist, pstring fname) +plib::pvector_t<input_t> *read_input(netlist::netlist_t *netlist, pstring fname) { - pvector_t<input_t> *ret = palloc<pvector_t<input_t>>(); + plib::pvector_t<input_t> *ret = plib::palloc<plib::pvector_t<input_t>>(); if (fname != "") { - pifilestream f(fname); + plib::pifilestream f(fname); pstring l; while (f.readline(l)) { @@ -212,7 +212,7 @@ pvector_t<input_t> *read_input(netlist::netlist_t *netlist, pstring fname) static void run(tool_options_t &opts) { netlist_tool_t nt("netlist"); - pticks_t t = pticks(); + plib::ticks_t t = plib::ticks(); nt.m_opts = &opts; nt.init(); @@ -224,13 +224,13 @@ static void run(tool_options_t &opts) nt.read_netlist(opts.opt_file(), opts.opt_name()); - pvector_t<input_t> *inps = read_input(&nt, opts.opt_inp()); + plib::pvector_t<input_t> *inps = read_input(&nt, opts.opt_inp()); double ttr = opts.opt_ttr(); - pout("startup time ==> {1:5.3f}\n", (double) (pticks() - t) / (double) pticks_per_second() ); + pout("startup time ==> {1:5.3f}\n", (double) (plib::ticks() - t) / (double) plib::ticks_per_second() ); pout("runnning ...\n"); - t = pticks(); + t = plib::ticks(); unsigned pos = 0; netlist::netlist_time nlt = netlist::netlist_time::zero; @@ -246,7 +246,7 @@ static void run(tool_options_t &opts) nt.stop(); pfree(inps); - double emutime = (double) (pticks() - t) / (double) pticks_per_second(); + double emutime = (double) (plib::ticks() - t) / (double) plib::ticks_per_second(); pout("{1:f} seconds emulation took {2:f} real time ==> {3:5.2f}%\n", ttr, emutime, ttr/emutime*100.0); } @@ -287,10 +287,10 @@ static void listdevices() for (unsigned i=0; i < list.size(); i++) { auto &f = list[i]; - pstring out = pfmt("{1} {2}(<id>")(f->classname(),"-20")(f->name()); + pstring out = plib::pfmt("{1} {2}(<id>")(f->classname(),"-20")(f->name()); pstring terms(""); - auto d = f->Create(nt.setup().netlist(), pfmt("dummy{1}")(i)); + auto d = f->Create(nt.setup().netlist(), plib::pfmt("dummy{1}")(i)); // get the list of terminals ... for (unsigned j=0; j < d->m_terminals.size(); j++) @@ -371,15 +371,15 @@ int main(int argc, char *argv[]) else if (cmd == "convert") { pstring contents; - postringstream ostrm; + plib::postringstream ostrm; if (opts.opt_file() == "-") { - pstdin f; + plib::pstdin f; ostrm.write(f); } else { - pifilestream f(opts.opt_file()); + plib::pifilestream f(opts.opt_file()); ostrm.write(f); } contents = ostrm.str(); diff --git a/src/lib/netlist/prg/nlwav.cpp b/src/lib/netlist/prg/nlwav.cpp index ebd128af08d..8b53ea8f428 100644 --- a/src/lib/netlist/prg/nlwav.cpp +++ b/src/lib/netlist/prg/nlwav.cpp @@ -1,18 +1,18 @@ // license:GPL-2.0+ // copyright-holders:Couriersud +#include <plib/poptions.h> #include <cstdio> #include <cstring> -#include "plib/poptions.h" #include "plib/pstring.h" #include "plib/plists.h" #include "plib/pstream.h" #include "nl_setup.h" -class nlwav_options_t : public poptions +class nlwav_options_t : public plib::options { public: nlwav_options_t() : - poptions(), + plib::options(), #if 0 opt_ttr ("t", "time_to_run", 1.0, "time to run the emulation (seconds)", this), opt_name("n", "name", "", "netlist in file to run; default is first one", this), @@ -30,26 +30,26 @@ public: opt_help("h", "help", "display help", this) {} #if 0 - poption_double opt_ttr; - poption_str opt_name; - poption_str opt_logs; - poption_str opt_file; + option_double opt_ttr; + option_str opt_name; + option_str opt_logs; + option_str opt_file; poption_str_limit opt_type; - poption_str opt_cmd; + option_str opt_cmd; #endif - poption_str opt_inp; - poption_str opt_out; - poption_double opt_amp; - poption_bool opt_verb; - poption_bool opt_quiet; - poption_bool opt_help; + plib::option_str opt_inp; + plib::option_str opt_out; + plib::option_double opt_amp; + plib::option_bool opt_verb; + plib::option_bool opt_quiet; + plib::option_bool opt_help; }; /* http://de.wikipedia.org/wiki/RIFF_WAVE */ class wav_t { public: - wav_t(postream &strm, unsigned sr) : m_f(strm) + wav_t(plib::postream &strm, unsigned sr) : m_f(strm) { initialize(sr); m_f.write(&m_fh, sizeof(m_fh)); @@ -131,20 +131,20 @@ private: riff_format_t m_fmt; riff_data_t m_data; - postream &m_f; + plib::postream &m_f; }; void convert(nlwav_options_t &opts) { - pofilestream fo(opts.opt_out()); + plib::pofilestream fo(opts.opt_out()); if (fo.bad()) { throw netlist::fatalerror_e("Error opening output file: " + opts.opt_out()); } wav_t wo(fo, 48000); - pifilestream fin(opts.opt_inp()); + plib::pifilestream fin(opts.opt_inp()); if (fin.bad()) throw netlist::fatalerror_e("Error opening input file: " + opts.opt_inp()); diff --git a/src/lib/netlist/solver/nld_matrix_solver.h b/src/lib/netlist/solver/nld_matrix_solver.h index ab6364cb2d3..b4e8da156c8 100644 --- a/src/lib/netlist/solver/nld_matrix_solver.h +++ b/src/lib/netlist/solver/nld_matrix_solver.h @@ -52,9 +52,9 @@ public: unsigned m_railstart; - pvector_t<unsigned> m_nz; /* all non zero for multiplication */ - pvector_t<unsigned> m_nzrd; /* non zero right of the diagonal for elimination, may include RHS element */ - pvector_t<unsigned> m_nzbd; /* non zero below of the diagonal for elimination */ + plib::pvector_t<unsigned> m_nz; /* all non zero for multiplication */ + plib::pvector_t<unsigned> m_nzrd; /* non zero right of the diagonal for elimination, may include RHS element */ + plib::pvector_t<unsigned> m_nzbd; /* non zero below of the diagonal for elimination */ /* state */ nl_double m_last_V; @@ -62,19 +62,19 @@ public: nl_double m_h_n_m_1; private: - pvector_t<int> m_net_other; - pvector_t<nl_double> m_go; - pvector_t<nl_double> m_gt; - pvector_t<nl_double> m_Idr; - pvector_t<nl_double *> m_other_curanalog; - pvector_t<terminal_t *> m_term; + plib::pvector_t<int> m_net_other; + plib::pvector_t<nl_double> m_go; + plib::pvector_t<nl_double> m_gt; + plib::pvector_t<nl_double> m_Idr; + plib::pvector_t<nl_double *> m_other_curanalog; + plib::pvector_t<terminal_t *> m_term; }; class matrix_solver_t : public device_t { public: - using list_t = pvector_t<matrix_solver_t *>; + using list_t = plib::pvector_t<matrix_solver_t *>; using dev_list_t = core_device_t::list_t; enum eSortType @@ -133,13 +133,13 @@ public: public: ATTR_COLD int get_net_idx(net_t *net); - plog_base<NL_DEBUG> &log() { return netlist().log(); } + plib::plog_base<NL_DEBUG> &log() { return netlist().log(); } virtual void log_stats(); - virtual void create_solver_code(postream &strm) + virtual void create_solver_code(plib::postream &strm) { - strm.writeline(pfmt("/* {1} doesn't support static compile */")); + strm.writeline(plib::pfmt("/* {1} doesn't support static compile */")); } protected: @@ -163,11 +163,11 @@ protected: template <typename T> void build_LE_RHS(); - pvector_t<terms_t *> m_terms; - pvector_t<analog_net_t *> m_nets; - pvector_t<analog_output_t *> m_inps; + plib::pvector_t<terms_t *> m_terms; + plib::pvector_t<analog_net_t *> m_nets; + plib::pvector_t<analog_output_t *> m_inps; - pvector_t<terms_t *> m_rails_temp; + plib::pvector_t<terms_t *> m_rails_temp; int m_stat_calculations; int m_stat_newton_raphson; diff --git a/src/lib/netlist/solver/nld_ms_direct.h b/src/lib/netlist/solver/nld_ms_direct.h index bfbd0a66c7a..c0d6587edbb 100644 --- a/src/lib/netlist/solver/nld_ms_direct.h +++ b/src/lib/netlist/solver/nld_ms_direct.h @@ -211,7 +211,7 @@ ATTR_COLD void matrix_solver_direct_t<m_N, _storage_N>::vsetup(analog_net_t::lis for (unsigned k = 0; k < N(); k++) { - pstring num = pfmt("{1}")(k); + pstring num = plib::pfmt("{1}")(k); save(RHS(k), "RHS." + num); } diff --git a/src/lib/netlist/solver/nld_ms_direct_lu.h b/src/lib/netlist/solver/nld_ms_direct_lu.h index e6ccf819653..de494fcde10 100644 --- a/src/lib/netlist/solver/nld_ms_direct_lu.h +++ b/src/lib/netlist/solver/nld_ms_direct_lu.h @@ -355,7 +355,7 @@ ATTR_COLD void matrix_solver_direct_t<m_N, _storage_N>::vsetup(analog_net_t::lis for (unsigned k = 0; k < N(); k++) { - pstring num = pfmt("{1}")(k); + pstring num = plib::pfmt("{1}")(k); save(m_terms[k]->go(),"GO" + num, m_terms[k]->count()); save(m_terms[k]->gt(),"GT" + num, m_terms[k]->count()); diff --git a/src/lib/netlist/solver/nld_ms_gcr.h b/src/lib/netlist/solver/nld_ms_gcr.h index fc83125803d..de3acdeadbe 100644 --- a/src/lib/netlist/solver/nld_ms_gcr.h +++ b/src/lib/netlist/solver/nld_ms_gcr.h @@ -47,25 +47,25 @@ public: virtual void vsetup(analog_net_t::list_t &nets) override; virtual int vsolve_non_dynamic(const bool newton_raphson) override; - virtual void create_solver_code(postream &strm) override; + virtual void create_solver_code(plib::postream &strm) override; private: - void csc_private(postream &strm); + void csc_private(plib::postream &strm); using extsolver = void (*)(double * RESTRICT m_A, double * RESTRICT RHS); pstring static_compile_name() { - postringstream t; + plib::postringstream t; csc_private(t); - phash_functor<pstring> h(t.str()); + plib::hash_functor<pstring> h(t.str()); - return pfmt("nl_gcr_{1:x}_{2}")(h())(mat.nz_num); + return plib::pfmt("nl_gcr_{1:x}_{2}")(h())(mat.nz_num); } unsigned m_dim; - pvector_t<int> m_term_cr[_storage_N]; + plib::pvector_t<int> m_term_cr[_storage_N]; mat_cr_t<_storage_N> mat; nl_double m_A[_storage_N * _storage_N]; @@ -179,7 +179,7 @@ void matrix_solver_GCR_t<m_N, _storage_N>::vsetup(analog_net_t::list_t &nets) } template <unsigned m_N, unsigned _storage_N> -void matrix_solver_GCR_t<m_N, _storage_N>::csc_private(postream &strm) +void matrix_solver_GCR_t<m_N, _storage_N>::csc_private(plib::postream &strm) { const unsigned iN = N(); for (unsigned i = 0; i < iN - 1; i++) @@ -191,7 +191,7 @@ void matrix_solver_GCR_t<m_N, _storage_N>::csc_private(postream &strm) unsigned pi = mat.diag[i]; //const nl_double f = 1.0 / m_A[pi++]; - strm.writeline(pfmt("const double f{1} = 1.0 / m_A[{2}];")(i)(pi)); + strm.writeline(plib::pfmt("const double f{1} = 1.0 / m_A[{2}];")(i)(pi)); pi++; const unsigned piie = mat.ia[i+1]; @@ -204,7 +204,7 @@ void matrix_solver_GCR_t<m_N, _storage_N>::csc_private(postream &strm) pj++; //const nl_double f1 = - m_A[pj++] * f; - strm.writeline(pfmt("\tconst double f{1}_{2} = -f{3} * m_A[{4}];")(i)(j)(i)(pj)); + strm.writeline(plib::pfmt("\tconst double f{1}_{2} = -f{3} * m_A[{4}];")(i)(j)(i)(pj)); pj++; // subtract row i from j */ @@ -213,22 +213,22 @@ void matrix_solver_GCR_t<m_N, _storage_N>::csc_private(postream &strm) while (mat.ja[pj] < mat.ja[pii]) pj++; //m_A[pj++] += m_A[pii++] * f1; - strm.writeline(pfmt("\tm_A[{1}] += m_A[{2}] * f{3}_{4};")(pj)(pii)(i)(j)); + strm.writeline(plib::pfmt("\tm_A[{1}] += m_A[{2}] * f{3}_{4};")(pj)(pii)(i)(j)); pj++; pii++; } //RHS[j] += f1 * RHS[i]; - strm.writeline(pfmt("\tRHS[{1}] += f{2}_{3} * RHS[{4}];")(j)(i)(j)(i)); + strm.writeline(plib::pfmt("\tRHS[{1}] += f{2}_{3} * RHS[{4}];")(j)(i)(j)(i)); } } } } template <unsigned m_N, unsigned _storage_N> -void matrix_solver_GCR_t<m_N, _storage_N>::create_solver_code(postream &strm) +void matrix_solver_GCR_t<m_N, _storage_N>::create_solver_code(plib::postream &strm) { //const unsigned iN = N(); - strm.writeline(pfmt("extern \"C\" void {1}(double * __restrict m_A, double * __restrict RHS)")(static_compile_name())); + strm.writeline(plib::pfmt("extern \"C\" void {1}(double * __restrict m_A, double * __restrict RHS)")(static_compile_name())); strm.writeline("{"); csc_private(strm); strm.writeline("}"); diff --git a/src/lib/netlist/solver/nld_ms_gmres.h b/src/lib/netlist/solver/nld_ms_gmres.h index 9e5542f2a42..2cbd329247d 100644 --- a/src/lib/netlist/solver/nld_ms_gmres.h +++ b/src/lib/netlist/solver/nld_ms_gmres.h @@ -45,7 +45,7 @@ private: int solve_ilu_gmres(nl_double * RESTRICT x, const nl_double * RESTRICT rhs, const unsigned restart_max, const unsigned mr, nl_double accuracy); - pvector_t<int> m_term_cr[_storage_N]; + plib::pvector_t<int> m_term_cr[_storage_N]; bool m_use_iLU_preconditioning; bool m_use_more_precise_stop_condition; diff --git a/src/lib/netlist/solver/nld_ms_sm.h b/src/lib/netlist/solver/nld_ms_sm.h index 1a3c50b4a27..e3a4b4a4452 100644 --- a/src/lib/netlist/solver/nld_ms_sm.h +++ b/src/lib/netlist/solver/nld_ms_sm.h @@ -130,7 +130,7 @@ ATTR_COLD void matrix_solver_sm_t<m_N, _storage_N>::vsetup(analog_net_t::list_t for (unsigned k = 0; k < N(); k++) { - pstring num = pfmt("{1}")(k); + pstring num = plib::pfmt("{1}")(k); save(RHS(k), "RHS." + num); } diff --git a/src/lib/netlist/solver/nld_ms_w.h b/src/lib/netlist/solver/nld_ms_w.h index f61c2b1b616..6f0e03cf170 100644 --- a/src/lib/netlist/solver/nld_ms_w.h +++ b/src/lib/netlist/solver/nld_ms_w.h @@ -139,7 +139,7 @@ ATTR_COLD void matrix_solver_w_t<m_N, _storage_N>::vsetup(analog_net_t::list_t & for (unsigned k = 0; k < N(); k++) { - pstring num = pfmt("{1}")(k); + pstring num = plib::pfmt("{1}")(k); save(RHS(k), "RHS." + num); } diff --git a/src/lib/netlist/solver/nld_solver.cpp b/src/lib/netlist/solver/nld_solver.cpp index 22b496d95f9..761567b788e 100644 --- a/src/lib/netlist/solver/nld_solver.cpp +++ b/src/lib/netlist/solver/nld_solver.cpp @@ -99,7 +99,7 @@ ATTR_COLD matrix_solver_t::~matrix_solver_t() m_inps.clear_and_free(); for (unsigned k = 0; k < m_terms.size(); k++) { - pfree(m_terms[k]); + plib::pfree(m_terms[k]); } } @@ -114,8 +114,8 @@ ATTR_COLD void matrix_solver_t::setup_base(analog_net_t::list_t &nets) for (auto & net : nets) { m_nets.push_back(net); - m_terms.push_back(palloc<terms_t>()); - m_rails_temp.push_back(palloc<terms_t>()); + m_terms.push_back(plib::palloc<terms_t>()); + m_rails_temp.push_back(plib::palloc<terms_t>()); } for (std::size_t k = 0; k < nets.size(); k++) @@ -157,9 +157,9 @@ ATTR_COLD void matrix_solver_t::setup_base(analog_net_t::list_t &nets) if (net_proxy_output == nullptr) { //net_proxy_output = palloc(analog_output_t(*this, - // this->name() + "." + pfmt("m{1}")(m_inps.size()))); + // this->name() + "." + plib::pfmt("m{1}")(m_inps.size()))); - net_proxy_output = palloc<analog_output_t>(*this, this->name() + "." + pfmt("m{1}")(m_inps.size())); + net_proxy_output = plib::palloc<analog_output_t>(*this, this->name() + "." + plib::pfmt("m{1}")(m_inps.size())); m_inps.push_back(net_proxy_output); net_proxy_output->m_proxied_net = &p->net().as_analog(); } @@ -196,7 +196,7 @@ ATTR_COLD void matrix_solver_t::setup_matrix() } for (unsigned k = 0; k < iN; k++) - pfree(m_rails_temp[k]); // no longer needed + plib::pfree(m_rails_temp[k]); // no longer needed m_rails_temp.clear(); @@ -259,7 +259,7 @@ ATTR_COLD void matrix_solver_t::setup_matrix() t->m_nz.push_back(k); // add diagonal /* and sort */ - psort_list(t->m_nz); + plib::sort_list(t->m_nz); } /* create a list of non zero elements right of the diagonal @@ -292,7 +292,7 @@ ATTR_COLD void matrix_solver_t::setup_matrix() t->m_nzrd.push_back(other[i]); /* and sort */ - psort_list(t->m_nzrd); + plib::sort_list(t->m_nzrd); } /* create a list of non zero elements below diagonal k @@ -336,9 +336,9 @@ ATTR_COLD void matrix_solver_t::setup_matrix() if (0) for (unsigned k = 0; k < iN; k++) { - pstring line = pfmt("{1}")(k, "3"); + pstring line = plib::pfmt("{1}")(k, "3"); for (unsigned j = 0; j < m_terms[k]->m_nzrd.size(); j++) - line += pfmt(" {1}")(m_terms[k]->m_nzrd[j], "3"); + line += plib::pfmt(" {1}")(m_terms[k]->m_nzrd[j], "3"); log().verbose("{1}", line); } @@ -347,7 +347,7 @@ ATTR_COLD void matrix_solver_t::setup_matrix() */ for (unsigned k = 0; k < iN; k++) { - pstring num = pfmt("{1}")(k); + pstring num = plib::pfmt("{1}")(k); save(m_terms[k]->m_last_V, "lastV." + num); save(m_terms[k]->m_DD_n_m_1, "m_DD_n_m_1." + num); @@ -625,11 +625,11 @@ NETLIB_UPDATE(solver) template <int m_N, int _storage_N> matrix_solver_t * NETLIB_NAME(solver)::create_solver(int size, const bool use_specific) { - pstring solvername = pfmt("Solver_{1}")(m_mat_solvers.size()); + pstring solvername = plib::pfmt("Solver_{1}")(m_mat_solvers.size()); if (use_specific && m_N == 1) - return palloc<matrix_solver_direct1_t>(netlist(), solvername, &m_params); + return plib::palloc<matrix_solver_direct1_t>(netlist(), solvername, &m_params); else if (use_specific && m_N == 2) - return palloc<matrix_solver_direct2_t>(netlist(), solvername, &m_params); + return plib::palloc<matrix_solver_direct2_t>(netlist(), solvername, &m_params); else { if (size >= m_gs_threshold) @@ -637,39 +637,39 @@ matrix_solver_t * NETLIB_NAME(solver)::create_solver(int size, const bool use_sp if (pstring("SOR_MAT").equals(m_iterative_solver)) { typedef matrix_solver_SOR_mat_t<m_N,_storage_N> solver_sor_mat; - return palloc<solver_sor_mat>(netlist(), solvername, &m_params, size); + return plib::palloc<solver_sor_mat>(netlist(), solvername, &m_params, size); } else if (pstring("MAT_CR").equals(m_iterative_solver)) { typedef matrix_solver_GCR_t<m_N,_storage_N> solver_mat; - return palloc<solver_mat>(netlist(), solvername, &m_params, size); + return plib::palloc<solver_mat>(netlist(), solvername, &m_params, size); } else if (pstring("MAT").equals(m_iterative_solver)) { typedef matrix_solver_direct_t<m_N,_storage_N> solver_mat; - return palloc<solver_mat>(netlist(), solvername, &m_params, size); + return plib::palloc<solver_mat>(netlist(), solvername, &m_params, size); } else if (pstring("SM").equals(m_iterative_solver)) { /* Sherman-Morrison Formula */ typedef matrix_solver_sm_t<m_N,_storage_N> solver_mat; - return palloc<solver_mat>(netlist(), solvername, &m_params, size); + return plib::palloc<solver_mat>(netlist(), solvername, &m_params, size); } else if (pstring("W").equals(m_iterative_solver)) { /* Woodbury Formula */ typedef matrix_solver_w_t<m_N,_storage_N> solver_mat; - return palloc<solver_mat>(netlist(), solvername, &m_params, size); + return plib::palloc<solver_mat>(netlist(), solvername, &m_params, size); } else if (pstring("SOR").equals(m_iterative_solver)) { typedef matrix_solver_SOR_t<m_N,_storage_N> solver_GS; - return palloc<solver_GS>(netlist(), solvername, &m_params, size); + return plib::palloc<solver_GS>(netlist(), solvername, &m_params, size); } else if (pstring("GMRES").equals(m_iterative_solver)) { typedef matrix_solver_GMRES_t<m_N,_storage_N> solver_GMRES; - return palloc<solver_GMRES>(netlist(), solvername, &m_params, size); + return plib::palloc<solver_GMRES>(netlist(), solvername, &m_params, size); } else { @@ -680,14 +680,14 @@ matrix_solver_t * NETLIB_NAME(solver)::create_solver(int size, const bool use_sp else { typedef matrix_solver_direct_t<m_N,_storage_N> solver_D; - return palloc<solver_D>(netlist(), solvername, &m_params, size); + return plib::palloc<solver_D>(netlist(), solvername, &m_params, size); } } } ATTR_COLD void NETLIB_NAME(solver)::post_start() { - pvector_t<analog_net_t::list_t> groups; + plib::pvector_t<analog_net_t::list_t> groups; const bool use_specific = true; m_params.m_pivot = m_pivot.Value(); @@ -840,7 +840,7 @@ ATTR_COLD void NETLIB_NAME(solver)::post_start() } } -void NETLIB_NAME(solver)::create_solver_code(postream &strm) +void NETLIB_NAME(solver)::create_solver_code(plib::postream &strm) { for (auto & s : m_mat_solvers) s->create_solver_code(strm); diff --git a/src/lib/netlist/solver/nld_solver.h b/src/lib/netlist/solver/nld_solver.h index 8b1e674cbdd..8f6abb123ff 100644 --- a/src/lib/netlist/solver/nld_solver.h +++ b/src/lib/netlist/solver/nld_solver.h @@ -92,7 +92,7 @@ NETLIB_OBJECT(solver) inline nl_double gmin() { return m_gmin.Value(); } - void create_solver_code(postream &strm); + void create_solver_code(plib::postream &strm); NETLIB_UPDATEI(); NETLIB_RESETI(); @@ -120,7 +120,7 @@ protected: param_logic_t m_log_stats; - pvector_t<matrix_solver_t *> m_mat_solvers; + plib::pvector_t<matrix_solver_t *> m_mat_solvers; private: solver_parameters_t m_params; diff --git a/src/lib/netlist/tools/nl_convert.cpp b/src/lib/netlist/tools/nl_convert.cpp index 052bd246e5e..fde6c663005 100644 --- a/src/lib/netlist/tools/nl_convert.cpp +++ b/src/lib/netlist/tools/nl_convert.cpp @@ -12,9 +12,9 @@ template<typename Class> -static pvector_t<int> bubble(const pvector_t<Class> &sl) +static plib::pvector_t<int> bubble(const plib::pvector_t<Class> &sl) { - pvector_t<int> ret; + plib::pvector_t<int> ret; for (unsigned i=0; i<sl.size(); i++) ret.push_back(i); @@ -38,7 +38,7 @@ static pvector_t<int> bubble(const pvector_t<Class> &sl) void nl_convert_base_t::add_pin_alias(const pstring &devname, const pstring &name, const pstring &alias) { pstring pname = devname + "." + name; - m_pins.add(pname, pmake_unique<pin_alias_t>(pname, devname + "." + alias)); + m_pins.add(pname, plib::pmake_unique<pin_alias_t>(pname, devname + "." + alias)); } void nl_convert_base_t::add_ext_alias(const pstring &alias) @@ -102,7 +102,7 @@ void nl_convert_base_t::dump_nl() if (net->terminals().size() == 1) net->set_no_export(); } - pvector_t<int> sorted = bubble(m_devs); + plib::pvector_t<int> sorted = bubble(m_devs); for (std::size_t i=0; i<m_devs.size(); i++) { std::size_t j = sorted[i]; @@ -148,7 +148,7 @@ const pstring nl_convert_base_t::get_nl_val(const double val) break; i++; } - return pfmt(m_units[i].m_func.cstr())(val / m_units[i].m_mult); + return plib::pfmt(m_units[i].m_func.cstr())(val / m_units[i].m_mult); } } double nl_convert_base_t::get_sp_unit(const pstring &unit) @@ -199,7 +199,7 @@ nl_convert_base_t::unit_t nl_convert_base_t::m_units[] = { void nl_convert_spice_t::convert(const pstring &contents) { - pstring_vector_t spnl(contents, "\n"); + plib::pstring_vector_t spnl(contents, "\n"); // Add gnd net @@ -231,7 +231,7 @@ void nl_convert_spice_t::process_line(const pstring &line) { if (line != "") { - pstring_vector_t tt(line, " ", true); + plib::pstring_vector_t tt(line, " ", true); double val = 0.0; switch (tt[0].code_at(0)) { @@ -270,7 +270,7 @@ void nl_convert_spice_t::process_line(const pstring &line) model = tt[5]; else model = tt[4]; - pstring_vector_t m(model,"{"); + plib::pstring_vector_t m(model,"{"); if (m.size() == 2) { if (m[1].len() != 4) @@ -343,7 +343,7 @@ void nl_convert_spice_t::process_line(const pstring &line) add_device(tname, xname); for (std::size_t i=1; i < tt.size() - 1; i++) { - pstring term = pfmt("{1}.{2}")(xname)(i); + pstring term = plib::pfmt("{1}.{2}")(xname)(i); add_term(tt[i], term); } break; @@ -357,7 +357,7 @@ void nl_convert_spice_t::process_line(const pstring &line) //FIXME: should accept a stream as well void nl_convert_eagle_t::convert(const pstring &contents) { - pistringstream istrm(contents); + plib::pistringstream istrm(contents); eagle_tokenizer tok(*this, istrm); out("NETLIST_START(dummy)\n"); diff --git a/src/lib/netlist/tools/nl_convert.h b/src/lib/netlist/tools/nl_convert.h index 65b951d8daf..40d339e0934 100644 --- a/src/lib/netlist/tools/nl_convert.h +++ b/src/lib/netlist/tools/nl_convert.h @@ -54,7 +54,7 @@ protected: double get_sp_val(const pstring &sin); - pstream_fmt_writer_t out; + plib::pstream_fmt_writer_t out; private: struct net_t @@ -64,14 +64,14 @@ private: : m_name(aname), m_no_export(false) {} const pstring &name() { return m_name;} - pstring_vector_t &terminals() { return m_terminals; } + plib::pstring_vector_t &terminals() { return m_terminals; } void set_no_export() { m_no_export = true; } bool is_no_export() { return m_no_export; } private: pstring m_name; bool m_no_export; - pstring_vector_t m_terminals; + plib::pstring_vector_t m_terminals; }; struct dev_t @@ -128,12 +128,12 @@ private: void add_device(std::shared_ptr<dev_t> dev); - postringstream m_buf; + plib::postringstream m_buf; - pvector_t<std::shared_ptr<dev_t>> m_devs; - phashmap_t<pstring, std::shared_ptr<net_t> > m_nets; - pvector_t<pstring> m_ext_alias; - phashmap_t<pstring, std::shared_ptr<pin_alias_t>> m_pins; + plib::pvector_t<std::shared_ptr<dev_t>> m_devs; + plib::hashmap_t<pstring, std::shared_ptr<net_t> > m_nets; + plib::pvector_t<pstring> m_ext_alias; + plib::hashmap_t<pstring, std::shared_ptr<pin_alias_t>> m_pins; static unit_t m_units[]; @@ -167,11 +167,11 @@ public: { } - class eagle_tokenizer : public ptokenizer + class eagle_tokenizer : public plib::ptokenizer { public: - eagle_tokenizer(nl_convert_eagle_t &convert, pistream &strm) - : ptokenizer(strm), m_convert(convert) + eagle_tokenizer(nl_convert_eagle_t &convert, plib::pistream &strm) + : plib::ptokenizer(strm), m_convert(convert) { set_identifier_chars("abcdefghijklmnopqrstuvwvxyzABCDEFGHIJKLMNOPQRSTUVWXYZ01234567890_.-"); set_number_chars(".0123456789", "0123456789eE-."); //FIXME: processing of numbers |