summaryrefslogtreecommitdiffstatshomepage
diff options
context:
space:
mode:
author couriersud <couriersud@gmx.org>2017-03-31 18:07:35 +0200
committer couriersud <couriersud@gmx.org>2017-04-04 02:02:56 +0200
commit58aa97913fa966b03d3b5bed77c6670e49821f1e (patch)
tree22aa0c6d2a40ed4a751226ae33d28db6ae149be3
parent9e78adc115a11d4495d291b10d5177a9d06d62f2 (diff)
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)
-rw-r--r--src/lib/netlist/devices/nld_log.cpp4
-rw-r--r--src/lib/netlist/devices/nlid_truthtable.cpp4
-rw-r--r--src/lib/netlist/nl_setup.cpp12
-rw-r--r--src/lib/netlist/plib/pdynlib.h29
-rwxr-xr-x[-rw-r--r--]src/lib/netlist/plib/pfmtlog.cpp128
-rwxr-xr-x[-rw-r--r--]src/lib/netlist/plib/pfmtlog.h185
-rw-r--r--src/lib/netlist/plib/poptions.cpp10
-rw-r--r--src/lib/netlist/plib/pparser.cpp2
-rw-r--r--src/lib/netlist/plib/pstate.cpp2
-rw-r--r--src/lib/netlist/plib/pstream.h10
-rw-r--r--src/lib/netlist/plib/pstring.cpp94
-rwxr-xr-x[-rw-r--r--]src/lib/netlist/plib/pstring.h334
-rw-r--r--src/lib/netlist/plib/putil.cpp12
-rwxr-xr-x[-rw-r--r--]src/lib/netlist/prg/nltool.cpp8
-rw-r--r--src/lib/netlist/solver/nld_matrix_solver.cpp4
-rw-r--r--src/lib/netlist/solver/nld_matrix_solver.h2
-rw-r--r--src/lib/netlist/solver/nld_ms_gcr.h16
-rw-r--r--src/lib/netlist/tools/nl_convert.cpp14
18 files changed, 556 insertions, 314 deletions
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<double>(m_I())));
+ m_writer.writeline(plib::pfmt("{1:.9} {2}").e(netlist().time().as_double()).e(static_cast<double>(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<double>(m_I() - m_I2())));
+ m_writer.writeline(plib::pfmt("{1:.9} {2}").e(netlist().time().as_double()).e(static_cast<double>(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<pstring> 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<m_NO; j++)
m_timing[nstate * m_NO + j] = timing_index[j];
diff --git a/src/lib/netlist/nl_setup.cpp b/src/lib/netlist/nl_setup.cpp
index 9625ed5b15b..0d290c8dfcf 100644
--- a/src/lib/netlist/nl_setup.cpp
+++ b/src/lib/netlist/nl_setup.cpp
@@ -273,7 +273,7 @@ void setup_t::register_frontier(const pstring &attach, const double r_IN, const
void setup_t::register_param(const pstring &param, const double value)
{
- register_param(param, plib::pfmt("{1}").e(value,".9"));
+ register_param(param, plib::pfmt("{1:.9}").e(value));
}
void setup_t::register_param(const pstring &param, const pstring &value)
@@ -820,7 +820,7 @@ void setup_t::model_parse(const pstring &model_in, detail::model_map_t &map)
if (!remainder.endsWith(")"))
log().fatal(MF_1_MODEL_ERROR_1, model);
// FIMXE: Not optimal
- remainder = remainder.left(remainder.len() - 1);
+ remainder = remainder.left(remainder.length() - 1);
std::vector<pstring> 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<pstring::difference_type>(tmp.len() - 1));
+ auto p = std::next(tmp.begin(), static_cast<pstring::difference_type>(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<plib::pistream> source_string_t::stream(const pstring &name)
{
- return plib::make_unique_base<plib::pistream, plib::pimemstream>(m_str.c_str(), m_str.len());
+ return plib::make_unique_base<plib::pistream, plib::pimemstream>(m_str.c_str(), m_str.mem_t_size());
}
std::unique_ptr<plib::pistream> source_mem_t::stream(const pstring &name)
{
- return plib::make_unique_base<plib::pistream, plib::pimemstream>(m_str.c_str(), m_str.len());
+ return plib::make_unique_base<plib::pistream, plib::pimemstream>(m_str.c_str(), m_str.mem_t_size());
}
std::unique_ptr<plib::pistream> 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 <typename R, typename... Args>
+class dynproc
+{
+public:
+ using calltype = R(*) (Args... args);
+
+ dynproc() : m_sym(nullptr) { }
+
+ dynproc(dynlib &dl, const pstring &name)
+ {
+ m_sym = dl.getsym<calltype>(name);
+ }
+
+ void load(dynlib &dl, const pstring &name)
+ {
+ m_sym = dl.getsym<calltype>(name);
+ }
+
+ R operator ()(Args&&... args) const
+ {
+ return m_sym(std::forward<Args>(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
index 86d059d9247..ac4f0f6f046 100644..100755
--- a/src/lib/netlist/plib/pfmtlog.cpp
+++ b/src/lib/netlist/plib/pfmtlog.cpp
@@ -12,8 +12,8 @@
#include <cstdlib>
#include <cstdarg>
#include <algorithm>
-
-//* FIXME: remove cstring, replace with pstring */
+#include <locale>
+#include <iostream>
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<char>(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<std::size_t>(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<std::size_t>(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<std::size_t>(p1 - p + 1);
- strncat(fmt, p+1, static_cast<std::size_t>(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<std::size_t>(p1 - p + 1);
- if (m_arg>=10)
- strncat(fmt, p+4, static_cast<std::size_t>(p1 - p - 4));
- else
- strncat(fmt, p+3, static_cast<std::size_t>(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<std::size_t>(vsprintf(buf, fmt, ap));
- if (p != nullptr)
- {
- // check room
- std::size_t new_size = static_cast<std::size_t>(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<char>(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
index 200be024478..030de5d1fc5 100644..100755
--- a/src/lib/netlist/plib/pfmtlog.h
+++ b/src/lib/netlist/plib/pfmtlog.h
@@ -25,15 +25,20 @@ P_ENUM(plog_level,
template <typename T>
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<T>::is_signed;
+ static const char *size_spec() { return ""; }
+ static char32_t fmt_spec() { return 'u'; }
};
template <>
struct ptype_traits_base<bool>
{
- static unsigned int cast(bool x) { return static_cast<unsigned int>(x); }
+ static unsigned int cast(bool &x) { return static_cast<unsigned int>(x); }
+ static unsigned int cast(const bool &x) { return static_cast<unsigned int>(x); }
static const bool is_signed = std::numeric_limits<bool>::is_signed;
+ static const char *size_spec() { return ""; }
+ static char32_t fmt_spec() { return 'u'; }
};
template <typename T>
@@ -42,143 +47,155 @@ struct ptype_traits;
template<>
struct ptype_traits<bool> : ptype_traits_base<bool>
{
- static const char *size_specifier() { return ""; }
};
template<>
struct ptype_traits<char> : ptype_traits_base<char>
{
- 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<short> : ptype_traits_base<short>
{
- 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<int> : ptype_traits_base<int>
{
- static const char *size_specifier() { return ""; }
+ static char32_t fmt_spec() { return 'd'; }
};
template<>
struct ptype_traits<long> : ptype_traits_base<long>
{
- 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<long long> : ptype_traits_base<long long>
{
- 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<signed char> : ptype_traits_base<signed char>
{
- 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<unsigned char> : ptype_traits_base<unsigned char>
{
- 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<unsigned short> : ptype_traits_base<unsigned short>
{
- 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<unsigned int> : ptype_traits_base<unsigned int>
{
- static const char *size_specifier() { return ""; }
+ static char32_t fmt_spec() { return 'u'; }
};
template<>
struct ptype_traits<unsigned long> : ptype_traits_base<unsigned long>
{
- 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<unsigned long long> : ptype_traits_base<unsigned long long>
{
- static const char *size_specifier() { return "ll"; }
+ static const char *size_spec() { return "ll"; }
+ static char32_t fmt_spec() { return 'u'; }
};
-template <typename P>
-class pformat_base
+template<>
+struct ptype_traits<float> : ptype_traits_base<float>
+{
+ static char32_t fmt_spec() { return 'f'; }
+};
+
+template<>
+struct ptype_traits<double> : ptype_traits_base<double>
+{
+ static char32_t fmt_spec() { return 'f'; }
+};
+
+
+template<>
+struct ptype_traits<char *> : ptype_traits_base<char *>
+{
+ 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<P &>(*this); }
- P & e(const double x, const char *f = "") { format_element(f, "", "e", x); return static_cast<P &>(*this); }
- P & g(const double x, const char *f = "") { format_element(f, "", "g", x); return static_cast<P &>(*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<P &>(*this); }
- P & e(const float x, const char *f = "") { format_element(f, "", "e", x); return static_cast<P &>(*this); }
- P & g(const float x, const char *f = "") { format_element(f, "", "g", x); return static_cast<P &>(*this); }
+ pfmt & e(const float &x) {return format_element("", 'e', static_cast<double>(x)); }
+ pfmt & g(const float &x) {return format_element("", 'g', static_cast<double>(x)); }
- P &operator ()(const char *x, const char *f = "") { format_element(f, "", "s", x); return static_cast<P &>(*this); }
- P &operator ()(char *x, const char *f = "") { format_element(f, "", "s", x); return static_cast<P &>(*this); }
- P &operator ()(const void *x, const char *f = "") { format_element(f, "", "p", x); return static_cast<P &>(*this); }
- P &operator ()(const pstring &x, const char *f = "") { format_element(f, "", "s", x.c_str() ); return static_cast<P &>(*this); }
+ pfmt &operator ()(const void *x) {return format_element("", 'p', x); }
+ pfmt &operator ()(const pstring &x) {return format_element("", 's', x.c_str() ); }
template<typename T>
- P &operator ()(const T x, const char *f = "")
+ pfmt &operator ()(const T &x)
{
- if (ptype_traits<T>::is_signed)
- format_element(f, ptype_traits<T>::size_specifier(), "d", ptype_traits<T>::cast(x));
- else
- format_element(f, ptype_traits<T>::size_specifier(), "u", ptype_traits<T>::cast(x));
- return static_cast<P &>(*this);
+ return format_element(ptype_traits<T>::size_spec(), ptype_traits<T>::fmt_spec(), ptype_traits<T>::cast(x));
}
template<typename T>
- P &x(const T x, const char *f = "")
+ pfmt &operator ()(const T *x)
{
- format_element(f, ptype_traits<T>::size_specifier(), "x", x);
- return static_cast<P &>(*this);
+ return format_element(ptype_traits<T *>::size_spec(), ptype_traits<T *>::fmt_spec(), ptype_traits<T *>::cast(x));
}
template<typename T>
- P &o(const T x, const char *f = "")
+ pfmt &x(const T &x)
{
- format_element(f, ptype_traits<T>::size_specifier(), "o", x);
- return static_cast<P &>(*this);
+ return format_element(ptype_traits<T>::size_spec(), 'x', x);
}
+ template<typename T>
+ pfmt &o(const T &x)
+ {
+ return format_element(ptype_traits<T>::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<pfmt>
-{
-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<bool enabled, typename... Args>
void log(const pstring & fmt, Args&&... args) const
{
- if (build_enabled && enabled && m_enabled) (*this)(fmt, std::forward<Args>(args)...);
+ if (build_enabled && enabled && m_enabled)
+ vdowrite(xlog(pfmt(fmt), std::forward<Args>(args)...));
}
- void operator ()(const pstring &fmt) const
+ template<typename... Args>
+ void operator ()(const pstring &fmt, Args&&... args) const
{
- if (build_enabled && m_enabled) vdowrite(fmt);
- }
-
- template<typename T1>
- void operator ()(const pstring &fmt, const T1 &v1) const
- {
- if (build_enabled && m_enabled) vdowrite(pfmt(fmt)(v1));
- }
-
- template<typename T1, typename T2>
- void operator ()(const pstring &fmt, const T1 &v1, const T2 &v2) const
- {
- if (build_enabled && m_enabled) vdowrite(pfmt(fmt)(v1)(v2));
- }
-
- template<typename T1, typename T2, typename T3>
- 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<typename T1, typename T2, typename T3, typename T4>
- 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<typename T1, typename T2, typename T3, typename T4, typename T5>
- 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>(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<typename X, typename... Args>
+ pfmt &xlog(pfmt &fmt, X&& x, Args&&... args) const
+ {
+ return xlog(fmt(std::forward<X>(x)), std::forward<Args>(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<const pstring::mem_t *>(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 <typename T>
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<typename F>
-int pstring_t<F>::pcmp(const pstring_t &right) const
+int pstring_t<F>::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<F>::pcmp(const pstring_t &right) const
int ret = (si == this->end() ? 0 : static_cast<int>(*si) - static_cast<int>(*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<F> pstring_t<F>::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<F> pstring_t<F>::substr(size_type start, size_type nlen) const
template<typename F>
pstring_t<F> pstring_t<F>::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<F>::size_type pstring_t<F>::find(const pstring_t &search, siz
template<typename F>
typename pstring_t<F>::size_type pstring_t<F>::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<typename F>
pstring_t<F> pstring_t<F>::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<F> pstring_t<F>::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<pu8_traits> &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<pu8_traits> &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<typename F>
double pstring_t<F>::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<F>::as_double(bool *error) const
template<typename F>
long pstring_t<F>::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<F>::as_long(bool *error) const
template struct pstring_t<pu8_traits>;
template struct pstring_t<putf8_traits>;
-
-const unsigned pu8_traits::MAXCODELEN;
-const unsigned putf8_traits::MAXCODELEN;
+template struct pstring_t<putf16_traits>;
+template struct pstring_t<pwchar_traits>;
diff --git a/src/lib/netlist/plib/pstring.h b/src/lib/netlist/plib/pstring.h
index 7410388af41..9462d81a122 100644..100755
--- 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<typename C, std::size_t N>
+ template<typename C, std::size_t N,
+ class = typename std::enable_if<std::is_same<C, const mem_t>::value>::type>
pstring_t(C (&string)[N])
{
- static_assert(std::is_same<C, const mem_t>::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 <typename T,
+ class = typename std::enable_if<!std::is_same<T, pstring_t::traits_type>::value>::type>
+ explicit pstring_t(const pstring_t<T> &string)
+ {
+ m_str.clear();
+ for (auto &c : string)
+ *this += static_cast<code_t>(c); // FIXME: codepage conversion for u8
}
- // assignment operators
pstring_t &operator=(const pstring_t &string) { m_str = string.m_str; return *this; }
+ template <typename T,
+ class = typename std::enable_if<!std::is_same<T, pstring_t::traits_type>::value>::type>
+ pstring_t &operator=(const pstring_t<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 <typename G> 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<const mem_t *>(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<const ref_value_type *>(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 <string> */
+ 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<size_type>(-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<mem_t>(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<unsigned char *>(p);
if (c < 0x0080)
{
- m[0] = static_cast<unsigned char>(c);
+ s += static_cast<mem_t>(c);
}
else if (c < 0x800)
{
- m[0] = static_cast<unsigned char>(0xC0 | (c >> 6));
- m[1] = static_cast<unsigned char>(0x80 | (c & 0x3f));
+ s += static_cast<mem_t>(0xC0 | (c >> 6));
+ s += static_cast<mem_t>(0x80 | (c & 0x3f));
}
else if (c < 0x10000)
{
- m[0] = static_cast<unsigned char>(0xE0 | (c >> 12));
- m[1] = static_cast<unsigned char>(0x80 | ((c>>6) & 0x3f));
- m[2] = static_cast<unsigned char>(0x80 | (c & 0x3f));
+ s += static_cast<mem_t>(0xE0 | (c >> 12));
+ s += static_cast<mem_t>(0x80 | ((c>>6) & 0x3f));
+ s += static_cast<mem_t>(0x80 | (c & 0x3f));
}
else /* U+10000 U+1FFFFF */
{
- m[0] = static_cast<unsigned char>(0xF0 | (c >> 18));
- m[1] = static_cast<unsigned char>(0x80 | ((c>>12) & 0x3f));
- m[2] = static_cast<unsigned char>(0x80 | ((c>>6) & 0x3f));
- m[3] = static_cast<unsigned char>(0x80 | (c & 0x3f));
+ s += static_cast<mem_t>(0xF0 | (c >> 18));
+ s += static_cast<mem_t>(0x80 | ((c>>12) & 0x3f));
+ s += static_cast<mem_t>(0x80 | ((c>>6) & 0x3f));
+ s += static_cast<mem_t>(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<uint16_t>(*i++);
+ if (!((c & 0xd800) == 0xd800))
+ ret++;
+ }
+ return ret;
+ }
+ static std::size_t codelen(const mem_t *p)
+ {
+ uint16_t c = static_cast<uint16_t>(*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<uint32_t>(*p++);
+ if ((c & 0xd800) == 0xd800)
+ {
+ c = (c - 0xd800) << 10;
+ c += static_cast<uint32_t>(*p) - 0xdc00 + 0x10000;
+ }
+ return static_cast<code_t>(c);
+ }
+ static void encode(code_t c, string_type &s)
+ {
+ uint32_t cu = static_cast<uint32_t>(c);
+ if (c > 0xffff)
+ { //make a surrogate pair
+ uint32_t t = ((cu - 0x10000) >> 10) + 0xd800;
+ cu = (cu & 0x3ff) + 0xdc00;
+ s += static_cast<mem_t>(t);
+ s += static_cast<mem_t>(cu);
+ }
+ else
+ {
+ s += static_cast<mem_t>(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<uint32_t>(*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<uint16_t>(*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<uint32_t>(*p++);
+ if ((c & 0xd800) == 0xd800)
+ {
+ c = (c - 0xd800) << 10;
+ c += static_cast<uint32_t>(*p) - 0xdc00 + 0x10000;
+ }
+ return static_cast<code_t>(c);
+ }
+ else
+ return static_cast<code_t>(*p);
+ }
+
+ static void encode(code_t c, string_type &s)
+ {
+ if (sizeof(wchar_t) == 2)
+ {
+ uint32_t cu = static_cast<uint32_t>(c);
+ if (c > 0xffff)
+ { //make a surrogate pair
+ uint32_t t = ((cu - 0x10000) >> 10) + 0xd800;
+ cu = (cu & 0x3ff) + 0xdc00;
+ s += static_cast<mem_t>(t);
+ s += static_cast<mem_t>(cu);
+ }
+ else
+ s += static_cast<mem_t>(cu);
+ }
+ else
+ s += static_cast<wchar_t>(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<pu8_traits>;
extern template struct pstring_t<putf8_traits>;
+extern template struct pstring_t<putf16_traits>;
+extern template struct pstring_t<pwchar_traits>;
typedef pstring_t<putf8_traits> pstring;
+typedef pstring_t<putf16_traits> pu16string;
+typedef pstring_t<pwchar_traits> pwstring;
+
+namespace plib
+{
+ template<typename T>
+ pstring to_string(const T &v)
+ {
+ return pstring(std::to_string(v), pstring::UTF8);
+ }
+
+ template<typename T>
+ 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<pstring>
+ template<typename T> struct hash<pstring_t<T>>
{
- typedef pstring argument_type;
+ typedef pstring_t<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<std::size_t>(-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<pstring::difference_type>(onstrl[p].len()));
+ i = std::next(i, static_cast<pstring::difference_type>(onstrl[p].length()));
}
else
{
diff --git a/src/lib/netlist/prg/nltool.cpp b/src/lib/netlist/prg/nltool.cpp
index bde2bcd5b6c..cca0fbe2741 100644..100755
--- 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}(<id>")(f->classname(),"-20")(f->name());
+ pstring out = plib::pfmt("{1:-20} {2}(<id>")(f->classname())(f->name());
std::vector<pstring> 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<pstring, pstring> create_solver_code()
{
- return std::pair<pstring, pstring>("", plib::pfmt("/* {1} doesn't support static compile */"));
+ return std::pair<pstring, pstring>("", 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<unsigned> m_term_cr[storage_N];
mat_cr_t<storage_N> mat;
- extsolver m_proc;
+ //extsolver m_proc;
+ plib::dynproc<void, double * RESTRICT, double * RESTRICT, double * RESTRICT> m_proc;
};
@@ -153,11 +154,19 @@ void matrix_solver_GCR_t<m_N, storage_N>::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<extsolver>(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<m_N, storage_N>::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<pstring> 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<pstring> 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':
{