MacOSX compile fix.

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

diff --git a/src/support/unicode.C b/src/support/unicode.C
index 5c09a0d73b4b50b898889b66e78716108458d28d..1545e2ddc01b19e0bf9609ec751c9d208e8b6b8c 100644 (file)
--- a/src/support/unicode.C
+++ b/src/support/unicode.C
@@ -23,8 +23,6 @@
 
 using std::endl;
 
-namespace {
-
 #ifdef WORDS_BIGENDIAN
        char const * ucs4_codeset = "UCS-4BE";
        char const * ucs2_codeset = "UCS-2BE";
@@ -33,6 +31,8 @@ namespace {
        char const * ucs2_codeset = "UCS-2LE";
 #endif
 
+namespace {
+
 template<typename RetType, typename InType>
 std::vector<RetType>
 iconv_convert(iconv_t * cd,
@@ -64,9 +64,10 @@ iconv_convert(iconv_t * cd,
 
        char ICONV_CONST * inbuf = const_cast<char ICONV_CONST *>(reinterpret_cast<char const *>(buf));
        size_t inbytesleft = buflen * sizeof(InType);
-       static char out[1000];
+       size_t const outsize = 1000;
+       static char out[outsize];
        char * outbuf = out;
-       size_t outbytesleft = 1000;
+       size_t outbytesleft = outsize;
 
        size_t res = iconv(*cd, &inbuf, &inbytesleft, &outbuf, &outbytesleft);
 
@@ -83,8 +84,8 @@ iconv_convert(iconv_t * cd,
                               << " to " << tocode << ".\n";
                        lyxerr << "Input: " << std::hex;
                        for (size_t i = 0; i < buflen; ++i) {
-                               unsigned char const b = buf[i];
-                               lyxerr << "0x" << int(b) << " ";
+                               boost::uint32_t const b = buf[i];
+                               lyxerr << "0x" << b << " ";
                        }
                        lyxerr << endl;
                        break;
@@ -95,8 +96,8 @@ iconv_convert(iconv_t * cd,
                               << " to " << tocode << ".\n";
                        lyxerr << "Input: " << std::hex;
                        for (size_t i = 0; i < buflen; ++i) {
-                               unsigned char const b = buf[i];
-                               lyxerr << "0x" << int(b) << " ";
+                               boost::uint32_t const b = buf[i];
+                               lyxerr << "0x" << b << " ";
                        }
                        lyxerr << endl;
                        break;
@@ -115,7 +116,7 @@ iconv_convert(iconv_t * cd,
        //lyxerr << std::dec;
        //lyxerr << "Inbytesleft: " << inbytesleft << endl;
        //lyxerr << "Outbytesleft: " << outbytesleft << endl;
-       int bytes = 1000 - outbytesleft;
+       int bytes = outsize - outbytesleft;
 
        RetType const * tmp = reinterpret_cast<RetType const *>(out);
        return std::vector<RetType>(tmp, tmp + bytes / sizeof(RetType));
@@ -124,32 +125,60 @@ iconv_convert(iconv_t * cd,
 } // anon namespace
 
 
-std::vector<boost::uint32_t> utf8_to_ucs4(std::vector<char> const & utf8str)
+std::vector<lyx::char_type> utf8_to_ucs4(std::vector<char> const & utf8str)
+{
+       return utf8_to_ucs4(&utf8str[0], utf8str.size());
+}
+
+
+std::vector<lyx::char_type>
+utf8_to_ucs4(char const * utf8str, size_t ls)
 {
        static iconv_t cd = (iconv_t)(-1);
-       return iconv_convert<boost::uint32_t>(&cd, ucs4_codeset, "UTF-8",
-                                             &utf8str[0], utf8str.size());
+       return iconv_convert<lyx::char_type>(&cd, ucs4_codeset, "UTF-8",
+                                             utf8str, ls);
 }
 
 
-std::vector<boost::uint32_t>
+lyx::char_type
+ucs2_to_ucs4(unsigned short c)
+{
+       return ucs2_to_ucs4(&c, 1)[0];
+}
+
+
+std::vector<lyx::char_type>
 ucs2_to_ucs4(std::vector<unsigned short> const & ucs2str)
+{
+       return ucs2_to_ucs4(&ucs2str[0], ucs2str.size());
+}
+
+
+std::vector<lyx::char_type>
+ucs2_to_ucs4(unsigned short const * ucs2str, size_t ls)
 {
        static iconv_t cd = (iconv_t)(-1);
-       return iconv_convert<boost::uint32_t>(&cd, ucs4_codeset, ucs2_codeset,
-                                             &ucs2str[0], ucs2str.size());
+       return iconv_convert<lyx::char_type>(&cd, ucs4_codeset, ucs2_codeset,
+                                             ucs2str, ls);
+}
+
+
+unsigned short
+ucs4_to_ucs2(lyx::char_type c)
+{
+       return ucs4_to_ucs2(&c, 1)[0];
 }
 
 
 std::vector<unsigned short>
-ucs4_to_ucs2(std::vector<boost::uint32_t> const & ucs4str)
+ucs4_to_ucs2(std::vector<lyx::char_type> const & ucs4str)
 {
        return ucs4_to_ucs2(&ucs4str[0], ucs4str.size());
 }
 
 
 std::vector<unsigned short>
-ucs4_to_ucs2(boost::uint32_t const * s, size_t ls)
+ucs4_to_ucs2(lyx::char_type const * s, size_t ls)
 {
        static iconv_t cd = (iconv_t)(-1);
        return iconv_convert<unsigned short>(&cd, ucs2_codeset, ucs4_codeset,
@@ -157,24 +186,25 @@ ucs4_to_ucs2(boost::uint32_t const * s, size_t ls)
 }
 
 
-unsigned short
-ucs4_to_ucs2(boost::uint32_t c)
+std::vector<char>
+ucs4_to_utf8(lyx::char_type c)
 {
-       boost::uint32_t tmp[] = { c, 0 };
-       return ucs4_to_ucs2(tmp, 1)[0];
+       static iconv_t cd = (iconv_t)(-1);
+       return iconv_convert<char>(&cd, "UTF-8", ucs4_codeset, &c, 1);
 }
 
 
-std::vector<char> ucs4_to_utf8(std::vector<boost::uint32_t> const & ucs4str)
+std::vector<char>
+ucs4_to_utf8(std::vector<lyx::char_type> const & ucs4str)
 {
-       static iconv_t cd = (iconv_t)(-1);
-       return iconv_convert<char>(&cd, "UTF-8", ucs4_codeset,
-                                  &ucs4str[0], ucs4str.size());
+       return ucs4_to_utf8(&ucs4str[0], ucs4str.size());
 }
 
 
-std::vector<char> ucs4_to_utf8(boost::uint32_t c)
+std::vector<char>
+ucs4_to_utf8(lyx::char_type const * ucs4str, size_t ls)
 {
        static iconv_t cd = (iconv_t)(-1);
-       return iconv_convert<char>(&cd, "UTF-8", ucs4_codeset, &c, 1);
+       return iconv_convert<char>(&cd, "UTF-8", ucs4_codeset,
+                                  ucs4str, ls);
 }