* support/qstring_helpers.h: erase ucs4_to_qstring() method.

[lyx.git] / src / support / docstring.C

diff --git a/src/support/docstring.C b/src/support/docstring.C
index 7ee1923df9909c87f31ca9e8caf36e2895f63462..89abf212991ebf5fec66865e629fb5b95f05f688 100644 (file)
--- a/src/support/docstring.C
+++ b/src/support/docstring.C
@@ -11,11 +11,14 @@
 #include <config.h>
 
 #include "docstring.h"
+#include "qstring_helpers.h"
 #include "unicode.h"
 
 #include <locale>
 #include <iostream>
 
+#include <QFile>
+
 #include <boost/assert.hpp>
 
 
@@ -55,6 +58,14 @@ std::string const to_ascii(docstring const & ucs4)
 }
 
 
+IconvProcessor & utf8ToUcs4()
+{
+       static IconvProcessor iconv(ucs4_codeset, "UTF-8");
+       return iconv;
+}
+
+
+
 void utf8_to_ucs4(std::string const & utf8, docstring & ucs4)
 {
        size_t n = utf8.size();
@@ -91,6 +102,44 @@ std::string const to_utf8(docstring const & ucs4)
 }
 
 
+docstring const from_local8bit(std::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.";
+}
+
+
+std::string const to_local8bit(docstring const & s)
+{
+       // This conversion can fail, depending on input.
+       if (s.empty())
+               return std::string();
+       QByteArray const local = toqstr(s).toLocal8Bit();
+       if (local.size() == 0)
+               throw to_local8bit_failure();
+       return std::string(local.begin(), local.end());
+}
+
+
+docstring const from_filesystem8bit(std::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)
+{
+       QByteArray const encoded = QFile::encodeName(toqstr(s));
+       return std::string(encoded.begin(), encoded.end());
+}
+
+
 bool operator==(lyx::docstring const & l, char const * r)
 {
        int const len = l.length();
@@ -414,15 +463,69 @@ public:
        };
 
 protected:
+       iter_type
+       do_put(iter_type oit, std::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
+       {
+               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
+       {
+               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
+       {
+               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
+       {
+               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
+       {
+               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
+       {
+               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
+       {
+               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
        {
                if (fill >= 0x80)
                        throw num_put_failure();
 
-               std::string s;
-               // 64 is large enough
-               s.resize(64);
+               std::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');
                string_num_put_facet f;
                std::string::const_iterator cit = s.begin();
                std::string::const_iterator end =
@@ -465,9 +568,14 @@ protected:
                std::ios_base::iostate & err, long & v) const
        {
                std::string s;
-               s.resize(64);
-               for (int i = 0; iit != eit && isNumpunct(*iit); ++i, ++iit)
-                       s[i] = static_cast<char>(*iit);
+               s.reserve(64);
+               for (; iit != eit && isNumpunct(*iit); ++iit)
+                       s += static_cast<char>(*iit);
+               // We add another character, not part of the numpunct facet,
+               // in order to avoid setting the eofbit in the stream state,
+               // which would prevent any further read. The space seems a
+               // good choice here.
+               s += ' ';
                string_num_get_facet f;
                f.get(s.begin(), s.end(), b, err, v);