From 58aa97913fa966b03d3b5bed77c6670e49821f1e Mon Sep 17 00:00:00 2001 From: couriersud Date: Fri, 31 Mar 2017 18:07:35 +0200 Subject: pstring, pdynlib, pfmtlog refactoring : pstring: - added support for UTF16LE to pstring. - renamed size() to mem_t_size() - renmaed len() to length() - added size() == length() - added empty() - added simple compare() pfmtlog: - Simplified pfmtlog, added more c++ pdynlib: - add a dynproc type to dynlib to wrap dynamic library calls. various: - fix two coverty scan issue. - various clang warnings fixed. (nw) --- src/lib/netlist/devices/nld_log.cpp | 4 +- src/lib/netlist/devices/nlid_truthtable.cpp | 4 +- src/lib/netlist/nl_setup.cpp | 12 +- src/lib/netlist/plib/pdynlib.h | 29 +++ src/lib/netlist/plib/pfmtlog.cpp | 128 ++++------ src/lib/netlist/plib/pfmtlog.h | 185 +++++++-------- src/lib/netlist/plib/poptions.cpp | 10 +- src/lib/netlist/plib/pparser.cpp | 2 +- src/lib/netlist/plib/pstate.cpp | 2 +- src/lib/netlist/plib/pstream.h | 10 +- src/lib/netlist/plib/pstring.cpp | 94 +++++--- src/lib/netlist/plib/pstring.h | 334 +++++++++++++++++++++------ src/lib/netlist/plib/putil.cpp | 12 +- src/lib/netlist/prg/nltool.cpp | 8 +- src/lib/netlist/solver/nld_matrix_solver.cpp | 4 +- src/lib/netlist/solver/nld_matrix_solver.h | 2 +- src/lib/netlist/solver/nld_ms_gcr.h | 16 +- src/lib/netlist/tools/nl_convert.cpp | 14 +- 18 files changed, 556 insertions(+), 314 deletions(-) mode change 100644 => 100755 src/lib/netlist/plib/pfmtlog.cpp mode change 100644 => 100755 src/lib/netlist/plib/pfmtlog.h mode change 100644 => 100755 src/lib/netlist/plib/pstring.h mode change 100644 => 100755 src/lib/netlist/prg/nltool.cpp diff --git a/src/lib/netlist/devices/nld_log.cpp b/src/lib/netlist/devices/nld_log.cpp index 256e42ac80d..29218aaa09a 100644 --- a/src/lib/netlist/devices/nld_log.cpp +++ b/src/lib/netlist/devices/nld_log.cpp @@ -27,7 +27,7 @@ namespace netlist NETLIB_UPDATEI() { /* use pstring::sprintf, it is a LOT faster */ - m_writer.writeline(plib::pfmt("{1} {2}").e(netlist().time().as_double(),".9").e(static_cast(m_I()))); + m_writer.writeline(plib::pfmt("{1:.9} {2}").e(netlist().time().as_double()).e(static_cast(m_I()))); } NETLIB_RESETI() { } @@ -46,7 +46,7 @@ namespace netlist NETLIB_UPDATEI() { - m_writer.writeline(plib::pfmt("{1} {2}").e(netlist().time().as_double(),".9").e(static_cast(m_I() - m_I2()))); + m_writer.writeline(plib::pfmt("{1:.9} {2}").e(netlist().time().as_double()).e(static_cast(m_I() - m_I2()))); } NETLIB_RESETI() { } diff --git a/src/lib/netlist/devices/nlid_truthtable.cpp b/src/lib/netlist/devices/nlid_truthtable.cpp index fc07d3829c5..58c1ed65390 100644 --- a/src/lib/netlist/devices/nlid_truthtable.cpp +++ b/src/lib/netlist/devices/nlid_truthtable.cpp @@ -347,8 +347,8 @@ void truthtable_parser::parseline(unsigned cur, std::vector list, { // cutoff previous inputs and outputs for ignore if (m_outs[nstate] != m_outs.mask() && m_outs[nstate] != val) - nl_exception(plib::pfmt("Error in truthtable: State {1} already set, {2} != {3}\n") - .x(nstate.as_uint(),"04")(m_outs[nstate])(val) ); + nl_exception(plib::pfmt("Error in truthtable: State {1:04} already set, {2} != {3}\n") + .x(nstate.as_uint())(m_outs[nstate])(val) ); m_outs.set(nstate, val); for (std::size_t j=0; j pairs(plib::psplit(remainder," ", true)); for (pstring &pe : pairs) @@ -852,7 +852,7 @@ nl_double setup_t::model_value(detail::model_map_t &map, const pstring &entity) pstring tmp = model_value_str(map, entity); nl_double factor = NL_FCONST(1.0); - auto p = std::next(tmp.begin(), static_cast(tmp.len() - 1)); + auto p = std::next(tmp.begin(), static_cast(tmp.length() - 1)); switch (*p) { case 'M': factor = 1e6; break; @@ -868,7 +868,7 @@ nl_double setup_t::model_value(detail::model_map_t &map, const pstring &entity) log().fatal(MF_1_UNKNOWN_NUMBER_FACTOR_IN_1, entity); } if (factor != NL_FCONST(1.0)) - tmp = tmp.left(tmp.len() - 1); + tmp = tmp.left(tmp.length() - 1); return tmp.as_double() * factor; } @@ -997,12 +997,12 @@ bool source_t::parse(const pstring &name) std::unique_ptr source_string_t::stream(const pstring &name) { - return plib::make_unique_base(m_str.c_str(), m_str.len()); + return plib::make_unique_base(m_str.c_str(), m_str.mem_t_size()); } std::unique_ptr source_mem_t::stream(const pstring &name) { - return plib::make_unique_base(m_str.c_str(), m_str.len()); + return plib::make_unique_base(m_str.c_str(), m_str.mem_t_size()); } std::unique_ptr source_file_t::stream(const pstring &name) diff --git a/src/lib/netlist/plib/pdynlib.h b/src/lib/netlist/plib/pdynlib.h index 3a0c12a5f2d..f0883042111 100644 --- a/src/lib/netlist/plib/pdynlib.h +++ b/src/lib/netlist/plib/pdynlib.h @@ -35,6 +35,35 @@ private: void *m_lib; }; +template +class dynproc +{ +public: + using calltype = R(*) (Args... args); + + dynproc() : m_sym(nullptr) { } + + dynproc(dynlib &dl, const pstring &name) + { + m_sym = dl.getsym(name); + } + + void load(dynlib &dl, const pstring &name) + { + m_sym = dl.getsym(name); + } + + R operator ()(Args&&... args) const + { + return m_sym(std::forward(args)...); + //return m_sym(args...); + } + + bool resolved() { return m_sym != nullptr; } +private: + calltype m_sym; +}; + } #endif /* PSTRING_H_ */ diff --git a/src/lib/netlist/plib/pfmtlog.cpp b/src/lib/netlist/plib/pfmtlog.cpp old mode 100644 new mode 100755 index 86d059d9247..ac4f0f6f046 --- a/src/lib/netlist/plib/pfmtlog.cpp +++ b/src/lib/netlist/plib/pfmtlog.cpp @@ -12,8 +12,8 @@ #include #include #include - -//* FIXME: remove cstring, replace with pstring */ +#include +#include namespace plib { @@ -21,115 +21,75 @@ plog_dispatch_intf::~plog_dispatch_intf() { } -pfmt::pfmt(const pstring &fmt) -: m_str(m_str_buf), m_allocated(0), m_arg(0) -{ - std::size_t l = fmt.size() + 1; - if (l>sizeof(m_str_buf)) - { - m_allocated = 2 * l; - m_str = palloc_array(2 * l); - } - std::copy(fmt.c_str(), fmt.c_str() + l, m_str); -} -pfmt::~pfmt() -{ - if (m_allocated > 0) - pfree_array(m_str); -} - -void pfmt::format_element(const char *f, const char *l, const char *fmt_spec, ...) +pfmt &pfmt::format_element(const char *l, const unsigned cfmt_spec, ...) { va_list ap; - va_start(ap, fmt_spec); - char fmt[30] = "%"; - char search[10] = ""; - char buf[2048]; + va_start(ap, cfmt_spec); + pstring fmt("%"); + char buf[2048]; // FIXME + std::size_t sl; + m_arg++; - std::size_t sl = static_cast(sprintf(search, "{%d:", m_arg)); - char *p = strstr(m_str, search); - if (p == nullptr) + + pstring search("{"); + search += plib::to_string(m_arg); + sl = search.length(); + + auto p = m_str.find(search + ":"); + sl++; // ":" + if (p == pstring::npos) // no further specifiers { - sl = static_cast(sprintf(search, "{%d}", m_arg)); - p = strstr(m_str, search); - if (p == nullptr) + p = m_str.find(search + "}"); + if (p == pstring::npos) // not found try default { sl = 2; - p = strstr(m_str, "{}"); + p = m_str.find("{}"); } - if (p==nullptr) + if (p == pstring::npos) { sl=1; - p = strstr(m_str, "{"); - if (p != nullptr) + p = m_str.find("{"); + if (p != pstring:: npos) { - char *p1 = strstr(p, "}"); - if (p1 != nullptr) + auto p1 = m_str.find("}", p); + if (p1 != pstring::npos) { - sl = static_cast(p1 - p + 1); - strncat(fmt, p+1, static_cast(p1 - p - 2)); + sl = p1 - p + 1; + fmt += m_str.substr(p+1, p1 - p - 2); } - else - strcat(fmt, f); } - else - strcat(fmt, f); } } else { - char *p1 = strstr(p, "}"); - if (p1 != nullptr) + auto p1 = m_str.find("}", p); + if (p1 != pstring::npos) { - sl = static_cast(p1 - p + 1); - if (m_arg>=10) - strncat(fmt, p+4, static_cast(p1 - p - 4)); - else - strncat(fmt, p+3, static_cast(p1 - p - 3)); + sl = p1 - p + 1; + fmt += ((m_arg>=10) ? m_str.substr(p+4, p1 - p - 4) : m_str.substr(p+3, p1 - p - 3)); } - else - strcat(fmt, f); } - strcat(fmt, l); - char *pend = fmt + strlen(fmt) - 1; - if (strchr("fge", *fmt_spec) != nullptr) + pstring::code_t pend = fmt.at(fmt.length() - 1); + if (pstring("duxo").find(cfmt_spec) != pstring::npos) { - if (strchr("fge", *pend) == nullptr) - strcat(fmt, fmt_spec); + if (pstring("duxo").find(pend) == pstring::npos) + fmt += (pstring(l, pstring::UTF8) + cfmt_spec); + else + fmt = fmt.left(fmt.length() - 1) + pstring(l, pstring::UTF8) + fmt.right(1); } - else if (strchr("duxo", *fmt_spec) != nullptr) + else if (pstring("fge").find(cfmt_spec) != pstring::npos) { - if (strchr("duxo", *pend) == nullptr) - strcat(fmt, fmt_spec); + if (pstring("fge").find(pend) == pstring::npos) + fmt += cfmt_spec; } else - strcat(fmt, fmt_spec); - std::size_t nl = static_cast(vsprintf(buf, fmt, ap)); - if (p != nullptr) - { - // check room - std::size_t new_size = static_cast(p - m_str) + nl + strlen(p) + 1 - sl; - if (new_size > m_allocated) - { - std::size_t old_alloc = std::max(m_allocated, sizeof(m_str_buf)); - if (m_allocated < old_alloc) - m_allocated = old_alloc; - while (new_size > m_allocated) - m_allocated *= 2; - char *np = palloc_array(m_allocated); - std::copy(m_str, m_str + old_alloc, np); - p = np + (p - m_str); - if (m_str != m_str_buf) - pfree_array(m_str); - m_str = np; - } - // Make room - //memmove(p+nl, p+sl, strlen(p) + 1 - sl); - std::copy_backward(p + sl, p + strlen(p) + 1, p + nl + strlen(p) + 1 - sl); - std::copy(buf, buf + nl, p); - } + fmt += cfmt_spec; + vsprintf(buf, fmt.c_str(), ap); + if (p != pstring::npos) + m_str = m_str.substr(0, p) + pstring(buf, pstring::UTF8) + m_str.substr(p + sl); va_end(ap); + return *this; } } diff --git a/src/lib/netlist/plib/pfmtlog.h b/src/lib/netlist/plib/pfmtlog.h old mode 100644 new mode 100755 index 200be024478..030de5d1fc5 --- a/src/lib/netlist/plib/pfmtlog.h +++ b/src/lib/netlist/plib/pfmtlog.h @@ -25,15 +25,20 @@ P_ENUM(plog_level, template struct ptype_traits_base { - static T cast(T x) { return x; } + static const T cast(const T &x) { return x; } static const bool is_signed = std::numeric_limits::is_signed; + static const char *size_spec() { return ""; } + static char32_t fmt_spec() { return 'u'; } }; template <> struct ptype_traits_base { - static unsigned int cast(bool x) { return static_cast(x); } + static unsigned int cast(bool &x) { return static_cast(x); } + static unsigned int cast(const bool &x) { return static_cast(x); } static const bool is_signed = std::numeric_limits::is_signed; + static const char *size_spec() { return ""; } + static char32_t fmt_spec() { return 'u'; } }; template @@ -42,143 +47,155 @@ struct ptype_traits; template<> struct ptype_traits : ptype_traits_base { - static const char *size_specifier() { return ""; } }; template<> struct ptype_traits : ptype_traits_base { - static const char *size_specifier() { return "h"; } + static const char *size_spec() { return "h"; } + static char32_t fmt_spec() { return is_signed ? 'd' : 'u'; } }; template<> struct ptype_traits : ptype_traits_base { - static const char *size_specifier() { return "h"; } + static const char *size_spec() { return "h"; } + static char32_t fmt_spec() { return 'd'; } }; template<> struct ptype_traits : ptype_traits_base { - static const char *size_specifier() { return ""; } + static char32_t fmt_spec() { return 'd'; } }; template<> struct ptype_traits : ptype_traits_base { - static const char *size_specifier() { return "l"; } + static const char *size_spec() { return "l"; } + static char32_t fmt_spec() { return 'd'; } }; template<> struct ptype_traits : ptype_traits_base { - static const char *size_specifier() { return "ll"; } + static const char *size_spec() { return "ll"; } + static char32_t fmt_spec() { return 'd'; } }; template<> struct ptype_traits : ptype_traits_base { - static const char *size_specifier() { return "h"; } + static const char *size_spec() { return "h"; } + static char32_t fmt_spec() { return 'd'; } }; template<> struct ptype_traits : ptype_traits_base { - static const char *size_specifier() { return "h"; } + static const char *size_spec() { return "h"; } + static char32_t fmt_spec() { return 'u'; } }; template<> struct ptype_traits : ptype_traits_base { - static const char *size_specifier() { return "h"; } + static const char *size_spec() { return "h"; } + static char32_t fmt_spec() { return 'u'; } }; template<> struct ptype_traits : ptype_traits_base { - static const char *size_specifier() { return ""; } + static char32_t fmt_spec() { return 'u'; } }; template<> struct ptype_traits : ptype_traits_base { - static const char *size_specifier() { return "l"; } + static const char *size_spec() { return "l"; } + static char32_t fmt_spec() { return 'u'; } }; template<> struct ptype_traits : ptype_traits_base { - static const char *size_specifier() { return "ll"; } + static const char *size_spec() { return "ll"; } + static char32_t fmt_spec() { return 'u'; } }; -template -class pformat_base +template<> +struct ptype_traits : ptype_traits_base +{ + static char32_t fmt_spec() { return 'f'; } +}; + +template<> +struct ptype_traits : ptype_traits_base +{ + static char32_t fmt_spec() { return 'f'; } +}; + + +template<> +struct ptype_traits : ptype_traits_base +{ + static const char *cast(const char *x) { return x; } + static char32_t fmt_spec() { return 's'; } +}; + +class pfmt { public: + explicit pfmt(const pstring &fmt) + : m_str(fmt), m_arg(0) + { + } + + ~pfmt() + { + } - P &operator ()(const double x, const char *f = "") { format_element(f, "", "f", x); return static_cast

(*this); } - P & e(const double x, const char *f = "") { format_element(f, "", "e", x); return static_cast

(*this); } - P & g(const double x, const char *f = "") { format_element(f, "", "g", x); return static_cast

(*this); } + operator pstring() const { return m_str; } + pfmt & e(const double &x) {return format_element("", 'e', x); } + pfmt & g(const double &x) {return format_element("", 'g', x); } - P &operator ()(const float x, const char *f = "") { format_element(f, "", "f", x); return static_cast

(*this); } - P & e(const float x, const char *f = "") { format_element(f, "", "e", x); return static_cast

(*this); } - P & g(const float x, const char *f = "") { format_element(f, "", "g", x); return static_cast

(*this); } + pfmt & e(const float &x) {return format_element("", 'e', static_cast(x)); } + pfmt & g(const float &x) {return format_element("", 'g', static_cast(x)); } - P &operator ()(const char *x, const char *f = "") { format_element(f, "", "s", x); return static_cast

(*this); } - P &operator ()(char *x, const char *f = "") { format_element(f, "", "s", x); return static_cast

(*this); } - P &operator ()(const void *x, const char *f = "") { format_element(f, "", "p", x); return static_cast

(*this); } - P &operator ()(const pstring &x, const char *f = "") { format_element(f, "", "s", x.c_str() ); return static_cast

(*this); } + pfmt &operator ()(const void *x) {return format_element("", 'p', x); } + pfmt &operator ()(const pstring &x) {return format_element("", 's', x.c_str() ); } template - P &operator ()(const T x, const char *f = "") + pfmt &operator ()(const T &x) { - if (ptype_traits::is_signed) - format_element(f, ptype_traits::size_specifier(), "d", ptype_traits::cast(x)); - else - format_element(f, ptype_traits::size_specifier(), "u", ptype_traits::cast(x)); - return static_cast

(*this); + return format_element(ptype_traits::size_spec(), ptype_traits::fmt_spec(), ptype_traits::cast(x)); } template - P &x(const T x, const char *f = "") + pfmt &operator ()(const T *x) { - format_element(f, ptype_traits::size_specifier(), "x", x); - return static_cast

(*this); + return format_element(ptype_traits::size_spec(), ptype_traits::fmt_spec(), ptype_traits::cast(x)); } template - P &o(const T x, const char *f = "") + pfmt &x(const T &x) { - format_element(f, ptype_traits::size_specifier(), "o", x); - return static_cast

(*this); + return format_element(ptype_traits::size_spec(), 'x', x); } + template + pfmt &o(const T &x) + { + return format_element(ptype_traits::size_spec(), 'o', x); + } protected: - ~pformat_base() { } - virtual void format_element(const char *f, const char *l, const char *fmt_spec, ...) = 0; - -}; - -class pfmt : public pformat_base -{ -public: - explicit pfmt(const pstring &fmt); - virtual ~pfmt(); - - operator pstring() const { return pstring(m_str, pstring::UTF8); } - - const char *c_str() { return m_str; } - - -protected: - void format_element(const char *f, const char *l, const char *fmt_spec, ...) override; + pfmt &format_element(const char *l, const unsigned fmt_spec, ...); private: - char *m_str; - char m_str_buf[256]; - std::size_t m_allocated; + pstring m_str; unsigned m_arg; }; @@ -194,42 +211,18 @@ public: template void log(const pstring & fmt, Args&&... args) const { - if (build_enabled && enabled && m_enabled) (*this)(fmt, std::forward(args)...); + if (build_enabled && enabled && m_enabled) + vdowrite(xlog(pfmt(fmt), std::forward(args)...)); } - void operator ()(const pstring &fmt) const + template + void operator ()(const pstring &fmt, Args&&... args) const { - if (build_enabled && m_enabled) vdowrite(fmt); - } - - template - void operator ()(const pstring &fmt, const T1 &v1) const - { - if (build_enabled && m_enabled) vdowrite(pfmt(fmt)(v1)); - } - - template - void operator ()(const pstring &fmt, const T1 &v1, const T2 &v2) const - { - if (build_enabled && m_enabled) vdowrite(pfmt(fmt)(v1)(v2)); - } - - template - void operator ()(const pstring &fmt, const T1 &v1, const T2 &v2, const T3 &v3) const - { - if (build_enabled && m_enabled) vdowrite(pfmt(fmt)(v1)(v2)(v3)); - } - - template - void operator ()(const pstring &fmt, const T1 &v1, const T2 &v2, const T3 &v3, const T4 &v4) const - { - if (build_enabled && m_enabled) vdowrite(pfmt(fmt)(v1)(v2)(v3)(v4)); - } - - template - void operator ()(const pstring &fmt, const T1 &v1, const T2 &v2, const T3 &v3, const T4 &v4, const T5 &v5) const - { - if (build_enabled && m_enabled) vdowrite(pfmt(fmt)(v1)(v2)(v3)(v4)(v5)); + if (build_enabled && m_enabled) + { + pfmt pf(fmt); + vdowrite(xlog(pf, std::forward(args)...)); + } } void set_enabled(const bool v) @@ -244,6 +237,14 @@ protected: virtual void vdowrite(const pstring &ls) const = 0; private: + pfmt &xlog(pfmt &fmt) const { return fmt; } + + template + pfmt &xlog(pfmt &fmt, X&& x, Args&&... args) const + { + return xlog(fmt(std::forward(x)), std::forward(args)...); + } + bool m_enabled; }; diff --git a/src/lib/netlist/plib/poptions.cpp b/src/lib/netlist/plib/poptions.cpp index c79fb28fe58..910660acb3d 100644 --- a/src/lib/netlist/plib/poptions.cpp +++ b/src/lib/netlist/plib/poptions.cpp @@ -136,7 +136,7 @@ namespace plib { std::size_t p = 1; opt = getopt_short(arg.substr(p, 1)); ++p; - if (p < arg.len()) + if (p < arg.length()) { has_equal_arg = true; opt_arg = arg.substr(p); @@ -184,7 +184,7 @@ namespace plib { pstring line = pstring("").rpad(" ", firstline_indent); for (auto &s : psplit(p, " ")) { - if (line.len() + s.len() > width) + if (line.length() + s.length() > width) { ret += line + "\n"; line = pstring("").rpad(" ", indent); @@ -228,14 +228,14 @@ namespace plib { { line += v + "|"; } - line = line.left(line.len() - 1); + line = line.left(line.length() - 1); } else line += "Value"; } } line = line.rpad(" ", indent - 2) + " "; - if (line.len() > indent) + if (line.length() > indent) { //ret += "TestGroup abc\n def gef\nxyz\n\n" ; ret += line + "\n"; @@ -259,7 +259,7 @@ namespace plib { ex += split_paragraphs(example->help(), width, 4, 4) + "\n"; } } - if (ex.len() > 0) + if (ex.length() > 0) { ret += "\n\nExamples:\n\n" + ex; } diff --git a/src/lib/netlist/plib/pparser.cpp b/src/lib/netlist/plib/pparser.cpp index 5253417695a..7547572192d 100644 --- a/src/lib/netlist/plib/pparser.cpp +++ b/src/lib/netlist/plib/pparser.cpp @@ -245,7 +245,7 @@ ptokenizer::token_t ptokenizer::get_token_internal() { tokstr += c; /* expensive, check for single char tokens */ - if (tokstr.len() == 1) + if (tokstr.length() == 1) { auto id = m_tokens.find(tokstr); if (id != m_tokens.end()) diff --git a/src/lib/netlist/plib/pstate.cpp b/src/lib/netlist/plib/pstate.cpp index 21ad55b6eb3..043033ed1ea 100644 --- a/src/lib/netlist/plib/pstate.cpp +++ b/src/lib/netlist/plib/pstate.cpp @@ -39,7 +39,7 @@ void state_manager_t::remove_save_items(const void *owner) for (auto i = m_custom.begin(); i != m_custom.end(); ) { if (i->get()->m_owner == owner) - i = m_save.erase(i); + i = m_custom.erase(i); else i++; } diff --git a/src/lib/netlist/plib/pstream.h b/src/lib/netlist/plib/pstream.h index 119ff8fbe3b..f78e6655f48 100644 --- a/src/lib/netlist/plib/pstream.h +++ b/src/lib/netlist/plib/pstream.h @@ -157,7 +157,7 @@ protected: m_buf += pstring(static_cast(buf), n, pstring::UTF8); } virtual void vseek(const pos_type n) override { } - virtual pos_type vtell() override { return m_buf.len(); } + virtual pos_type vtell() override { return m_buf.mem_t_size(); } private: pstring m_buf; @@ -284,7 +284,7 @@ private: class pistringstream : public pimemstream { public: - explicit pistringstream(const pstring &str) : pimemstream(str.c_str(), str.len()), m_str(str) { } + explicit pistringstream(const pstring &str) : pimemstream(str.c_str(), str.mem_t_size()), m_str(str) { } virtual ~pistringstream() override; private: @@ -348,7 +348,7 @@ public: void write(const pstring &text) const { - m_strm.write(text.c_str(), text.size()); + m_strm.write(text.c_str(), text.mem_t_size()); } void write(const pstring::code_t c) const @@ -391,8 +391,8 @@ public: void write(const pstring &s) { - write(s.size()); - m_strm.write(s.c_str(), s.size()); + write(s.mem_t_size()); + m_strm.write(s.c_str(), s.mem_t_size()); } template diff --git a/src/lib/netlist/plib/pstring.cpp b/src/lib/netlist/plib/pstring.cpp index 0fa6a6f83d9..554baac9bc7 100644 --- a/src/lib/netlist/plib/pstring.cpp +++ b/src/lib/netlist/plib/pstring.cpp @@ -23,14 +23,14 @@ std::size_t strlen_mem(const T *s) } template -int pstring_t::pcmp(const pstring_t &right) const +int pstring_t::compare(const pstring_t &right) const { - std::size_t l = std::min(size(), right.size()); + std::size_t l = std::min(mem_t_size(), right.mem_t_size()); if (l == 0) { - if (size() == 0 && right.size() == 0) + if (mem_t_size() == 0 && right.mem_t_size() == 0) return 0; - else if (right.size() == 0) + else if (right.mem_t_size() == 0) return 1; else return -1; @@ -45,9 +45,9 @@ int pstring_t::pcmp(const pstring_t &right) const int ret = (si == this->end() ? 0 : static_cast(*si) - static_cast(*ri)); if (ret == 0) { - if (this->size() > right.size()) + if (this->mem_t_size() > right.mem_t_size()) ret = 1; - else if (this->size() < right.size()) + else if (this->mem_t_size() < right.mem_t_size()) ret = -1; } return ret; @@ -58,7 +58,7 @@ pstring_t pstring_t::substr(size_type start, size_type nlen) const { pstring_t ret; //FIXME: throw ? - const size_type l = len(); + const size_type l = length(); if (start < l) { if (nlen == npos || start + nlen > l) @@ -73,7 +73,7 @@ pstring_t pstring_t::substr(size_type start, size_type nlen) const template pstring_t pstring_t::ucase() const { - pstring_t ret = ""; + pstring_t ret; for (const auto &c : *this) if (c >= 'a' && c <= 'z') ret += (c - 'a' + 'A'); @@ -149,17 +149,17 @@ typename pstring_t::size_type pstring_t::find(const pstring_t &search, siz template typename pstring_t::size_type pstring_t::find(code_t search, size_type start) const { - mem_t buf[traits_type::MAXCODELEN+1] = { 0 }; - traits_type::encode(search, buf); - return find(pstring_t(&buf[0], UTF8), start); + pstring_t ss; + traits_type::encode(search, ss.m_str); + return find(ss, start); } template pstring_t pstring_t::replace_all(const pstring_t &search, const pstring_t &replace) const { - pstring_t ret(""); - const size_type slen = search.len(); + pstring_t ret; + const size_type slen = search.length(); size_type last_s = 0; size_type s = find(search, last_s); @@ -180,22 +180,64 @@ pstring_t pstring_t::rpad(const pstring_t &ws, const size_type cnt) const // FIXME: pstringbuffer ret(*this); pstring_t ret(*this); - size_type wsl = ws.len(); - for (auto i = ret.len(); i < cnt; i+=wsl) + size_type wsl = ws.length(); + for (auto i = ret.length(); i < cnt; i+=wsl) ret += ws; return ret; } +static double pstod(const pstring_t &str, std::size_t *e) +{ + return std::stod(str.cpp_string(), e); +} + +static double pstod(const pstring &str, std::size_t *e) +{ + return std::stod(str.cpp_string(), e); +} + +static double pstod(const pwstring &str, std::size_t *e) +{ + return std::stod(str.cpp_string(), e); +} + +static double pstod(const pu16string &str, std::size_t *e) +{ + pstring c; + c = str; + return std::stod(c.cpp_string(), e); +} + +static long pstol(const pstring_t &str, std::size_t *e, int base = 10) +{ + return std::stol(str.cpp_string(), e, base); +} + +static long pstol(const pstring &str, std::size_t *e, int base = 10) +{ + return std::stol(str.cpp_string(), e, base); +} + +static long pstol(const pwstring &str, std::size_t *e, int base = 10) +{ + return std::stol(str.cpp_string(), e, base); +} + +static long pstol(const pu16string &str, std::size_t *e, int base = 10) +{ + pstring c; + c = str; + return std::stol(c.cpp_string(), e, base); +} + template double pstring_t::as_double(bool *error) const { - double ret; std::size_t e = 0; - if (error != nullptr) *error = false; - ret = std::stod(m_str, &e); - if (e != size()) + double ret = pstod(*this, &e); + if (e != mem_t_size()) if (error != nullptr) *error = true; return ret; @@ -204,16 +246,17 @@ double pstring_t::as_double(bool *error) const template long pstring_t::as_long(bool *error) const { + static pstring_t prefix(pstring("0x")); long ret; std::size_t e = 0; if (error != nullptr) *error = false; - if (startsWith("0x")) - ret = std::stol(substr(2).m_str, &e, 16); + if (startsWith(prefix)) + ret = pstol(substr(2), &e, 16); else - ret = std::stol(m_str, &e, 10); - if (e != size()) + ret = pstol(*this, &e, 10); + if (e != mem_t_size()) if (error != nullptr) *error = true; return ret; @@ -225,6 +268,5 @@ long pstring_t::as_long(bool *error) const template struct pstring_t; template struct pstring_t; - -const unsigned pu8_traits::MAXCODELEN; -const unsigned putf8_traits::MAXCODELEN; +template struct pstring_t; +template struct pstring_t; diff --git a/src/lib/netlist/plib/pstring.h b/src/lib/netlist/plib/pstring.h old mode 100644 new mode 100755 index 7410388af41..9462d81a122 --- a/src/lib/netlist/plib/pstring.h +++ b/src/lib/netlist/plib/pstring.h @@ -28,15 +28,31 @@ public: typedef typename traits_type::code_t code_t; typedef std::size_t size_type; typedef std::ptrdiff_t difference_type; + typedef typename traits_type::string_type string_type; + + class ref_value_type final + { + public: + ref_value_type() = delete; + ref_value_type(const ref_value_type &) = delete; + ref_value_type(ref_value_type &&) = delete; + ref_value_type &operator=(const ref_value_type &) = delete; + ref_value_type &operator=(ref_value_type &&) = delete; + operator code_t() const noexcept { return traits_type::code(&m); } + private: + const mem_t m; + }; + typedef const ref_value_type& const_reference ; + typedef const_reference reference; enum enc_t { - UTF8 + UTF8, + UTF16 }; // simple construction/destruction pstring_t() - : m_str("") { } ~pstring_t() @@ -54,10 +70,10 @@ public: { } - template + template::value>::type> pstring_t(C (&string)[N]) { - static_assert(std::is_same::value, "pstring constructor only accepts const mem_t"); static_assert(N > 0,"pstring from array of length 0"); if (string[N-1] != 0) throw std::exception(); @@ -68,35 +84,45 @@ public: : m_str(string.m_str) { } + explicit pstring_t(const string_type &string, const enc_t enc) + : m_str(string) + { } + pstring_t(pstring_t &&string) : m_str(string.m_str) { } explicit pstring_t(code_t code) { - pstring_t t; - t+= code; - m_str.assign(t.m_str); + *this += code; + } + + template ::value>::type> + explicit pstring_t(const pstring_t &string) + { + m_str.clear(); + for (auto &c : string) + *this += static_cast(c); // FIXME: codepage conversion for u8 } - // assignment operators pstring_t &operator=(const pstring_t &string) { m_str = string.m_str; return *this; } + template ::value>::type> + pstring_t &operator=(const pstring_t &string) + { + m_str.clear(); + for (auto &c : string) + *this += c; + return *this; + } + class const_iterator final { public: - class value_type final - { - public: - value_type() = delete; - value_type(const value_type &) = delete; - value_type(value_type &&) = delete; - value_type &operator=(const value_type &) = delete; - value_type &operator=(value_type &&) = delete; - operator code_t() const noexcept { return traits_type::code(&m); } - private: - const mem_t m; - }; + + typedef ref_value_type value_type; typedef value_type const *pointer; typedef value_type const &reference; @@ -104,7 +130,7 @@ public: typedef std::forward_iterator_tag iterator_category; const_iterator() noexcept : p() { } - explicit constexpr const_iterator(const std::string::const_iterator &x) noexcept : p(x) { } + explicit constexpr const_iterator(const typename string_type::const_iterator &x) noexcept : p(x) { } const_iterator(const const_iterator &rhs) noexcept = default; const_iterator(const_iterator &&rhs) noexcept = default; const_iterator &operator=(const const_iterator &rhs) noexcept = default; @@ -121,7 +147,7 @@ public: private: template friend struct pstring_t; - std::string::const_iterator p; + typename string_type::const_iterator p; }; // no non-const const_iterator for now @@ -136,10 +162,14 @@ public: // C string conversion helpers const mem_t *c_str() const { return static_cast(m_str.c_str()); } + const mem_t *data() const { return c_str(); } - size_type size() const { return m_str.size(); } + size_type length() const { return traits_type::len(m_str); } + size_type size() const { return traits_type::len(m_str); } + bool empty() const { return m_str.size() == 0; } pstring_t substr(size_type start, size_type nlen = npos) const; + int compare(const pstring_t &right) const; size_type find(const pstring_t &search, size_type start = 0) const; size_type find(code_t search, size_type start = 0) const; @@ -149,25 +179,27 @@ public: // concatenation operators pstring_t& operator+=(const pstring_t &string) { m_str.append(string.m_str); return *this; } - pstring_t& operator+=(const code_t c) { mem_t buf[traits_type::MAXCODELEN+1] = { 0 }; traits_type::encode(c, buf); m_str.append(buf); return *this; } + pstring_t& operator+=(const code_t c) { traits_type::encode(c, m_str); return *this; } friend pstring_t operator+(const pstring_t &lhs, const pstring_t &rhs) { return pstring_t(lhs) += rhs; } friend pstring_t operator+(const pstring_t &lhs, const code_t rhs) { return pstring_t(lhs) += rhs; } // comparison operators - bool operator==(const pstring_t &string) const { return (pcmp(string) == 0); } - bool operator!=(const pstring_t &string) const { return (pcmp(string) != 0); } + bool operator==(const pstring_t &string) const { return (compare(string) == 0); } + bool operator!=(const pstring_t &string) const { return (compare(string) != 0); } + + bool operator<(const pstring_t &string) const { return (compare(string) < 0); } + bool operator<=(const pstring_t &string) const { return (compare(string) <= 0); } + bool operator>(const pstring_t &string) const { return (compare(string) > 0); } + bool operator>=(const pstring_t &string) const { return (compare(string) >= 0); } - bool operator<(const pstring_t &string) const { return (pcmp(string) < 0); } - bool operator<=(const pstring_t &string) const { return (pcmp(string) <= 0); } - bool operator>(const pstring_t &string) const { return (pcmp(string) > 0); } - bool operator>=(const pstring_t &string) const { return (pcmp(string) >= 0); } + const_reference at(const size_type pos) const { return *reinterpret_cast(F::nthcode(m_str.c_str(),pos)); } /* The following is not compatible to std::string */ - bool equals(const pstring_t &string) const { return (pcmp(string) == 0); } + bool equals(const pstring_t &string) const { return (compare(string) == 0); } - bool startsWith(const pstring_t &arg) const { return arg.size() > size() ? false : m_str.compare(0, arg.size(), arg.m_str) == 0; } - bool endsWith(const pstring_t &arg) const { return arg.size() > size() ? false : m_str.compare(size()-arg.size(), arg.size(), arg.m_str) == 0; } + bool startsWith(const pstring_t &arg) const { return arg.mem_t_size() > mem_t_size() ? false : m_str.compare(0, arg.mem_t_size(), arg.m_str) == 0; } + bool endsWith(const pstring_t &arg) const { return arg.mem_t_size() > mem_t_size() ? false : m_str.compare(mem_t_size()-arg.mem_t_size(), arg.mem_t_size(), arg.m_str) == 0; } pstring_t replace_all(const pstring_t &search, const pstring_t &replace) const; pstring_t cat(const pstring_t &s) const { return *this + s; } @@ -178,14 +210,14 @@ public: double as_double(bool *error = nullptr) const; long as_long(bool *error = nullptr) const; - size_type len() const { return traits_type::len(m_str); } - /* the following are extensions to */ + size_type mem_t_size() const { return m_str.size(); } + pstring_t left(size_type len) const { return substr(0, len); } pstring_t right(size_type nlen) const { - return nlen >= len() ? pstring_t(*this) : substr(len() - nlen, nlen); + return nlen >= length() ? *this : substr(length() - nlen, nlen); } pstring_t ltrim(const pstring_t &ws = pstring_t(" \t\n\r")) const @@ -196,50 +228,45 @@ public: pstring_t rtrim(const pstring_t &ws = pstring_t(" \t\n\r")) const { auto f = find_last_not_of(ws); - if (f==npos) - return pstring_t(""); - else - return substr(0, f + 1); + return f == npos ? pstring_t() : substr(0, f + 1); } pstring_t trim(const pstring_t &ws = pstring_t(" \t\n\r")) const { return this->ltrim(ws).rtrim(ws); } pstring_t rpad(const pstring_t &ws, const size_type cnt) const; - code_t code_at(const size_type pos) const {return F::code(F::nthcode(m_str.c_str(),pos)); } - pstring_t ucase() const; + const string_type &cpp_string() const { return m_str; } + static const size_type npos = static_cast(-1); protected: - std::string m_str; + string_type m_str; private: - - int pcmp(const pstring_t &right) const; }; struct pu8_traits { - static const unsigned MAXCODELEN = 1; /* in memory units */ typedef char mem_t; typedef char code_t; - static std::size_t len(const std::string &p) { return p.size(); } - static unsigned codelen(const mem_t *p) { return 1; } - static unsigned codelen(const code_t c) { return 1; } + typedef std::string string_type; + static std::size_t len(const string_type &p) { return p.size(); } + static std::size_t codelen(const mem_t *p) { return 1; } + static std::size_t codelen(const code_t c) { return 1; } static code_t code(const mem_t *p) { return *p; } - static void encode(const code_t c, mem_t *p) { *p = c; } + static void encode(const code_t c, string_type &s) { s += static_cast(c); } static const mem_t *nthcode(const mem_t *p, const std::size_t n) { return &(p[n]); } }; /* No checking, this may deliver invalid codes */ struct putf8_traits { - static const unsigned MAXCODELEN = 4; /* in memory units, RFC 3629 */ typedef char mem_t; typedef char32_t code_t; - static std::size_t len(const std::string &p) + typedef std::string string_type; + static std::size_t len(const string_type &p) { std::size_t ret = 0; for (const auto &c : p) @@ -265,7 +292,7 @@ struct putf8_traits return 1; // not correct } } - static char32_t codelen(const code_t c) + static std::size_t codelen(const code_t c) { if (c < 0x0080) return 1; @@ -290,30 +317,29 @@ struct putf8_traits else return *p1; // not correct } - static void encode(const code_t c, mem_t *p) + static void encode(const code_t c, string_type &s) { - unsigned char *m = reinterpret_cast(p); if (c < 0x0080) { - m[0] = static_cast(c); + s += static_cast(c); } else if (c < 0x800) { - m[0] = static_cast(0xC0 | (c >> 6)); - m[1] = static_cast(0x80 | (c & 0x3f)); + s += static_cast(0xC0 | (c >> 6)); + s += static_cast(0x80 | (c & 0x3f)); } else if (c < 0x10000) { - m[0] = static_cast(0xE0 | (c >> 12)); - m[1] = static_cast(0x80 | ((c>>6) & 0x3f)); - m[2] = static_cast(0x80 | (c & 0x3f)); + s += static_cast(0xE0 | (c >> 12)); + s += static_cast(0x80 | ((c>>6) & 0x3f)); + s += static_cast(0x80 | (c & 0x3f)); } else /* U+10000 U+1FFFFF */ { - m[0] = static_cast(0xF0 | (c >> 18)); - m[1] = static_cast(0x80 | ((c>>12) & 0x3f)); - m[2] = static_cast(0x80 | ((c>>6) & 0x3f)); - m[3] = static_cast(0x80 | (c & 0x3f)); + s += static_cast(0xF0 | (c >> 18)); + s += static_cast(0x80 | ((c>>12) & 0x3f)); + s += static_cast(0x80 | ((c>>6) & 0x3f)); + s += static_cast(0x80 | (c & 0x3f)); } } static const mem_t *nthcode(const mem_t *p, const std::size_t n) @@ -326,17 +352,191 @@ struct putf8_traits } }; +struct putf16_traits +{ + typedef char16_t mem_t; + typedef char32_t code_t; + typedef std::u16string string_type; + static std::size_t len(const string_type &p) + { + std::size_t ret = 0; + auto i = p.begin(); + while (i != p.end()) + { + // FIXME: check that size is equal + uint16_t c = static_cast(*i++); + if (!((c & 0xd800) == 0xd800)) + ret++; + } + return ret; + } + static std::size_t codelen(const mem_t *p) + { + uint16_t c = static_cast(*p); + return ((c & 0xd800) == 0xd800) ? 2 : 1; + } + static std::size_t codelen(const code_t c) + { + if (c < 0x10000) + return 1; + else /* U+10000 U+1FFFFF */ + return 2; + } + static code_t code(const mem_t *p) + { + uint32_t c = static_cast(*p++); + if ((c & 0xd800) == 0xd800) + { + c = (c - 0xd800) << 10; + c += static_cast(*p) - 0xdc00 + 0x10000; + } + return static_cast(c); + } + static void encode(code_t c, string_type &s) + { + uint32_t cu = static_cast(c); + if (c > 0xffff) + { //make a surrogate pair + uint32_t t = ((cu - 0x10000) >> 10) + 0xd800; + cu = (cu & 0x3ff) + 0xdc00; + s += static_cast(t); + s += static_cast(cu); + } + else + { + s += static_cast(cu); + } + } + static const mem_t *nthcode(const mem_t *p, const std::size_t n) + { + std::size_t i = n; + while (i-- > 0) + p += codelen(p); + return p; + } +}; + +struct pwchar_traits +{ + typedef wchar_t mem_t; + typedef char32_t code_t; + typedef std::wstring string_type; + static std::size_t len(const string_type &p) + { + if (sizeof(wchar_t) == 2) + { + std::size_t ret = 0; + auto i = p.begin(); + while (i != p.end()) + { + // FIXME: check that size is equal + uint32_t c = static_cast(*i++); + if (!((c & 0xd800) == 0xd800)) + ret++; + } + return ret; + } + else + return p.size(); + } + + static std::size_t codelen(const mem_t *p) + { + if (sizeof(wchar_t) == 2) + { + uint16_t c = static_cast(*p); + return ((c & 0xd800) == 0xd800) ? 2 : 1; + } + else + return 1; + } + + static std::size_t codelen(const code_t c) + { + if (sizeof(wchar_t) == 2) + return ((c & 0xd800) == 0xd800) ? 2 : 1; + else + return 1; + } + + static code_t code(const mem_t *p) + { + if (sizeof(wchar_t) == 2) + { + uint32_t c = static_cast(*p++); + if ((c & 0xd800) == 0xd800) + { + c = (c - 0xd800) << 10; + c += static_cast(*p) - 0xdc00 + 0x10000; + } + return static_cast(c); + } + else + return static_cast(*p); + } + + static void encode(code_t c, string_type &s) + { + if (sizeof(wchar_t) == 2) + { + uint32_t cu = static_cast(c); + if (c > 0xffff) + { //make a surrogate pair + uint32_t t = ((cu - 0x10000) >> 10) + 0xd800; + cu = (cu & 0x3ff) + 0xdc00; + s += static_cast(t); + s += static_cast(cu); + } + else + s += static_cast(cu); + } + else + s += static_cast(c); + } + static const mem_t *nthcode(const mem_t *p, const std::size_t n) + { + if (sizeof(wchar_t) == 2) + { + std::size_t i = n; + while (i-- > 0) + p += codelen(p); + return p; + } + else + return p + n; + } +}; + extern template struct pstring_t; extern template struct pstring_t; +extern template struct pstring_t; +extern template struct pstring_t; typedef pstring_t pstring; +typedef pstring_t pu16string; +typedef pstring_t pwstring; + +namespace plib +{ + template + pstring to_string(const T &v) + { + return pstring(std::to_string(v), pstring::UTF8); + } + + template + pwstring to_wstring(const T &v) + { + return pwstring(std::to_wstring(v), pwstring::UTF16); + } +} // custom specialization of std::hash can be injected in namespace std namespace std { - template<> struct hash + template struct hash> { - typedef pstring argument_type; + typedef pstring_t argument_type; typedef std::size_t result_type; result_type operator()(argument_type const& s) const { diff --git a/src/lib/netlist/plib/putil.cpp b/src/lib/netlist/plib/putil.cpp index ddb300958ea..c34102417ec 100644 --- a/src/lib/netlist/plib/putil.cpp +++ b/src/lib/netlist/plib/putil.cpp @@ -50,15 +50,15 @@ namespace plib while (pn != pstring::npos) { pstring t = str.substr(p, pn - p); - if (!ignore_empty || t.len() != 0) + if (!ignore_empty || t.length() != 0) ret.push_back(t); - p = pn + onstr.len(); + p = pn + onstr.length(); pn = str.find(onstr, p); } - if (p < str.len()) + if (p < str.length()) { pstring t = str.substr(p); - if (!ignore_empty || t.len() != 0) + if (!ignore_empty || t.length() != 0) ret.push_back(t); } return ret; @@ -75,7 +75,7 @@ namespace plib std::size_t p = static_cast(-1); for (std::size_t j=0; j < onstrl.size(); j++) { - if (std::equal(onstrl[j].c_str(), onstrl[j].c_str() + onstrl[j].size(), i)) + if (std::equal(onstrl[j].begin(), onstrl[j].end(), i)) { p = j; break; @@ -88,7 +88,7 @@ namespace plib col = ""; ret.push_back(onstrl[p]); - i = std::next(i, static_cast(onstrl[p].len())); + i = std::next(i, static_cast(onstrl[p].length())); } else { diff --git a/src/lib/netlist/prg/nltool.cpp b/src/lib/netlist/prg/nltool.cpp old mode 100644 new mode 100755 index bde2bcd5b6c..cca0fbe2741 --- a/src/lib/netlist/prg/nltool.cpp +++ b/src/lib/netlist/prg/nltool.cpp @@ -591,7 +591,7 @@ void tool_app_t::listdevices() for (auto & f : list) { - pstring out = plib::pfmt("{1} {2}(")(f->classname(),"-20")(f->name()); + pstring out = plib::pfmt("{1:-20} {2}(")(f->classname())(f->name()); std::vector terms; f->macro_actions(nt.setup().netlist(), f->name() + "_lc"); @@ -602,7 +602,7 @@ void tool_app_t::listdevices() { if (t.second->name().startsWith(d->name())) { - pstring tn(t.second->name().substr(d->name().len()+1)); + pstring tn(t.second->name().substr(d->name().length()+1)); if (tn.find(".") == pstring::npos) terms.push_back(tn); } @@ -612,7 +612,7 @@ void tool_app_t::listdevices() { if (t.first.startsWith(d->name())) { - pstring tn(t.first.substr(d->name().len()+1)); + pstring tn(t.first.substr(d->name().length()+1)); //printf("\t%s %s %s\n", t.first.c_str(), t.second.c_str(), tn.c_str()); if (tn.find(".") == pstring::npos) { @@ -621,7 +621,7 @@ void tool_app_t::listdevices() //printf("\t%s %s %s\n", t.first.c_str(), t.second.c_str(), resolved.c_str()); if (resolved != t.first) { - auto found = std::find(terms.begin(), terms.end(), resolved.substr(d->name().len()+1)); + auto found = std::find(terms.begin(), terms.end(), resolved.substr(d->name().length()+1)); if (found!=terms.end()) terms.erase(found); } diff --git a/src/lib/netlist/solver/nld_matrix_solver.cpp b/src/lib/netlist/solver/nld_matrix_solver.cpp index 0323b35f3c8..6636bff6238 100644 --- a/src/lib/netlist/solver/nld_matrix_solver.cpp +++ b/src/lib/netlist/solver/nld_matrix_solver.cpp @@ -328,9 +328,9 @@ void matrix_solver_t::setup_matrix() if ((0)) for (unsigned k = 0; k < iN; k++) { - pstring line = plib::pfmt("{1}")(k, "3"); + pstring line = plib::pfmt("{1:3}")(k); for (unsigned j = 0; j < m_terms[k]->m_nzrd.size(); j++) - line += plib::pfmt(" {1}")(m_terms[k]->m_nzrd[j], "3"); + line += plib::pfmt(" {1:3}")(m_terms[k]->m_nzrd[j]); log().verbose("{1}", line); } diff --git a/src/lib/netlist/solver/nld_matrix_solver.h b/src/lib/netlist/solver/nld_matrix_solver.h index 50011d2ef6d..8bc383b5196 100644 --- a/src/lib/netlist/solver/nld_matrix_solver.h +++ b/src/lib/netlist/solver/nld_matrix_solver.h @@ -136,7 +136,7 @@ public: virtual std::pair create_solver_code() { - return std::pair("", plib::pfmt("/* {1} doesn't support static compile */")); + return std::pair("", plib::pfmt("/* solver doesn't support static compile */\n\n")); } protected: diff --git a/src/lib/netlist/solver/nld_ms_gcr.h b/src/lib/netlist/solver/nld_ms_gcr.h index b5601e9d65f..7e8e233d1cc 100644 --- a/src/lib/netlist/solver/nld_ms_gcr.h +++ b/src/lib/netlist/solver/nld_ms_gcr.h @@ -33,7 +33,7 @@ public: : matrix_solver_t(anetlist, name, matrix_solver_t::ASCENDING, params) , m_dim(size) , mat(size) - , m_proc(nullptr) + , m_proc() { } @@ -63,7 +63,8 @@ private: std::vector m_term_cr[storage_N]; mat_cr_t mat; - extsolver m_proc; + //extsolver m_proc; + plib::dynproc m_proc; }; @@ -153,11 +154,19 @@ void matrix_solver_GCR_t::vsetup(analog_net_t::list_t &nets) if (netlist().lib().isLoaded()) { pstring symname = static_compile_name(); +#if 0 m_proc = this->netlist().lib().template getsym(symname); if (m_proc != nullptr) this->log().verbose("External static solver {1} found ...", symname); else this->log().warning("External static solver {1} not found ...", symname); +#else + m_proc.load(this->netlist().lib(), symname); + if (m_proc.resolved()) + this->log().warning("External static solver {1} found ...", symname); + else + this->log().warning("External static solver {1} not found ...", symname); +#endif } } @@ -375,7 +384,8 @@ unsigned matrix_solver_GCR_t::vsolve_non_dynamic(const bool newt /* now solve it */ - if (m_proc != nullptr) + //if (m_proc != nullptr) + if (m_proc.resolved()) { //static_solver(m_A, RHS); m_proc(mat.A, RHS, new_V); diff --git a/src/lib/netlist/tools/nl_convert.cpp b/src/lib/netlist/tools/nl_convert.cpp index bbed33043d0..bedddba3cda 100644 --- a/src/lib/netlist/tools/nl_convert.cpp +++ b/src/lib/netlist/tools/nl_convert.cpp @@ -210,7 +210,7 @@ double nl_convert_base_t::get_sp_unit(const pstring &unit) double nl_convert_base_t::get_sp_val(const pstring &sin) { std::size_t p = 0; - while (p < sin.len() && (m_numberchars.find(sin.substr(p, 1)) != pstring::npos)) + while (p < sin.length() && (m_numberchars.find(sin.substr(p, 1)) != pstring::npos)) ++p; pstring val = sin.left(p); pstring unit = sin.substr(p); @@ -276,7 +276,7 @@ void nl_convert_spice_t::process_line(const pstring &line) { std::vector tt(plib::psplit(line, " ", true)); double val = 0.0; - switch (tt[0].code_at(0)) + switch (tt[0].at(0)) { case ';': out("// {}\n", line.substr(1)); @@ -316,14 +316,14 @@ void nl_convert_spice_t::process_line(const pstring &line) std::vector m(plib::psplit(model,"{")); if (m.size() == 2) { - if (m[1].len() != 4) + if (m[1].length() != 4) fprintf(stderr, "error with model desc %s\n", model.c_str()); pins = m[1].left(3); } add_device("QBJT_EB", tt[0], m[0]); - add_term(tt[1], tt[0] + "." + pins.code_at(0)); - add_term(tt[2], tt[0] + "." + pins.code_at(1)); - add_term(tt[3], tt[0] + "." + pins.code_at(2)); + add_term(tt[1], tt[0] + "." + pins.at(0)); + add_term(tt[2], tt[0] + "." + pins.at(1)); + add_term(tt[3], tt[0] + "." + pins.at(2)); } break; case 'R': @@ -467,7 +467,7 @@ void nl_convert_eagle_t::convert(const pstring &contents) tok.require_token(tok.m_tok_SEMICOLON); token = tok.get_token(); } - switch (name.code_at(0)) + switch (name.at(0)) { case 'Q': { -- cgit v1.2.3