#include <config.h>
-#include "docstring.h"
-#include "qstring_helpers.h"
-#include "unicode.h"
+#include "support/docstring.h"
-#include <locale>
-#include <iostream>
+#include "support/lassert.h"
+#include "support/lstrings.h"
+#include "support/qstring_helpers.h"
+#include "support/unicode.h"
#include <QFile>
-#include <boost/assert.hpp>
+//Needed in Ubuntu
+#include <typeinfo>
+#if ! defined(USE_WCHAR_T) && defined(__GNUC__)
+#include <locale>
+#include <iostream>
+#endif
+
+using namespace std;
+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<unsigned char>(*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];
+ LATTEST(static_cast<unsigned char>(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<unsigned char>(ascii[i]) < 0x80);
+ LATTEST(static_cast<unsigned char>(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);
+ LATTEST(ucs4[i] < 0x80);
ascii[i] = static_cast<char>(ucs4[i]);
}
return ascii;
}
-IconvProcessor & utf8ToUcs4()
-{
- static IconvProcessor iconv(ucs4_codeset, "UTF-8");
- return iconv;
-}
-
-
-
-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
}
-docstring const from_utf8(std::string const & utf8)
+docstring const from_utf8(string const & utf8)
{
docstring ucs4;
utf8_to_ucs4(utf8, ucs4);
}
-std::string const to_utf8(docstring const & ucs4)
+string const to_utf8(docstring const & ucs4)
{
- std::vector<char> const utf8 =
- ucs4_to_utf8(ucs4.data(), ucs4.size());
- return std::string(utf8.begin(), utf8.end());
+ vector<char> 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() noexcept : bad_cast() {}
+ virtual ~to_local8bit_failure() noexcept {}
+ const char* what() const noexcept override
+ {
+ 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<char> 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<char_type> const ucs4 =
+ eightbit_to_ucs4(s.data(), s.length(), encoding);
+ return docstring(ucs4.begin(), ucs4.end());
}
lyx::docstring::const_iterator it = l.begin();
lyx::docstring::const_iterator end = l.end();
for (; it != end; ++it, ++r) {
- BOOST_ASSERT(static_cast<unsigned char>(*r) < 0x80);
+ LASSERT(static_cast<unsigned char>(*r) < 0x80, return false);
if (!*r)
return false;
if (*it != static_cast<lyx::docstring::value_type>(*r))
{
lyx::docstring s(l);
for (char const * c = r; *c; ++c) {
- BOOST_ASSERT(static_cast<unsigned char>(*c) < 0x80);
+ LASSERT(static_cast<unsigned char>(*c) < 0x80, return l);
s.push_back(*c);
}
return s;
{
lyx::docstring s;
for (char const * c = l; *c; ++c) {
- BOOST_ASSERT(static_cast<unsigned char>(*c) < 0x80);
+ LASSERT(static_cast<unsigned char>(*c) < 0x80, return r);
s.push_back(*c);
}
s += r;
lyx::docstring operator+(lyx::docstring const & l, char r)
{
- BOOST_ASSERT(static_cast<unsigned char>(r) < 0x80);
- return l + lyx::docstring::value_type(r);
+ LASSERT(static_cast<unsigned char>(r) < 0x80, return l);
+ docstring s = l;
+ s += docstring::value_type(r);
+ return s;
}
lyx::docstring operator+(char l, lyx::docstring const & r)
{
- BOOST_ASSERT(static_cast<unsigned char>(l) < 0x80);
+ LASSERT(static_cast<unsigned char>(l) < 0x80, return r);
return lyx::docstring::value_type(l) + r;
}
lyx::docstring & operator+=(lyx::docstring & l, char const * r)
{
for (char const * c = r; *c; ++c) {
- BOOST_ASSERT(static_cast<unsigned char>(*c) < 0x80);
+ LASSERT(static_cast<unsigned char>(*c) < 0x80, return l);
l.push_back(*c);
}
return l;
lyx::docstring & operator+=(lyx::docstring & l, char r)
{
- BOOST_ASSERT(static_cast<unsigned char>(r) < 0x80);
+ LASSERT(static_cast<unsigned char>(r) < 0x80, return l);
l.push_back(r);
return l;
}
// We get undefined references to these virtual methods. This looks like
// a bug in gcc. The implementation here does not do anything useful, since
-// it is overriden in ascii_ctype_facet.
+// it is overridden in ascii_ctype_facet.
namespace std {
template<> ctype<lyx::char_type>::~ctype() {}
template<> bool
ctype<lyx::char_type>::do_narrow(const lyx::char_type, char) const { return 0; }
template<> const lyx::char_type *
ctype<lyx::char_type>::do_narrow(const lyx::char_type *, const lyx::char_type *, char, char *) const { return 0; }
-}
+} // namespace std
namespace lyx {
-class ctype_failure : public std::bad_cast {
+class ctype_failure : public bad_cast {
public:
- ctype_failure() throw() : std::bad_cast() {}
- virtual ~ctype_failure() throw() {}
- virtual const char* what() const throw()
+ ctype_failure() noexcept : bad_cast() {}
+ virtual ~ctype_failure() noexcept {}
+ const char* what() const noexcept override
{
return "The ctype<lyx::char_type> locale facet does only support ASCII characters on this platform.";
}
};
-class num_put_failure : public std::bad_cast {
+class num_put_failure : public bad_cast {
public:
- num_put_failure() throw() : std::bad_cast() {}
- virtual ~num_put_failure() throw() {}
- virtual const char* what() const throw()
+ num_put_failure() noexcept : bad_cast() {}
+ virtual ~num_put_failure() noexcept {}
+ const char* what() const noexcept override
{
return "The num_put locale facet does only support ASCII characters on this platform.";
}
/// 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<wchar_t> from gcc.
-class ascii_ctype_facet : public std::ctype<lyx::char_type>
+/// The code is partly stolen from ctype<wchar_t> from gcc.
+class ascii_ctype_facet : public ctype<lyx::char_type>
{
public:
typedef lyx::char_type char_type;
typedef wctype_t wmask_type;
- explicit ascii_ctype_facet(size_t refs = 0) : std::ctype<char_type>(refs)
+ explicit ascii_ctype_facet(size_t refs = 0) : ctype<char_type>(refs)
{
M_initialize_ctype();
}
const int c = wctob(i);
if (c == EOF)
break;
- else
- M_narrow[i] = static_cast<char>(c);
+ M_narrow[i] = static_cast<char>(c);
}
if (i == 128)
M_narrow_ok = true;
}
}
virtual ~ascii_ctype_facet() {}
- char_type do_toupper(char_type c) const
+ char_type do_toupper(char_type c) const override
{
if (c >= 0x80)
throw ctype_failure();
return toupper(static_cast<int>(c));
}
- char_type const * do_toupper(char_type * lo, char_type const * hi) const
+ char_type const * do_toupper(char_type * lo, char_type const * hi) const override
{
while (lo < hi) {
if (*lo >= 0x80)
}
return hi;
}
- char_type do_tolower(char_type c) const
+ char_type do_tolower(char_type c) const override
{
if (c >= 0x80)
throw ctype_failure();
return tolower(c);
}
- char_type const * do_tolower(char_type * lo, char_type const * hi) const
+ char_type const * do_tolower(char_type * lo, char_type const * hi) const override
{
while (lo < hi) {
if (*lo >= 0x80)
}
return hi;
}
- bool do_is(mask m, char_type c) const
+ bool do_is(mask m, char_type c) const override
{
if (c >= 0x80)
throw ctype_failure();
}
return ret;
}
- char_type const * do_is(char_type const * lo, char_type const * hi, mask * vec) const
+ char_type const * do_is(char_type const * lo, char_type const * hi, mask * vec) const override
{
for (;lo < hi; ++vec, ++lo) {
if (*lo >= 0x80)
}
return hi;
}
- char_type const * do_scan_is(mask m, char_type const * lo, char_type const * hi) const
+ char_type const * do_scan_is(mask m, char_type const * lo, char_type const * hi) const override
{
while (lo < hi && !this->do_is(m, *lo))
++lo;
return lo;
}
- char_type const * do_scan_not(mask m, char_type const * lo, char_type const * hi) const
+ char_type const * do_scan_not(mask m, char_type const * lo, char_type const * hi) const override
{
while (lo < hi && this->do_is(m, *lo) != 0)
++lo;
return lo;
}
- char_type do_widen(char c) const
+ char_type do_widen(char c) const override
{
if (static_cast<unsigned char>(c) < 0x80)
return c;
throw ctype_failure();
}
- const char* do_widen(const char* lo, const char* hi, char_type* dest) const
+ const char* do_widen(const char* lo, const char* hi, char_type* dest) const override
{
while (lo < hi) {
if (static_cast<unsigned char>(*lo) >= 0x80)
}
return hi;
}
- char do_narrow(char_type wc, char) const
+ char do_narrow(char_type wc, char) const override
{
if (wc < 0x80)
return static_cast<char>(wc);
throw ctype_failure();
}
- const char_type * do_narrow(const char_type * lo, const char_type * hi, char, char * dest) const
+ const char_type * do_narrow(const char_type * lo, const char_type * hi, char, char * dest) const override
{
while (lo < hi) {
if (*lo < 0x80)
/// 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<lyx::char_type, std::ostreambuf_iterator<lyx::char_type, std::char_traits<lyx::char_type> > >
+class ascii_num_put_facet : public num_put<lyx::char_type, ostreambuf_iterator<lyx::char_type, char_traits<lyx::char_type> > >
{
- typedef std::ostreambuf_iterator<lyx::char_type, std::char_traits<lyx::char_type> > iter_type;
+ typedef ostreambuf_iterator<lyx::char_type, char_traits<lyx::char_type> > iter_type;
public:
- ascii_num_put_facet(size_t refs = 0) : std::num_put<lyx::char_type, iter_type>(refs) {}
+ ascii_num_put_facet(size_t refs = 0) : num_put<lyx::char_type, iter_type>(refs) {}
/// Facet for converting numbers to ascii strings.
- class string_num_put_facet : public std::num_put<char, std::basic_string<char>::iterator>
+ class string_num_put_facet : public num_put<char, basic_string<char>::iterator>
{
public:
- string_num_put_facet() : std::num_put<char, std::basic_string<char>::iterator>(1) {}
+ string_num_put_facet() : num_put<char, basic_string<char>::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 override
{
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 override
{
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 override
{
return do_put_helper(oit, b, fill, v);
}
-#ifdef _GLIBCXX_USE_LONG_LONG
+#ifdef HAVE_LONG_LONG_INT
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 override
{
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 override
{
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 override
{
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 override
{
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 override
{
return do_put_helper(oit, b, fill, v);
}
private:
template <typename ValueType>
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;
/// 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<lyx::char_type, std::istreambuf_iterator<lyx::char_type, std::char_traits<lyx::char_type> > >
+class ascii_num_get_facet : public num_get<lyx::char_type, istreambuf_iterator<lyx::char_type, char_traits<lyx::char_type> > >
{
- typedef std::istreambuf_iterator<lyx::char_type, std::char_traits<lyx::char_type> > iter_type;
+ typedef istreambuf_iterator<lyx::char_type, char_traits<lyx::char_type> > iter_type;
public:
- ascii_num_get_facet(size_t refs = 0) : std::num_get<lyx::char_type, iter_type>(refs) {}
+ ascii_num_get_facet(size_t refs = 0) : num_get<lyx::char_type, iter_type>(refs) {}
/// Facet for converting ascii representation of numbers to a value.
- class string_num_get_facet : public std::num_get<char, std::basic_string<char>::iterator>
+ class string_num_get_facet : public num_get<char, basic_string<char>::iterator>
{
public:
- string_num_get_facet() : std::num_get<char, std::basic_string<char>::iterator>(1) {}
+ string_num_get_facet() : num_get<char, basic_string<char>::iterator>(1) {}
};
-private:
- bool isNumpunct(lyx::char_type const c) const
+ /// Numpunct facet defining the I/O format.
+ class numpunct_facet : public numpunct<char>
{
- /// 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<char>(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 override
+ {
+ 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);
+ } 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 override
+ {
+ 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 override
+ {
+ 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 override
+ {
+ 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 override
{
- std::string s;
+ return do_get_integer(iit, eit, b, err, v);
+ }
+
+#ifdef HAVE_LONG_LONG_INT
+ iter_type
+ do_get(iter_type iit, iter_type eit, ios_base & b,
+ ios_base::iostate & err, long long & v) const override
+ {
+ 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 override
+ {
+ 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 override
+ {
+ 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 override
+ {
+ 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 override
+ {
+ 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 override
+ {
+ unsigned long val;
+ iter_type end = do_get_integer(iit, eit, b, err, val);
+ if (!(err & ios_base::failbit))
+ v = reinterpret_cast<void *>(val);
+ return end;
+ }
+
+private:
+ template <typename ValueType>
+ iter_type
+ do_get_integer(iter_type iit, iter_type eit, ios_base & b,
+ ios_base::iostate & err, ValueType & v) const
+ {
+ string s;
s.reserve(64);
for (; iit != eit && isNumpunct(*iit); ++iit)
s += static_cast<char>(*iit);
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 <typename ValueType>
+ 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);
+ 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<char>(*iit);
+ ++iit;
+ }
+ for (; iit != eit && isDigitOrSep(*iit, sep); ++iit)
+ s += static_cast<char>(*iit);
+ if (iit != eit && *iit == dot) {
+ s += dot;
+ ++iit;
+ for (; iit != eit && isDigitOrSep(*iit, 0); ++iit)
+ s += static_cast<char>(*iit);
+ if (iit != eit && (*iit == 'e' || *iit == 'E')) {
+ s += static_cast<char>(*iit);
+ ++iit;
+ for (; iit != eit && isDigitOrSep(*iit, 0); ++iit)
+ s += static_cast<char>(*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);
+ }
};
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);
}
};
/// make sure that our facets get used
static locale_initializer initializer;
-}
-}
+} // namespace
+} // namespace lyx
#endif