X-Git-Url: https://git.lyx.org/gitweb/?a=blobdiff_plain;f=src%2Fsupport%2Fdocstring.cpp;h=c937ba3721a1157bd2acff7d0bc754b74b0e614e;hb=43f6b1672b5ef442b4e9b7e4f7ea76dc14ac4fc8;hp=4ed503bb21e4b73cf26e6394ce71bcca44517369;hpb=7562340249a59084f617fd82da2eec54a0216b4d;p=lyx.git diff --git a/src/support/docstring.cpp b/src/support/docstring.cpp index 4ed503bb21..c937ba3721 100644 --- a/src/support/docstring.cpp +++ b/src/support/docstring.cpp @@ -10,48 +10,56 @@ #include -#include "docstring.h" -#include "qstring_helpers.h" -#include "unicode.h" +#include "support/docstring.h" -#include -#include +#include "support/lassert.h" +#include "support/lstrings.h" +#include "support/qstring_helpers.h" +#include "support/unicode.h" #include -#include +#include +#include +#include +using namespace std; -namespace lyx { +using lyx::support::isHexChar; +namespace lyx { docstring const from_ascii(char const * ascii) { docstring s; - for (char const * c = ascii; *c; ++c) { - BOOST_ASSERT(static_cast(*c) < 0x80); - s.push_back(*c); + if (int n = strlen(ascii)) { + s.resize(n); + char_type *d = &s[0]; + while (--n >= 0) { + d[n] = ascii[n]; + LASSERT(static_cast(ascii[n]) < 0x80, /**/); + } } return s; } -docstring const from_ascii(std::string const & ascii) +docstring const from_ascii(string const & ascii) { int const len = ascii.length(); for (int i = 0; i < len; ++i) - BOOST_ASSERT(static_cast(ascii[i]) < 0x80); + LASSERT(static_cast(ascii[i]) < 0x80, /**/); return docstring(ascii.begin(), ascii.end()); } -std::string const to_ascii(docstring const & ucs4) +string const to_ascii(docstring const & ucs4) { int const len = ucs4.length(); - std::string ascii; + string ascii; ascii.resize(len); for (int i = 0; i < len; ++i) { - BOOST_ASSERT(ucs4[i] < 0x80); + LASSERT(ucs4[i] < 0x80, /**/); ascii[i] = static_cast(ucs4[i]); } return ascii; @@ -66,7 +74,7 @@ IconvProcessor & utf8ToUcs4() -void utf8_to_ucs4(std::string const & utf8, docstring & ucs4) +void utf8_to_ucs4(string const & utf8, docstring & ucs4) { size_t n = utf8.size(); // as utf8 is a multi-byte encoding, there would be at most @@ -86,7 +94,7 @@ void utf8_to_ucs4(std::string const & utf8, docstring & ucs4) } -docstring const from_utf8(std::string const & utf8) +docstring const from_utf8(string const & utf8) { docstring ucs4; utf8_to_ucs4(utf8, ucs4); @@ -94,49 +102,70 @@ docstring const from_utf8(std::string const & utf8) } -std::string const to_utf8(docstring const & ucs4) +string const to_utf8(docstring const & ucs4) { - std::vector const utf8 = - ucs4_to_utf8(ucs4.data(), ucs4.size()); - return std::string(utf8.begin(), utf8.end()); + vector const utf8 = ucs4_to_utf8(ucs4.data(), ucs4.size()); + return string(utf8.begin(), utf8.end()); } -docstring const from_local8bit(std::string const & s) +docstring const from_local8bit(string const & s) { return qstring_to_ucs4(QString::fromLocal8Bit(s.data(), s.length())); } -const char* to_local8bit_failure::what() const throw() -{ - return "A string could not be converted from unicode to the local 8 bit encoding."; -} +/// Exception thrown by to_local8bit if the string could not be converted +class to_local8bit_failure : public bad_cast { +public: + to_local8bit_failure() throw() : bad_cast() {} + virtual ~to_local8bit_failure() throw() {} + virtual const char* what() const throw() + { + return "A string could not be converted from unicode to the local 8 bit encoding."; + } +}; -std::string const to_local8bit(docstring const & s) +string const to_local8bit(docstring const & s) { // This conversion can fail, depending on input. if (s.empty()) - return std::string(); + return string(); QByteArray const local = toqstr(s).toLocal8Bit(); - if (local.size() == 0) + if (local.isEmpty()) throw to_local8bit_failure(); - return std::string(local.begin(), local.end()); + return string(local.begin(), local.end()); } -docstring const from_filesystem8bit(std::string const & s) +docstring const from_filesystem8bit(string const & s) { QByteArray const encoded(s.c_str(), s.length()); return qstring_to_ucs4(QFile::decodeName(encoded)); } -std::string const to_filesystem8bit(docstring const & s) +string const to_filesystem8bit(docstring const & s) { QByteArray const encoded = QFile::encodeName(toqstr(s)); - return std::string(encoded.begin(), encoded.end()); + return string(encoded.begin(), encoded.end()); +} + + +string const to_iconv_encoding(docstring const & s, string const & encoding) +{ + std::vector const encoded = + ucs4_to_eightbit(s.data(), s.length(), encoding); + return string(encoded.begin(), encoded.end()); +} + + +docstring const from_iconv_encoding(string const & s, string const & encoding) +{ + std::vector const ucs4 = + eightbit_to_ucs4(s.data(), s.length(), encoding); + return docstring(ucs4.begin(), ucs4.end()); } @@ -151,7 +180,7 @@ bool operator==(lyx::docstring const & l, char const * r) lyx::docstring::const_iterator it = l.begin(); lyx::docstring::const_iterator end = l.end(); for (; it != end; ++it, ++r) { - BOOST_ASSERT(static_cast(*r) < 0x80); + LASSERT(static_cast(*r) < 0x80, /**/); if (!*r) return false; if (*it != static_cast(*r)) @@ -165,7 +194,7 @@ lyx::docstring operator+(lyx::docstring const & l, char const * r) { lyx::docstring s(l); for (char const * c = r; *c; ++c) { - BOOST_ASSERT(static_cast(*c) < 0x80); + LASSERT(static_cast(*c) < 0x80, /**/); s.push_back(*c); } return s; @@ -176,7 +205,7 @@ lyx::docstring operator+(char const * l, lyx::docstring const & r) { lyx::docstring s; for (char const * c = l; *c; ++c) { - BOOST_ASSERT(static_cast(*c) < 0x80); + LASSERT(static_cast(*c) < 0x80, /**/); s.push_back(*c); } s += r; @@ -186,14 +215,16 @@ lyx::docstring operator+(char const * l, lyx::docstring const & r) lyx::docstring operator+(lyx::docstring const & l, char r) { - BOOST_ASSERT(static_cast(r) < 0x80); - return l + lyx::docstring::value_type(r); + LASSERT(static_cast(r) < 0x80, /**/); + docstring s = l; + s += docstring::value_type(r); + return s; } lyx::docstring operator+(char l, lyx::docstring const & r) { - BOOST_ASSERT(static_cast(l) < 0x80); + LASSERT(static_cast(l) < 0x80, /**/); return lyx::docstring::value_type(l) + r; } @@ -201,7 +232,7 @@ lyx::docstring operator+(char l, lyx::docstring const & r) lyx::docstring & operator+=(lyx::docstring & l, char const * r) { for (char const * c = r; *c; ++c) { - BOOST_ASSERT(static_cast(*c) < 0x80); + LASSERT(static_cast(*c) < 0x80, /**/); l.push_back(*c); } return l; @@ -210,7 +241,7 @@ lyx::docstring & operator+=(lyx::docstring & l, char const * r) lyx::docstring & operator+=(lyx::docstring & l, char r) { - BOOST_ASSERT(static_cast(r) < 0x80); + LASSERT(static_cast(r) < 0x80, /**/); l.push_back(r); return l; } @@ -252,9 +283,9 @@ ctype::do_narrow(const lyx::char_type *, const lyx::char_type *, namespace lyx { -class ctype_failure : public std::bad_cast { +class ctype_failure : public bad_cast { public: - ctype_failure() throw() : std::bad_cast() {} + ctype_failure() throw() : bad_cast() {} virtual ~ctype_failure() throw() {} virtual const char* what() const throw() { @@ -263,9 +294,9 @@ public: }; -class num_put_failure : public std::bad_cast { +class num_put_failure : public bad_cast { public: - num_put_failure() throw() : std::bad_cast() {} + num_put_failure() throw() : bad_cast() {} virtual ~num_put_failure() throw() {} virtual const char* what() const throw() { @@ -276,13 +307,13 @@ public: /// ctype facet for UCS4 characters. The implementation does only support pure /// ASCII, since we do not need anything else for now. -/// The code is partly stolen from std::ctype from gcc. -class ascii_ctype_facet : public std::ctype +/// The code is partly stolen from ctype from gcc. +class ascii_ctype_facet : public ctype { public: typedef lyx::char_type char_type; typedef wctype_t wmask_type; - explicit ascii_ctype_facet(size_t refs = 0) : std::ctype(refs) + explicit ascii_ctype_facet(size_t refs = 0) : ctype(refs) { M_initialize_ctype(); } @@ -456,66 +487,66 @@ protected: /// Facet for outputting numbers to odocstreams as ascii. /// Here we simply need defining the virtual do_put functions. -class ascii_num_put_facet : public std::num_put > > +class ascii_num_put_facet : public num_put > > { - typedef std::ostreambuf_iterator > iter_type; + typedef ostreambuf_iterator > iter_type; public: - ascii_num_put_facet(size_t refs = 0) : std::num_put(refs) {} + ascii_num_put_facet(size_t refs = 0) : num_put(refs) {} /// Facet for converting numbers to ascii strings. - class string_num_put_facet : public std::num_put::iterator> + class string_num_put_facet : public num_put::iterator> { public: - string_num_put_facet() : std::num_put::iterator>(1) {} + string_num_put_facet() : num_put::iterator>(1) {} }; protected: iter_type - do_put(iter_type oit, std::ios_base & b, char_type fill, bool v) const + do_put(iter_type oit, ios_base & b, char_type fill, bool v) const { return do_put_helper(oit, b, fill, v); } iter_type - do_put(iter_type oit, std::ios_base & b, char_type fill, long v) const + do_put(iter_type oit, ios_base & b, char_type fill, long v) const { return do_put_helper(oit, b, fill, v); } iter_type - do_put(iter_type oit, std::ios_base & b, char_type fill, unsigned long v) const + do_put(iter_type oit, ios_base & b, char_type fill, unsigned long v) const { return do_put_helper(oit, b, fill, v); } #ifdef _GLIBCXX_USE_LONG_LONG iter_type - do_put(iter_type oit, std::ios_base & b, char_type fill, long long v) const + do_put(iter_type oit, ios_base & b, char_type fill, long long v) const { return do_put_helper(oit, b, fill, v); } iter_type - do_put(iter_type oit, std::ios_base & b, char_type fill, unsigned long long v) const + do_put(iter_type oit, ios_base & b, char_type fill, unsigned long long v) const { return do_put_helper(oit, b, fill, v); } #endif iter_type - do_put(iter_type oit, std::ios_base & b, char_type fill, double v) const + do_put(iter_type oit, ios_base & b, char_type fill, double v) const { return do_put_helper(oit, b, fill, v); } iter_type - do_put(iter_type oit, std::ios_base & b, char_type fill, long double v) const + do_put(iter_type oit, ios_base & b, char_type fill, long double v) const { return do_put_helper(oit, b, fill, v); } iter_type - do_put(iter_type oit, std::ios_base & b, char_type fill, void const * v) const + do_put(iter_type oit, ios_base & b, char_type fill, void const * v) const { return do_put_helper(oit, b, fill, v); } @@ -523,19 +554,19 @@ protected: private: template iter_type - do_put_helper(iter_type oit, std::ios_base & b, char_type fill, ValueType v) const + do_put_helper(iter_type oit, ios_base & b, char_type fill, ValueType v) const { if (fill >= 0x80) throw num_put_failure(); - std::streamsize const sz = b.width() > b.precision() ? + streamsize const sz = b.width() > b.precision() ? b.width() : b.precision(); // 64 is large enough, unless width or precision are bigger - std::streamsize const wd = (sz > 56 ? sz : 56) + 8; - std::string s(wd, '\0'); + streamsize const wd = (sz > 56 ? sz : 56) + 8; + string s(wd, '\0'); string_num_put_facet f; - std::string::const_iterator cit = s.begin(); - std::string::const_iterator end = + string::const_iterator cit = s.begin(); + string::const_iterator end = f.put(s.begin(), b, fill, v); for (; cit != end; ++cit, ++oit) *oit = *cit; @@ -547,34 +578,163 @@ private: /// Facet for inputting ascii representations of numbers from idocstreams. /// Here we simply need defining the virtual do_get functions. -class ascii_num_get_facet : public std::num_get > > +class ascii_num_get_facet : public num_get > > { - typedef std::istreambuf_iterator > iter_type; + typedef istreambuf_iterator > iter_type; public: - ascii_num_get_facet(size_t refs = 0) : std::num_get(refs) {} + ascii_num_get_facet(size_t refs = 0) : num_get(refs) {} /// Facet for converting ascii representation of numbers to a value. - class string_num_get_facet : public std::num_get::iterator> + class string_num_get_facet : public num_get::iterator> { public: - string_num_get_facet() : std::num_get::iterator>(1) {} + string_num_get_facet() : num_get::iterator>(1) {} }; -private: - bool isNumpunct(lyx::char_type const c) const + /// Numpunct facet defining the I/O format. + class numpunct_facet : public numpunct { - /// Only account for the standard numpunct "C" locale facet. - return c < 0x80 && (c == '-' || c == '+' || isdigit(c) - || ('a' <= c && c <= 'f') || ('A' <= c && c <= 'F') - || c == 'x' || c == 'X'); - } + public: + numpunct_facet() : numpunct(1) {} + }; protected: iter_type - do_get(iter_type iit, iter_type eit, std::ios_base & b, - std::ios_base::iostate & err, long & v) const + do_get(iter_type iit, iter_type eit, ios_base & b, + ios_base::iostate & err, bool & v) const + { + if (b.flags() & ios_base::boolalpha) { + numpunct_facet p; + lyx::docstring const truename = from_local8bit(p.truename()); + lyx::docstring const falsename = from_local8bit(p.falsename()); + lyx::docstring s; + s.resize(16); + bool ok = true; + size_t n = 0; + size_t const tsize = truename.size(); + size_t const fsize = falsename.size(); + for (; iit != eit; ++iit) { + s += *iit; + ++n; + bool true_ok = support::prefixIs(truename, s); + bool false_ok = support::prefixIs(falsename, s); + if (!true_ok && !false_ok) { + ++iit; + ok = false; + break; + } + if ((true_ok && n == tsize) || + (false_ok && n == fsize)) { + ++iit; + break; + } + } + if (ok) { + err = ios_base::goodbit; + v = truename == s ? true : false; + } else + err = ios_base::failbit; + if (iit == eit) + err |= ios_base::eofbit; + return iit; + } else { + long l; + iter_type end = this->do_get(iit, eit, b, err, l); + if (!(err & ios_base::failbit)) { + if (l == 0) + v = false; + else if (l == 1) + v = true; + else + err |= ios_base::failbit; + } + return end; + } + } + + iter_type + do_get(iter_type iit, iter_type eit, ios_base & b, + ios_base::iostate & err, long & v) const + { + return do_get_integer(iit, eit, b, err, v); + } + + iter_type + do_get(iter_type iit, iter_type eit, ios_base & b, + ios_base::iostate & err, unsigned short & v) const + { + return do_get_integer(iit, eit, b, err, v); + } + + iter_type + do_get(iter_type iit, iter_type eit, ios_base & b, + ios_base::iostate & err, unsigned int & v) const + { + return do_get_integer(iit, eit, b, err, v); + } + + iter_type + do_get(iter_type iit, iter_type eit, ios_base & b, + ios_base::iostate & err, unsigned long & v) const + { + return do_get_integer(iit, eit, b, err, v); + } + +#ifdef _GLIBCXX_USE_LONG_LONG + iter_type + do_get(iter_type iit, iter_type eit, ios_base & b, + ios_base::iostate & err, long long & v) const + { + return do_get_integer(iit, eit, b, err, v); + } + + iter_type + do_get(iter_type iit, iter_type eit, ios_base & b, + ios_base::iostate & err, unsigned long long & v) const + { + return do_get_integer(iit, eit, b, err, v); + } +#endif + + iter_type + do_get(iter_type iit, iter_type eit, ios_base & b, + ios_base::iostate & err, float & v) const + { + return do_get_float(iit, eit, b, err, v); + } + + iter_type + do_get(iter_type iit, iter_type eit, ios_base & b, + ios_base::iostate & err, double & v) const + { + return do_get_float(iit, eit, b, err, v); + } + + iter_type + do_get(iter_type iit, iter_type eit, ios_base & b, + ios_base::iostate & err, long double & v) const + { + return do_get_float(iit, eit, b, err, v); + } + + iter_type + do_get(iter_type iit, iter_type eit, ios_base & b, + ios_base::iostate & err, void * & v) const + { + unsigned long val; + iter_type end = do_get_integer(iit, eit, b, err, val); + if (!(err & ios_base::failbit)) + v = reinterpret_cast(val); + return end; + } + +private: + template + iter_type + do_get_integer(iter_type iit, iter_type eit, ios_base & b, + ios_base::iostate & err, ValueType & v) const { - std::string s; + string s; s.reserve(64); for (; iit != eit && isNumpunct(*iit); ++iit) s += static_cast(*iit); @@ -585,9 +745,65 @@ protected: s += ' '; string_num_get_facet f; f.get(s.begin(), s.end(), b, err, v); + if (iit == eit) + err |= ios_base::eofbit; + + return iit; + } + + bool isNumpunct(lyx::char_type const c) const + { + /// Only account for the standard numpunct "C" locale facet. + return c == '-' || c == '+' + || c == 'x' || c == 'X' + || isHexChar(c); + } + + template + iter_type + do_get_float(iter_type iit, iter_type eit, ios_base & b, + ios_base::iostate & err, ValueType & v) const + { + // Gather a string of the form + // [+-]? [0-9]* .? [0-9]* ([eE] [+-]? [0-9]+)? + string s; + s.reserve(64); + char c; + numpunct_facet p; + char const dot = p.decimal_point(); + char const sep = p.thousands_sep(); + // Get an optional sign + if (iit != eit && (*iit == '-' || *iit == '+')) { + s += static_cast(*iit); + ++iit; + } + for (; iit != eit && isDigitOrSep(*iit, sep); ++iit) + s += static_cast(*iit); + if (iit != eit && *iit == dot) { + s += dot; + ++iit; + for (; iit != eit && isDigitOrSep(*iit, 0); ++iit) + s += static_cast(*iit); + if (iit != eit && (*iit == 'e' || *iit == 'E')) { + s += static_cast(*iit); + ++iit; + for (; iit != eit && isDigitOrSep(*iit, 0); ++iit) + s += static_cast(*iit); + } + } + s += '\n'; + string_num_get_facet f; + f.get(s.begin(), s.end(), b, err, v); + if (iit == eit) + err |= ios_base::eofbit; return iit; } + + bool isDigitOrSep(lyx::char_type const c, char const sep) const + { + return (c >= '0' && c <= '9') || (c != 0 && c == sep); + } }; @@ -596,11 +812,11 @@ class locale_initializer { public: locale_initializer() { - std::locale global; - std::locale const loc1(global, new ascii_ctype_facet); - std::locale const loc2(loc1, new ascii_num_put_facet); - std::locale const loc3(loc2, new ascii_num_get_facet); - std::locale::global(loc3); + locale global; + locale const loc1(global, new ascii_ctype_facet); + locale const loc2(loc1, new ascii_num_put_facet); + locale const loc3(loc2, new ascii_num_get_facet); + locale::global(loc3); } };