[ 1509599 ] 'Split pickers page in widgets sample' with more icons and rebaking.

[wxWidgets.git] / src / common / strconv.cpp

diff --git a/src/common/strconv.cpp b/src/common/strconv.cpp
index 7b28a13b10c3a0ae1373ce85e56461d82dcd7f4b..ef07724797c5f67061dda645ca8d04462751e120 100644 (file)
--- a/src/common/strconv.cpp
+++ b/src/common/strconv.cpp
@@ -12,25 +12,15 @@
 // Licence:     wxWindows licence
 /////////////////////////////////////////////////////////////////////////////
 
 // Licence:     wxWindows licence
 /////////////////////////////////////////////////////////////////////////////
 

-// ============================================================================
-// declarations
-// ============================================================================
-
-// ----------------------------------------------------------------------------
-// headers
-// ----------------------------------------------------------------------------
-

 // For compilers that support precompilation, includes "wx.h".
 #include "wx/wxprec.h"
 
 // For compilers that support precompilation, includes "wx.h".
 #include "wx/wxprec.h"
 

-#ifdef __BORLANDC__
-  #pragma hdrstop
-#endif
-

 #ifndef WX_PRECOMP
     #include "wx/intl.h"
     #include "wx/log.h"
 #ifndef WX_PRECOMP
     #include "wx/intl.h"
     #include "wx/log.h"

-#endif // WX_PRECOMP
+    #include "wx/utils.h"
+    #include "wx/hashmap.h"
+#endif

 
 #include "wx/strconv.h"
 
 
 #include "wx/strconv.h"
 


@@ -51,7 +41,7 @@
 
 #if defined(__WIN32__) && !defined(__WXMICROWIN__)
     #define wxHAVE_WIN32_MB2WC
 
 #if defined(__WIN32__) && !defined(__WXMICROWIN__)
     #define wxHAVE_WIN32_MB2WC

-#endif // __WIN32__ but !__WXMICROWIN__
+#endif

 
 #ifdef __SALFORDC__
     #include <clib.h>
 
 #ifdef __SALFORDC__
     #include <clib.h>


@@ -64,7 +54,6 @@
 
 #include "wx/encconv.h"
 #include "wx/fontmap.h"
 
 #include "wx/encconv.h"
 #include "wx/fontmap.h"

-#include "wx/utils.h"

 
 #ifdef __WXMAC__
 #ifndef __DARWIN__
 
 #ifdef __WXMAC__
 #ifndef __DARWIN__


@@ -73,9 +62,11 @@
 #include <TextEncodingConverter.h>
 #endif
 
 #include <TextEncodingConverter.h>
 #endif
 

-#include  "wx/mac/private.h"  // includes mac headers
+// includes Mac headers
+#include "wx/mac/private.h"

 #endif
 
 #endif
 

+

 #define TRACE_STRCONV _T("strconv")
 
 // WC_UTF16 is defined only if sizeof(wchar_t) == 2, otherwise it's supposed to
 #define TRACE_STRCONV _T("strconv")
 
 // WC_UTF16 is defined only if sizeof(wchar_t) == 2, otherwise it's supposed to


@@ -84,6 +75,7 @@
     #define WC_UTF16
 #endif
 
     #define WC_UTF16
 #endif
 

+

 // ============================================================================
 // implementation
 // ============================================================================
 // ============================================================================
 // implementation
 // ============================================================================


@@ -103,13 +95,14 @@ static bool NotAllNULs(const char *p, size_t n)
 
 static size_t encode_utf16(wxUint32 input, wxUint16 *output)
 {
 
 static size_t encode_utf16(wxUint32 input, wxUint16 *output)
 {

-    if (input<=0xffff)
+    if (input <= 0xffff)

     {
         if (output)
             *output = (wxUint16) input;
     {
         if (output)
             *output = (wxUint16) input;

+

         return 1;
     }
         return 1;
     }

-    else if (input>=0x110000)
+    else if (input >= 0x110000)

     {
         return wxCONV_FAILED;
     }
     {
         return wxCONV_FAILED;
     }


@@ -117,21 +110,22 @@ static size_t encode_utf16(wxUint32 input, wxUint16 *output)
     {
         if (output)
         {
     {
         if (output)
         {

-            *output++ = (wxUint16) ((input >> 10)+0xd7c0);
-            *output = (wxUint16) ((input&0x3ff)+0xdc00);
+            *output++ = (wxUint16) ((input >> 10) + 0xd7c0);
+            *output = (wxUint16) ((input & 0x3ff) + 0xdc00);

         }
         }

+

         return 2;
     }
 }
 
 static size_t decode_utf16(const wxUint16* input, wxUint32& output)
 {
         return 2;
     }
 }
 
 static size_t decode_utf16(const wxUint16* input, wxUint32& output)
 {

-    if ((*input<0xd800) || (*input>0xdfff))
+    if ((*input < 0xd800) || (*input > 0xdfff))

     {
         output = *input;
         return 1;
     }
     {
         output = *input;
         return 1;
     }

-    else if ((input[1]<0xdc00) || (input[1]>0xdfff))
+    else if ((input[1] < 0xdc00) || (input[1] > 0xdfff))

     {
         output = *input;
         return wxCONV_FAILED;
     {
         output = *input;
         return wxCONV_FAILED;


@@ -144,16 +138,21 @@ static size_t decode_utf16(const wxUint16* input, wxUint32& output)
 }
 
 #ifdef WC_UTF16
 }
 
 #ifdef WC_UTF16

+    typedef wchar_t wxDecodeSurrogate_t;
+#else // !WC_UTF16
+    typedef wxUint16 wxDecodeSurrogate_t;
+#endif // WC_UTF16/!WC_UTF16

 
 // returns the next UTF-32 character from the wchar_t buffer and advances the
 // pointer to the character after this one
 //
 // if an invalid character is found, *pSrc is set to NULL, the caller must
 // check for this
 
 // returns the next UTF-32 character from the wchar_t buffer and advances the
 // pointer to the character after this one
 //
 // if an invalid character is found, *pSrc is set to NULL, the caller must
 // check for this

-static wxUint32 wxDecodeSurrogate(const wchar_t **pSrc)
+static wxUint32 wxDecodeSurrogate(const wxDecodeSurrogate_t **pSrc)

 {
     wxUint32 out;
 {
     wxUint32 out;

-    const size_t n = decode_utf16(*pSrc, out);
+    const size_t
+        n = decode_utf16(wx_reinterpret_cast(const wxUint16 *, *pSrc), out);

     if ( n == wxCONV_FAILED )
         *pSrc = NULL;
     else
     if ( n == wxCONV_FAILED )
         *pSrc = NULL;
     else


@@ -162,8 +161,6 @@ static wxUint32 wxDecodeSurrogate(const wchar_t **pSrc)
     return out;
 }
 
     return out;
 }
 

-#endif // WC_UTF16
-

 // ----------------------------------------------------------------------------
 // wxMBConv
 // ----------------------------------------------------------------------------
 // ----------------------------------------------------------------------------
 // wxMBConv
 // ----------------------------------------------------------------------------


@@ -183,7 +180,7 @@ wxMBConv::ToWChar(wchar_t *dst, size_t dstLen,
     size_t dstWritten = 0;
 
     // the number of NULs terminating this string
     size_t dstWritten = 0;
 
     // the number of NULs terminating this string

-    size_t nulLen wxDUMMY_INITIALIZE(0);
+    size_t nulLen = 0;  // not really needed, but just to avoid warnings

 
     // if we were not given the input size we just have to assume that the
     // string is properly terminated as we have no way of knowing how long it
 
     // if we were not given the input size we just have to assume that the
     // string is properly terminated as we have no way of knowing how long it


@@ -296,7 +293,7 @@ wxMBConv::FromWChar(char *dst, size_t dstLen,
     {
         // make a copy in order to properly NUL-terminate the string
         bufTmp = wxWCharBuffer(srcLen);
     {
         // make a copy in order to properly NUL-terminate the string
         bufTmp = wxWCharBuffer(srcLen);

-        memcpy(bufTmp.data(), src, srcLen*sizeof(wchar_t));
+        memcpy(bufTmp.data(), src, srcLen * sizeof(wchar_t));

         src = bufTmp;
     }
 
         src = bufTmp;
     }
 


@@ -329,9 +326,9 @@ wxMBConv::FromWChar(char *dst, size_t dstLen,
     return dstWritten;
 }
 
     return dstWritten;
 }
 

-size_t wxMBConv::MB2WC(wchar_t *out, const char *in, size_t outLen) const
+size_t wxMBConv::MB2WC(wchar_t *outBuff, const char *inBuff, size_t outLen) const

 {
 {

-    size_t rc = ToWChar(out, outLen, in);
+    size_t rc = ToWChar(outBuff, outLen, inBuff);

     if ( rc != wxCONV_FAILED )
     {
         // ToWChar() returns the buffer length, i.e. including the trailing
     if ( rc != wxCONV_FAILED )
     {
         // ToWChar() returns the buffer length, i.e. including the trailing


@@ -342,9 +339,9 @@ size_t wxMBConv::MB2WC(wchar_t *out, const char *in, size_t outLen) const
     return rc;
 }
 
     return rc;
 }
 

-size_t wxMBConv::WC2MB(char *out, const wchar_t *in, size_t outLen) const
+size_t wxMBConv::WC2MB(char *outBuff, const wchar_t *inBuff, size_t outLen) const

 {
 {

-    size_t rc = FromWChar(out, outLen, in);
+    size_t rc = FromWChar(outBuff, outLen, inBuff);

     if ( rc != wxCONV_FAILED )
     {
         rc -= GetMBNulLen();
     if ( rc != wxCONV_FAILED )
     {
         rc -= GetMBNulLen();


@@ -398,13 +395,13 @@ const wxCharBuffer wxMBConv::cWC2MB(const wchar_t *pwz) const
 }
 
 const wxWCharBuffer
 }
 
 const wxWCharBuffer

-wxMBConv::cMB2WC(const char *in, size_t inLen, size_t *outLen) const
+wxMBConv::cMB2WC(const char *inBuff, size_t inLen, size_t *outLen) const

 {
 {

-    const size_t dstLen = ToWChar(NULL, 0, in, inLen);
+    const size_t dstLen = ToWChar(NULL, 0, inBuff, inLen);

     if ( dstLen != wxCONV_FAILED )
     {
         wxWCharBuffer wbuf(dstLen - 1);
     if ( dstLen != wxCONV_FAILED )
     {
         wxWCharBuffer wbuf(dstLen - 1);

-        if ( ToWChar(wbuf.data(), dstLen, in, inLen) != wxCONV_FAILED )
+        if ( ToWChar(wbuf.data(), dstLen, inBuff, inLen) != wxCONV_FAILED )

         {
             if ( outLen )
             {
         {
             if ( outLen )
             {


@@ -424,24 +421,27 @@ wxMBConv::cMB2WC(const char *in, size_t inLen, size_t *outLen) const
 }
 
 const wxCharBuffer
 }
 
 const wxCharBuffer

-wxMBConv::cWC2MB(const wchar_t *in, size_t inLen, size_t *outLen) const
+wxMBConv::cWC2MB(const wchar_t *inBuff, size_t inLen, size_t *outLen) const

 {
 {

-    const size_t dstLen = FromWChar(NULL, 0, in, inLen);
+    size_t dstLen = FromWChar(NULL, 0, inBuff, inLen);

     if ( dstLen != wxCONV_FAILED )
     {
     if ( dstLen != wxCONV_FAILED )
     {

-        wxCharBuffer buf(dstLen - 1);
-        if ( FromWChar(buf.data(), dstLen, in, inLen) != wxCONV_FAILED )
+        // special case of empty input: can't allocate 0 size buffer below as
+        // wxCharBuffer insists on NUL-terminating it
+        wxCharBuffer buf(dstLen ? dstLen - 1 : 1);
+        if ( FromWChar(buf.data(), dstLen, inBuff, inLen) != wxCONV_FAILED )

         {
             if ( outLen )
             {
                 *outLen = dstLen;
 
                 const size_t nulLen = GetMBNulLen();
         {
             if ( outLen )
             {
                 *outLen = dstLen;
 
                 const size_t nulLen = GetMBNulLen();

-                if ( !NotAllNULs(buf.data() + dstLen - nulLen, nulLen) )
+                if ( dstLen >= nulLen &&
+                        !NotAllNULs(buf.data() + dstLen - nulLen, nulLen) )

                 {
                     // in this case the output is NUL-terminated and we're not
                     // supposed to count NUL
                 {
                     // in this case the output is NUL-terminated and we're not
                     // supposed to count NUL

-                    (*outLen) -= nulLen;
+                    *outLen -= nulLen;

                 }
             }
 
                 }
             }
 


@@ -646,6 +646,7 @@ size_t wxMBConvUTF7::WC2MB(char *buf, const wchar_t *psz, size_t n) const
             // plain ASCII char
             if (buf)
                 *buf++ = (char)cc;
             // plain ASCII char
             if (buf)
                 *buf++ = (char)cc;

+

             len++;
         }
 #ifndef WC_UTF16
             len++;
         }
 #ifndef WC_UTF16


@@ -659,6 +660,7 @@ size_t wxMBConvUTF7::WC2MB(char *buf, const wchar_t *psz, size_t n) const
         {
             if (buf)
                 *buf++ = '+';
         {
             if (buf)
                 *buf++ = '+';

+

             len++;
             if (cc != '+')
             {
             len++;
             if (cc != '+')
             {


@@ -679,24 +681,30 @@ size_t wxMBConvUTF7::WC2MB(char *buf, const wchar_t *psz, size_t n) const
                             len++;
                         }
                     }
                             len++;
                         }
                     }

+

                     cc = *psz;
                     if (!(cc) || (cc < 0x80 && utf7encode[cc] < 1))
                         break;
                 }
                     cc = *psz;
                     if (!(cc) || (cc < 0x80 && utf7encode[cc] < 1))
                         break;
                 }

+

                 if (l != 0)
                 {
                     if (buf)
                         *buf++ = utf7enb64[((d % 16) << (6 - l)) % 64];
                 if (l != 0)
                 {
                     if (buf)
                         *buf++ = utf7enb64[((d % 16) << (6 - l)) % 64];

+

                     len++;
                 }
             }
                     len++;
                 }
             }

+

             if (buf)
                 *buf++ = '-';
             len++;
         }
     }
             if (buf)
                 *buf++ = '-';
             len++;
         }
     }

+

     if (buf && (len < n))
         *buf = 0;
     if (buf && (len < n))
         *buf = 0;

+

     return len;
 }
 
     return len;
 }
 


@@ -724,6 +732,7 @@ size_t wxMBConvUTF8::MB2WC(wchar_t *buf, const char *psz, size_t n) const
         unsigned cnt;
         for (cnt = 0; fc & 0x80; cnt++)
             fc <<= 1;
         unsigned cnt;
         for (cnt = 0; fc & 0x80; cnt++)
             fc <<= 1;

+

         if (!cnt)
         {
             // plain ASCII char
         if (!cnt)
         {
             // plain ASCII char


@@ -761,9 +770,11 @@ size_t wxMBConvUTF8::MB2WC(wchar_t *buf, const char *psz, size_t n) const
                         invalid = true;
                         break;
                     }
                         invalid = true;
                         break;
                     }

+

                     psz++;
                     res = (res << 6) | (cc & 0x3f);
                 }
                     psz++;
                     res = (res << 6) | (cc & 0x3f);
                 }

+

                 if (invalid || res <= utf8_max[ocnt])
                 {
                     // illegal UTF-8 encoding
                 if (invalid || res <= utf8_max[ocnt])
                 {
                     // illegal UTF-8 encoding


@@ -799,6 +810,7 @@ size_t wxMBConvUTF8::MB2WC(wchar_t *buf, const char *psz, size_t n) const
 #endif // WC_UTF16/!WC_UTF16
                 }
             }
 #endif // WC_UTF16/!WC_UTF16
                 }
             }

+

             if (invalid)
             {
                 if (m_options & MAP_INVALID_UTF8_TO_PUA)
             if (invalid)
             {
                 if (m_options & MAP_INVALID_UTF8_TO_PUA)


@@ -833,6 +845,7 @@ size_t wxMBConvUTF8::MB2WC(wchar_t *buf, const char *psz, size_t n) const
                             *buf++ = (wchar_t)( L'0' + (on % 0100) / 010 );
                             *buf++ = (wchar_t)( L'0' + on % 010 );
                         }
                             *buf++ = (wchar_t)( L'0' + (on % 0100) / 010 );
                             *buf++ = (wchar_t)( L'0' + on % 010 );
                         }

+

                         opsz++;
                         len += 4;
                     }
                         opsz++;
                         len += 4;
                     }


@@ -844,8 +857,10 @@ size_t wxMBConvUTF8::MB2WC(wchar_t *buf, const char *psz, size_t n) const
             }
         }
     }
             }
         }
     }

+

     if (buf && (len < n))
         *buf = 0;
     if (buf && (len < n))
         *buf = 0;

+

     return len;
 }
 
     return len;
 }
 


@@ -861,12 +876,13 @@ size_t wxMBConvUTF8::WC2MB(char *buf, const wchar_t *psz, size_t n) const
     while (*psz && ((!buf) || (len < n)))
     {
         wxUint32 cc;
     while (*psz && ((!buf) || (len < n)))
     {
         wxUint32 cc;

+

 #ifdef WC_UTF16
         // cast is ok for WC_UTF16
         size_t pa = decode_utf16((const wxUint16 *)psz, cc);
         psz += (pa == wxCONV_FAILED) ? 1 : pa;
 #else
 #ifdef WC_UTF16
         // cast is ok for WC_UTF16
         size_t pa = decode_utf16((const wxUint16 *)psz, cc);
         psz += (pa == wxCONV_FAILED) ? 1 : pa;
 #else

-        cc=(*psz++) & 0x7fffffff;
+        cc = (*psz++) & 0x7fffffff;

 #endif
 
         if ( (m_options & MAP_INVALID_UTF8_TO_PUA)
 #endif
 
         if ( (m_options & MAP_INVALID_UTF8_TO_PUA)


@@ -890,8 +906,8 @@ size_t wxMBConvUTF8::WC2MB(char *buf, const wchar_t *psz, size_t n) const
         {
             if (buf)
             {
         {
             if (buf)
             {

-                *buf++ = (char) ((psz[0] - L'0')*0100 +
-                                 (psz[1] - L'0')*010 +
+                *buf++ = (char) ((psz[0] - L'0') * 0100 +
+                                 (psz[1] - L'0') * 010 +

                                  (psz[2] - L'0'));
             }
 
                                  (psz[2] - L'0'));
             }
 


@@ -901,7 +917,10 @@ size_t wxMBConvUTF8::WC2MB(char *buf, const wchar_t *psz, size_t n) const
         else
         {
             unsigned cnt;
         else
         {
             unsigned cnt;

-            for (cnt = 0; cc > utf8_max[cnt]; cnt++) {}
+            for (cnt = 0; cc > utf8_max[cnt]; cnt++)
+            {
+            }
+

             if (!cnt)
             {
                 // plain ASCII char
             if (!cnt)
             {
                 // plain ASCII char


@@ -909,7 +928,6 @@ size_t wxMBConvUTF8::WC2MB(char *buf, const wchar_t *psz, size_t n) const
                     *buf++ = (char) cc;
                 len++;
             }
                     *buf++ = (char) cc;
                 len++;
             }

-

             else
             {
                 len += cnt + 1;
             else
             {
                 len += cnt + 1;


@@ -923,7 +941,7 @@ size_t wxMBConvUTF8::WC2MB(char *buf, const wchar_t *psz, size_t n) const
         }
     }
 
         }
     }
 

-    if (buf && (len<n))
+    if (buf && (len < n))

         *buf = 0;
 
     return len;
         *buf = 0;
 
     return len;


@@ -947,8 +965,8 @@ size_t wxMBConvUTF16Base::GetLength(const char *src, size_t srcLen)
     if ( srcLen == wxNO_LEN )
     {
         // count the number of bytes in input, including the trailing NULs
     if ( srcLen == wxNO_LEN )
     {
         // count the number of bytes in input, including the trailing NULs

-        const wxUint16 *in = wx_reinterpret_cast(const wxUint16 *, src);
-        for ( srcLen = 1; *in++; srcLen++ )
+        const wxUint16 *inBuff = wx_reinterpret_cast(const wxUint16 *, src);
+        for ( srcLen = 1; *inBuff++; srcLen++ )

             ;
 
         srcLen *= BYTES_PER_CHAR;
             ;
 
         srcLen *= BYTES_PER_CHAR;


@@ -980,7 +998,7 @@ wxMBConvUTF16straight::ToWChar(wchar_t *dst, size_t dstLen,
     if ( srcLen == wxNO_LEN )
         return wxCONV_FAILED;
 
     if ( srcLen == wxNO_LEN )
         return wxCONV_FAILED;
 

-    const size_t inLen = srcLen/BYTES_PER_CHAR;
+    const size_t inLen = srcLen / BYTES_PER_CHAR;

     if ( dst )
     {
         if ( dstLen < inLen )
     if ( dst )
     {
         if ( dstLen < inLen )


@@ -1031,10 +1049,10 @@ wxMBConvUTF16swap::ToWChar(wchar_t *dst, size_t dstLen,
         if ( dstLen < srcLen )
             return wxCONV_FAILED;
 
         if ( dstLen < srcLen )
             return wxCONV_FAILED;
 

-        const wxUint16 *in = wx_reinterpret_cast(const wxUint16 *, src);
-        for ( size_t n = 0; n < srcLen; n++, in++ )
+        const wxUint16 *inBuff = wx_reinterpret_cast(const wxUint16 *, src);
+        for ( size_t n = 0; n < srcLen; n++, inBuff++ )

         {
         {

-            *dst++ = wxUINT16_SWAP_ALWAYS(*in);
+            *dst++ = wxUINT16_SWAP_ALWAYS(*inBuff);

         }
     }
 
         }
     }
 


@@ -1055,10 +1073,10 @@ wxMBConvUTF16swap::FromWChar(char *dst, size_t dstLen,
         if ( dstLen < srcLen )
             return wxCONV_FAILED;
 
         if ( dstLen < srcLen )
             return wxCONV_FAILED;
 

-        wxUint16 *out = wx_reinterpret_cast(wxUint16 *, dst);
+        wxUint16 *outBuff = wx_reinterpret_cast(wxUint16 *, dst);

         for ( size_t n = 0; n < srcLen; n += BYTES_PER_CHAR, src++ )
         {
         for ( size_t n = 0; n < srcLen; n += BYTES_PER_CHAR, src++ )
         {

-            *out++ = wxUINT16_SWAP_ALWAYS(*src);
+            *outBuff++ = wxUINT16_SWAP_ALWAYS(*src);

         }
     }
 
         }
     }
 


@@ -1071,130 +1089,164 @@ wxMBConvUTF16swap::FromWChar(char *dst, size_t dstLen,
 // conversions without endianness change
 // ----------------------------------------------------------------------------
 
 // conversions without endianness change
 // ----------------------------------------------------------------------------
 

-size_t wxMBConvUTF16straight::MB2WC(wchar_t *buf, const char *psz, size_t n) const
+size_t
+wxMBConvUTF16straight::ToWChar(wchar_t *dst, size_t dstLen,
+                               const char *src, size_t srcLen) const

 {
 {

-    size_t len=0;
+    srcLen = GetLength(src, srcLen);
+    if ( srcLen == wxNO_LEN )
+        return wxCONV_FAILED;

 
 

-    while (*(wxUint16*)psz && (!buf || len < n))
+    const size_t inLen = srcLen / BYTES_PER_CHAR;
+    if ( !dst )

     {
     {

-        wxUint32 cc;
-        size_t pa=decode_utf16((wxUint16*)psz, cc);
-        if (pa == wxCONV_FAILED)
-            return pa;
+        // optimization: return maximal space which could be needed for this
+        // string even if the real size could be smaller if the buffer contains
+        // any surrogates
+        return inLen;
+    }

 
 

-        if (buf)
-            *buf++ = (wchar_t)cc;
-        len++;
-        psz += pa * sizeof(wxUint16);
+    size_t outLen = 0;
+    const wxUint16 *inBuff = wx_reinterpret_cast(const wxUint16 *, src);
+    for ( const wxUint16 * const inEnd = inBuff + inLen; inBuff < inEnd; )
+    {
+        const wxUint32 ch = wxDecodeSurrogate(&inBuff);
+        if ( !inBuff )
+            return wxCONV_FAILED;
+
+        if ( ++outLen > dstLen )
+            return wxCONV_FAILED;
+
+        *dst++ = ch;

     }
     }

-    if (buf && len<n)   *buf=0;

 
 

-    return len;
-}

 
 

+    return outLen;
+}

 
 

-// copy 32bit String to 16bit MB
-size_t wxMBConvUTF16straight::WC2MB(char *buf, const wchar_t *psz, size_t n) const
+size_t
+wxMBConvUTF16straight::FromWChar(char *dst, size_t dstLen,
+                                 const wchar_t *src, size_t srcLen) const

 {
 {

-    size_t len=0;
+    if ( srcLen == wxNO_LEN )
+        srcLen = wxWcslen(src) + 1;

 
 

-    while (*psz && (!buf || len < n))
+    size_t outLen = 0;
+    wxUint16 *outBuff = wx_reinterpret_cast(wxUint16 *, dst);
+    for ( size_t n = 0; n < srcLen; n++ )

     {
         wxUint16 cc[2];
     {
         wxUint16 cc[2];

-        size_t pa=encode_utf16(*psz, cc);
-
-        if (pa == wxCONV_FAILED)
-            return pa;
+        const size_t numChars = encode_utf16(*src++, cc);
+        if ( numChars == wxCONV_FAILED )
+            return wxCONV_FAILED;

 
 

-        if (buf)
+        outLen += numChars * BYTES_PER_CHAR;
+        if ( outBuff )

         {
         {

-            *(wxUint16*)buf = cc[0];
-            buf += sizeof(wxUint16);
-            if (pa > 1)
+            if ( outLen > dstLen )
+                return wxCONV_FAILED;
+
+            *outBuff++ = cc[0];
+            if ( numChars == 2 )

             {
             {

-                *(wxUint16*)buf = cc[1];
-                buf += sizeof(wxUint16);
+                // second character of a surrogate
+                *outBuff++ = cc[1];

             }
         }
             }
         }

-
-        len += pa*sizeof(wxUint16);
-        psz++;

     }
     }

-    if (buf && len<=n-sizeof(wxUint16))   *(wxUint16*)buf=0;

 
 

-    return len;
+    return outLen;

 }
 
 // ----------------------------------------------------------------------------
 // endian-reversing conversions
 // ----------------------------------------------------------------------------
 
 }
 
 // ----------------------------------------------------------------------------
 // endian-reversing conversions
 // ----------------------------------------------------------------------------
 

-// swap 16bit MB to 32bit String
-size_t wxMBConvUTF16swap::MB2WC(wchar_t *buf, const char *psz, size_t n) const
+size_t
+wxMBConvUTF16swap::ToWChar(wchar_t *dst, size_t dstLen,
+                           const char *src, size_t srcLen) const

 {
 {

-    size_t len=0;
+    srcLen = GetLength(src, srcLen);
+    if ( srcLen == wxNO_LEN )
+        return wxCONV_FAILED;

 
 

-    while (*(wxUint16*)psz && (!buf || len < n))
+    const size_t inLen = srcLen / BYTES_PER_CHAR;
+    if ( !dst )

     {
     {

-        wxUint32 cc;
-        char tmp[4];
-        tmp[0]=psz[1];  tmp[1]=psz[0];
-        tmp[2]=psz[3];  tmp[3]=psz[2];
+        // optimization: return maximal space which could be needed for this
+        // string even if the real size could be smaller if the buffer contains
+        // any surrogates
+        return inLen;
+    }

 
 

-        size_t pa=decode_utf16((wxUint16*)tmp, cc);
-        if (pa == wxCONV_FAILED)
-            return pa;
+    size_t outLen = 0;
+    const wxUint16 *inBuff = wx_reinterpret_cast(const wxUint16 *, src);
+    for ( const wxUint16 * const inEnd = inBuff + inLen; inBuff < inEnd; )
+    {
+        wxUint32 ch;
+        wxUint16 tmp[2];

 
 

-        if (buf)
-            *buf++ = (wchar_t)cc;
+        tmp[0] = wxUINT16_SWAP_ALWAYS(*inBuff);
+        inBuff++;
+        tmp[1] = wxUINT16_SWAP_ALWAYS(*inBuff);

 
 

-        len++;
-        psz += pa * sizeof(wxUint16);
+        const size_t numChars = decode_utf16(tmp, ch);
+        if ( numChars == wxCONV_FAILED )
+            return wxCONV_FAILED;
+
+        if ( numChars == 2 )
+            inBuff++;
+
+        if ( ++outLen > dstLen )
+            return wxCONV_FAILED;
+
+        *dst++ = ch;

     }
     }

-    if (buf && len<n)   *buf=0;

 
 

-    return len;
-}

 
 

+    return outLen;
+}

 
 

-// swap 32bit String to 16bit MB
-size_t wxMBConvUTF16swap::WC2MB(char *buf, const wchar_t *psz, size_t n) const
+size_t
+wxMBConvUTF16swap::FromWChar(char *dst, size_t dstLen,
+                             const wchar_t *src, size_t srcLen) const

 {
 {

-    size_t len=0;
+    if ( srcLen == wxNO_LEN )
+        srcLen = wxWcslen(src) + 1;

 
 

-    while (*psz && (!buf || len < n))
+    size_t outLen = 0;
+    wxUint16 *outBuff = wx_reinterpret_cast(wxUint16 *, dst);
+    for ( const wchar_t *srcEnd = src + srcLen; src < srcEnd; src++ )

     {
         wxUint16 cc[2];
     {
         wxUint16 cc[2];

-        size_t pa=encode_utf16(*psz, cc);
-
-        if (pa == wxCONV_FAILED)
-            return pa;
+        const size_t numChars = encode_utf16(*src, cc);
+        if ( numChars == wxCONV_FAILED )
+            return wxCONV_FAILED;

 
 

-        if (buf)
+        outLen += numChars * BYTES_PER_CHAR;
+        if ( outBuff )

         {
         {

-            *buf++ = ((char*)cc)[1];
-            *buf++ = ((char*)cc)[0];
-            if (pa > 1)
+            if ( outLen > dstLen )
+                return wxCONV_FAILED;
+
+            *outBuff++ = wxUINT16_SWAP_ALWAYS(cc[0]);
+            if ( numChars == 2 )

             {
             {

-                *buf++ = ((char*)cc)[3];
-                *buf++ = ((char*)cc)[2];
+                // second character of a surrogate
+                *outBuff++ = wxUINT16_SWAP_ALWAYS(cc[1]);

             }
         }
             }
         }

-
-        len += pa*sizeof(wxUint16);
-        psz++;

     }
     }

-    if (buf && len<=n-sizeof(wxUint16))   *(wxUint16*)buf=0;

 
 

-    return len;
+    return outLen;

 }
 
 #endif // WC_UTF16/!WC_UTF16
 
 
 }
 
 #endif // WC_UTF16/!WC_UTF16
 
 

-// ----------------------------------------------------------------------------
+// ============================================================================

 // UTF-32
 // UTF-32

-// ----------------------------------------------------------------------------
+// ============================================================================

 
 #ifdef WORDS_BIGENDIAN
     #define wxMBConvUTF32straight  wxMBConvUTF32BE
 
 #ifdef WORDS_BIGENDIAN
     #define wxMBConvUTF32straight  wxMBConvUTF32BE


@@ -1214,8 +1266,8 @@ size_t wxMBConvUTF32Base::GetLength(const char *src, size_t srcLen)
     if ( srcLen == wxNO_LEN )
     {
         // count the number of bytes in input, including the trailing NULs
     if ( srcLen == wxNO_LEN )
     {
         // count the number of bytes in input, including the trailing NULs

-        const wxUint32 *in = wx_reinterpret_cast(const wxUint32 *, src);
-        for ( srcLen = 1; *in++; srcLen++ )
+        const wxUint32 *inBuff = wx_reinterpret_cast(const wxUint32 *, src);
+        for ( srcLen = 1; *inBuff++; srcLen++ )

             ;
 
         srcLen *= BYTES_PER_CHAR;
             ;
 
         srcLen *= BYTES_PER_CHAR;


@@ -1245,13 +1297,13 @@ wxMBConvUTF32straight::ToWChar(wchar_t *dst, size_t dstLen,
     if ( srcLen == wxNO_LEN )
         return wxCONV_FAILED;
 
     if ( srcLen == wxNO_LEN )
         return wxCONV_FAILED;
 

-    const wxUint32 *in = wx_reinterpret_cast(const wxUint32 *, src);
-    const size_t inLen = srcLen/BYTES_PER_CHAR;
+    const wxUint32 *inBuff = wx_reinterpret_cast(const wxUint32 *, src);
+    const size_t inLen = srcLen / BYTES_PER_CHAR;

     size_t outLen = 0;
     for ( size_t n = 0; n < inLen; n++ )
     {
         wxUint16 cc[2];
     size_t outLen = 0;
     for ( size_t n = 0; n < inLen; n++ )
     {
         wxUint16 cc[2];

-        const size_t numChars = encode_utf16(*in++, cc);
+        const size_t numChars = encode_utf16(*inBuff++, cc);

         if ( numChars == wxCONV_FAILED )
             return wxCONV_FAILED;
 
         if ( numChars == wxCONV_FAILED )
             return wxCONV_FAILED;
 


@@ -1289,10 +1341,10 @@ wxMBConvUTF32straight::FromWChar(char *dst, size_t dstLen,
         // we consider that surrogates are rare enough to make it worthwhile to
         // avoid running the loop below at the cost of slightly extra memory
         // consumption
         // we consider that surrogates are rare enough to make it worthwhile to
         // avoid running the loop below at the cost of slightly extra memory
         // consumption

-        return srcLen*BYTES_PER_CHAR;
+        return srcLen * BYTES_PER_CHAR;

     }
 
     }
 

-    wxUint32 *out = wx_reinterpret_cast(wxUint32 *, dst);
+    wxUint32 *outBuff = wx_reinterpret_cast(wxUint32 *, dst);

     size_t outLen = 0;
     for ( const wchar_t * const srcEnd = src + srcLen; src < srcEnd; )
     {
     size_t outLen = 0;
     for ( const wchar_t * const srcEnd = src + srcLen; src < srcEnd; )
     {


@@ -1305,7 +1357,7 @@ wxMBConvUTF32straight::FromWChar(char *dst, size_t dstLen,
         if ( outLen > dstLen )
             return wxCONV_FAILED;
 
         if ( outLen > dstLen )
             return wxCONV_FAILED;
 

-        *out++ = ch;
+        *outBuff++ = ch;

     }
 
     return outLen;
     }
 
     return outLen;


@@ -1323,13 +1375,13 @@ wxMBConvUTF32swap::ToWChar(wchar_t *dst, size_t dstLen,
     if ( srcLen == wxNO_LEN )
         return wxCONV_FAILED;
 
     if ( srcLen == wxNO_LEN )
         return wxCONV_FAILED;
 

-    const wxUint32 *in = wx_reinterpret_cast(const wxUint32 *, src);
-    const size_t inLen = srcLen/BYTES_PER_CHAR;
+    const wxUint32 *inBuff = wx_reinterpret_cast(const wxUint32 *, src);
+    const size_t inLen = srcLen / BYTES_PER_CHAR;

     size_t outLen = 0;
     size_t outLen = 0;

-    for ( size_t n = 0; n < inLen; n++, in++ )
+    for ( size_t n = 0; n < inLen; n++, inBuff++ )

     {
         wxUint16 cc[2];
     {
         wxUint16 cc[2];

-        const size_t numChars = encode_utf16(wxUINT32_SWAP_ALWAYS(*in), cc);
+        const size_t numChars = encode_utf16(wxUINT32_SWAP_ALWAYS(*inBuff), cc);

         if ( numChars == wxCONV_FAILED )
             return wxCONV_FAILED;
 
         if ( numChars == wxCONV_FAILED )
             return wxCONV_FAILED;
 


@@ -1370,7 +1422,7 @@ wxMBConvUTF32swap::FromWChar(char *dst, size_t dstLen,
         return srcLen*BYTES_PER_CHAR;
     }
 
         return srcLen*BYTES_PER_CHAR;
     }
 

-    wxUint32 *out = wx_reinterpret_cast(wxUint32 *, dst);
+    wxUint32 *outBuff = wx_reinterpret_cast(wxUint32 *, dst);

     size_t outLen = 0;
     for ( const wchar_t * const srcEnd = src + srcLen; src < srcEnd; )
     {
     size_t outLen = 0;
     for ( const wchar_t * const srcEnd = src + srcLen; src < srcEnd; )
     {


@@ -1383,7 +1435,7 @@ wxMBConvUTF32swap::FromWChar(char *dst, size_t dstLen,
         if ( outLen > dstLen )
             return wxCONV_FAILED;
 
         if ( outLen > dstLen )
             return wxCONV_FAILED;
 

-        *out++ = wxUINT32_SWAP_ALWAYS(ch);
+        *outBuff++ = wxUINT32_SWAP_ALWAYS(ch);

     }
 
     return outLen;
     }
 
     return outLen;


@@ -1391,101 +1443,104 @@ wxMBConvUTF32swap::FromWChar(char *dst, size_t dstLen,
 
 #else // !WC_UTF16: wchar_t is UTF-32
 
 
 #else // !WC_UTF16: wchar_t is UTF-32
 

-// copy 32bit MB to 32bit String
-size_t wxMBConvUTF32straight::MB2WC(wchar_t *buf, const char *psz, size_t n) const
+// ----------------------------------------------------------------------------
+// conversions without endianness change
+// ----------------------------------------------------------------------------
+
+size_t
+wxMBConvUTF32straight::ToWChar(wchar_t *dst, size_t dstLen,
+                               const char *src, size_t srcLen) const

 {
 {

-    size_t len=0;
+    // use memcpy() as it should be much faster than hand-written loop
+    srcLen = GetLength(src, srcLen);
+    if ( srcLen == wxNO_LEN )
+        return wxCONV_FAILED;

 
 

-    while (*(wxUint32*)psz && (!buf || len < n))
+    const size_t inLen = srcLen/BYTES_PER_CHAR;
+    if ( dst )

     {
     {

-        if (buf)
-            *buf++ = (wchar_t)(*(wxUint32*)psz);
-        len++;
-        psz += sizeof(wxUint32);
-    }
+        if ( dstLen < inLen )
+            return wxCONV_FAILED;

 
 

-    if (buf && len<n)
-        *buf=0;
+        memcpy(dst, src, srcLen);
+    }

 
 

-    return len;
+    return inLen;

 }
 
 }
 

-
-// copy 32bit String to 32bit MB
-size_t wxMBConvUTF32straight::WC2MB(char *buf, const wchar_t *psz, size_t n) const
+size_t
+wxMBConvUTF32straight::FromWChar(char *dst, size_t dstLen,
+                                 const wchar_t *src, size_t srcLen) const

 {
 {

-    size_t len=0;
+    if ( srcLen == wxNO_LEN )
+        srcLen = wxWcslen(src) + 1;
+
+    srcLen *= BYTES_PER_CHAR;

 
 

-    while (*psz && (!buf || len < n))
+    if ( dst )

     {
     {

-        if (buf)
-        {
-            *(wxUint32*)buf = *psz;
-            buf += sizeof(wxUint32);
-        }
+        if ( dstLen < srcLen )
+            return wxCONV_FAILED;

 
 

-        len += sizeof(wxUint32);
-        psz++;
+        memcpy(dst, src, srcLen);

     }
 
     }
 

-    if (buf && len<=n-sizeof(wxUint32))
-        *(wxUint32*)buf=0;
-
-    return len;
+    return srcLen;

 }
 
 }
 

+// ----------------------------------------------------------------------------
+// endian-reversing conversions
+// ----------------------------------------------------------------------------

 
 

-// swap 32bit MB to 32bit String
-size_t wxMBConvUTF32swap::MB2WC(wchar_t *buf, const char *psz, size_t n) const
+size_t
+wxMBConvUTF32swap::ToWChar(wchar_t *dst, size_t dstLen,
+                           const char *src, size_t srcLen) const

 {
 {

-    size_t len=0;
+    srcLen = GetLength(src, srcLen);
+    if ( srcLen == wxNO_LEN )
+        return wxCONV_FAILED;

 
 

-    while (*(wxUint32*)psz && (!buf || len < n))
+    srcLen /= BYTES_PER_CHAR;
+
+    if ( dst )

     {
     {

-        if (buf)
+        if ( dstLen < srcLen )
+            return wxCONV_FAILED;
+
+        const wxUint32 *inBuff = wx_reinterpret_cast(const wxUint32 *, src);
+        for ( size_t n = 0; n < srcLen; n++, inBuff++ )

         {
         {

-            ((char *)buf)[0] = psz[3];
-            ((char *)buf)[1] = psz[2];
-            ((char *)buf)[2] = psz[1];
-            ((char *)buf)[3] = psz[0];
-            buf++;
+            *dst++ = wxUINT32_SWAP_ALWAYS(*inBuff);

         }
         }

-        len++;
-        psz += sizeof(wxUint32);

     }
 
     }
 

-    if (buf && len<n)
-        *buf=0;
-
-    return len;
+    return srcLen;

 }
 
 }
 

-
-// swap 32bit String to 32bit MB
-size_t wxMBConvUTF32swap::WC2MB(char *buf, const wchar_t *psz, size_t n) const
+size_t
+wxMBConvUTF32swap::FromWChar(char *dst, size_t dstLen,
+                             const wchar_t *src, size_t srcLen) const

 {
 {

-    size_t len=0;
+    if ( srcLen == wxNO_LEN )
+        srcLen = wxWcslen(src) + 1;
+
+    srcLen *= BYTES_PER_CHAR;

 
 

-    while (*psz && (!buf || len < n))
+    if ( dst )

     {
     {

-        if (buf)
+        if ( dstLen < srcLen )
+            return wxCONV_FAILED;
+
+        wxUint32 *outBuff = wx_reinterpret_cast(wxUint32 *, dst);
+        for ( size_t n = 0; n < srcLen; n += BYTES_PER_CHAR, src++ )

         {
         {

-            *buf++ = ((char *)psz)[3];
-            *buf++ = ((char *)psz)[2];
-            *buf++ = ((char *)psz)[1];
-            *buf++ = ((char *)psz)[0];
+            *outBuff++ = wxUINT32_SWAP_ALWAYS(*src);

         }
         }

-        len += sizeof(wxUint32);
-        psz++;

     }
 
     }
 

-    if (buf && len<=n-sizeof(wxUint32))
-        *(wxUint32*)buf=0;
-
-    return len;
+    return srcLen;

 }
 
 }
 

-

 #endif // WC_UTF16/!WC_UTF16
 
 
 #endif // WC_UTF16/!WC_UTF16
 
 


@@ -1552,10 +1607,11 @@ public:
         { return (m2w != ICONV_T_INVALID) && (w2m != ICONV_T_INVALID); }
 
 protected:
         { return (m2w != ICONV_T_INVALID) && (w2m != ICONV_T_INVALID); }
 
 protected:

-    // the iconv handlers used to translate from multibyte to wide char and in
-    // the other direction
+    // the iconv handlers used to translate from multibyte
+    // to wide char and in the other direction

     iconv_t m2w,
             w2m;
     iconv_t m2w,
             w2m;

+

 #if wxUSE_THREADS
     // guards access to m2w and w2m objects
     wxMutex m_iconvMutex;
 #if wxUSE_THREADS
     // guards access to m2w and w2m objects
     wxMutex m_iconvMutex;


@@ -1588,6 +1644,7 @@ WXDLLIMPEXP_BASE wxMBConv* new_wxMBConv_iconv( const wxChar* name )
         delete result;
         return 0;
     }
         delete result;
         return 0;
     }

+

     return result;
 }
 
     return result;
 }
 


@@ -1628,11 +1685,12 @@ wxMBConv_iconv::wxMBConv_iconv(const wxChar *name)
 
             // first try charset with explicit bytesex info (e.g. "UCS-4LE"):
             wxString nameXE(nameCS);
 
             // first try charset with explicit bytesex info (e.g. "UCS-4LE"):
             wxString nameXE(nameCS);

-            #ifdef WORDS_BIGENDIAN
+
+#ifdef WORDS_BIGENDIAN

                 nameXE += _T("BE");
                 nameXE += _T("BE");

-            #else // little endian
+#else // little endian

                 nameXE += _T("LE");
                 nameXE += _T("LE");

-            #endif
+#endif

 
             wxLogTrace(TRACE_STRCONV, _T("  trying charset \"%s\""),
                        nameXE.c_str());
 
             wxLogTrace(TRACE_STRCONV, _T("  trying charset \"%s\""),
                        nameXE.c_str());


@@ -1661,8 +1719,9 @@ wxMBConv_iconv::wxMBConv_iconv(const wxChar *name)
                     wbufPtr = wbuf;
                     bufPtr = buf;
 
                     wbufPtr = wbuf;
                     bufPtr = buf;
 

-                    res = iconv(m2w, ICONV_CHAR_CAST(&bufPtr), &insz,
-                                (char**)&wbufPtr, &outsz);
+                    res = iconv(
+                        m2w, ICONV_CHAR_CAST(&bufPtr), &insz,
+                        (char**)&wbufPtr, &outsz);

 
                     if (ICONV_FAILED(res, insz))
                     {
 
                     if (ICONV_FAILED(res, insz))
                     {


@@ -1756,7 +1815,6 @@ size_t wxMBConv_iconv::MB2WC(wchar_t *buf, const char *psz, size_t n) const
     wxMutexLocker lock(wxConstCast(this, wxMBConv_iconv)->m_iconvMutex);
 #endif // wxUSE_THREADS
 
     wxMutexLocker lock(wxConstCast(this, wxMBConv_iconv)->m_iconvMutex);
 #endif // wxUSE_THREADS
 

-

     size_t outbuf = n * SIZEOF_WCHAR_T;
     size_t res, cres;
     // VS: Use these instead of psz, buf because iconv() modifies its arguments:
     size_t outbuf = n * SIZEOF_WCHAR_T;
     size_t res, cres;
     // VS: Use these instead of psz, buf because iconv() modifies its arguments:


@@ -1788,16 +1846,19 @@ size_t wxMBConv_iconv::MB2WC(wchar_t *buf, const char *psz, size_t n) const
         // to calculate destination buffer requirement
         wchar_t tbuf[8];
         res = 0;
         // to calculate destination buffer requirement
         wchar_t tbuf[8];
         res = 0;

-        do {
+
+        do
+        {

             bufPtr = tbuf;
             bufPtr = tbuf;

-            outbuf = 8*SIZEOF_WCHAR_T;
+            outbuf = 8 * SIZEOF_WCHAR_T;

 
             cres = iconv(m2w,
                          ICONV_CHAR_CAST(&pszPtr), &inbuf,
                          (char**)&bufPtr, &outbuf );
 
 
             cres = iconv(m2w,
                          ICONV_CHAR_CAST(&pszPtr), &inbuf,
                          (char**)&bufPtr, &outbuf );
 

-            res += 8-(outbuf/SIZEOF_WCHAR_T);
-        } while ((cres==(size_t)-1) && (errno==E2BIG));
+            res += 8 - (outbuf / SIZEOF_WCHAR_T);
+        }
+        while ((cres == (size_t)-1) && (errno == E2BIG));

     }
 
     if (ICONV_FAILED(cres, inbuf))
     }
 
     if (ICONV_FAILED(cres, inbuf))


@@ -1832,6 +1893,7 @@ size_t wxMBConv_iconv::WC2MB(char *buf, const wchar_t *psz, size_t n) const
         tmpbuf = (wchar_t *)malloc(inbuf + SIZEOF_WCHAR_T);
         for ( size_t i = 0; i < inlen; i++ )
             tmpbuf[n] = WC_BSWAP(psz[i]);
         tmpbuf = (wchar_t *)malloc(inbuf + SIZEOF_WCHAR_T);
         for ( size_t i = 0; i < inlen; i++ )
             tmpbuf[n] = WC_BSWAP(psz[i]);

+

         tmpbuf[inlen] = L'\0';
         psz = tmpbuf;
     }
         tmpbuf[inlen] = L'\0';
         psz = tmpbuf;
     }


@@ -1841,7 +1903,7 @@ size_t wxMBConv_iconv::WC2MB(char *buf, const wchar_t *psz, size_t n) const
         // have destination buffer, convert there
         cres = iconv( w2m, ICONV_CHAR_CAST(&psz), &inbuf, &buf, &outbuf );
 
         // have destination buffer, convert there
         cres = iconv( w2m, ICONV_CHAR_CAST(&psz), &inbuf, &buf, &outbuf );
 

-        res = n-outbuf;
+        res = n - outbuf;

 
         // NB: iconv was given only wcslen(psz) characters on input, and so
         //     it couldn't convert the trailing zero. Let's do it ourselves
 
         // NB: iconv was given only wcslen(psz) characters on input, and so
         //     it couldn't convert the trailing zero. Let's do it ourselves


@@ -1851,17 +1913,20 @@ size_t wxMBConv_iconv::WC2MB(char *buf, const wchar_t *psz, size_t n) const
     }
     else
     {
     }
     else
     {

-        // no destination buffer... convert using temp buffer
+        // no destination buffer: convert using temp buffer

         // to calculate destination buffer requirement
         char tbuf[16];
         res = 0;
         // to calculate destination buffer requirement
         char tbuf[16];
         res = 0;

-        do {
-            buf = tbuf; outbuf = 16;
+        do
+        {
+            buf = tbuf;
+            outbuf = 16;

 
             cres = iconv( w2m, ICONV_CHAR_CAST(&psz), &inbuf, &buf, &outbuf );
 
             res += 16 - outbuf;
 
             cres = iconv( w2m, ICONV_CHAR_CAST(&psz), &inbuf, &buf, &outbuf );
 
             res += 16 - outbuf;

-        } while ((cres==(size_t)-1) && (errno==E2BIG));
+        }
+        while ((cres == (size_t)-1) && (errno == E2BIG));

     }
 
     if (ms_wcNeedsSwap)
     }
 
     if (ms_wcNeedsSwap)


@@ -1893,15 +1958,15 @@ size_t wxMBConv_iconv::GetMBNulLen() const
         char buf[8]; // should be enough for NUL in any encoding
         size_t inLen = sizeof(wchar_t),
                outLen = WXSIZEOF(buf);
         char buf[8]; // should be enough for NUL in any encoding
         size_t inLen = sizeof(wchar_t),
                outLen = WXSIZEOF(buf);

-        char *in = (char *)wnul;
-        char *out = buf;
-        if ( iconv(w2m, ICONV_CHAR_CAST(&in), &inLen, &out, &outLen) == (size_t)-1 )
+        char *inBuff = (char *)wnul;
+        char *outBuff = buf;
+        if ( iconv(w2m, ICONV_CHAR_CAST(&inBuff), &inLen, &outBuff, &outLen) == (size_t)-1 )

         {
             self->m_minMBCharWidth = (size_t)-1;
         }
         else // ok
         {
         {
             self->m_minMBCharWidth = (size_t)-1;
         }
         else // ok
         {

-            self->m_minMBCharWidth = out - buf;
+            self->m_minMBCharWidth = outBuff - buf;

         }
     }
 
         }
     }
 


@@ -1933,6 +1998,7 @@ public:
     }
 
     wxMBConv_win32(const wxMBConv_win32& conv)
     }
 
     wxMBConv_win32(const wxMBConv_win32& conv)

+        : wxMBConv()

     {
         m_CodePage = conv.m_CodePage;
         m_minMBCharWidth = conv.m_minMBCharWidth;
     {
         m_CodePage = conv.m_CodePage;
         m_minMBCharWidth = conv.m_minMBCharWidth;


@@ -2130,7 +2196,8 @@ public:
             {
                 default:
                     wxLogDebug(_T("Unexpected NUL length %d"), len);
             {
                 default:
                     wxLogDebug(_T("Unexpected NUL length %d"), len);

-                    // fall through
+                    self->m_minMBCharWidth = (size_t)-1;
+                    break;

 
                 case 0:
                     self->m_minMBCharWidth = (size_t)-1;
 
                 case 0:
                     self->m_minMBCharWidth = (size_t)-1;


@@ -2170,8 +2237,9 @@ private:
                     break;
 
                 default:
                     break;
 
                 default:

-                    // unknown, be conseravtive by default
+                    // unknown: be conservative by default

                     s_isWin98Or2k = 0;
                     s_isWin98Or2k = 0;

+                    break;

             }
 
             wxASSERT_MSG( s_isWin98Or2k != -1, _T("should be set above") );
             }
 
             wxASSERT_MSG( s_isWin98Or2k != -1, _T("should be set above") );


@@ -2224,9 +2292,9 @@ private:
 
 #if defined(__WXCOCOA__)
 
 
 #if defined(__WXCOCOA__)
 

-// RN:  There is no UTF-32 support in either Core Foundation or
-// Cocoa.  Strangely enough, internally Core Foundation uses
-// UTF 32 internally quite a bit - its just not public (yet).
+// RN: There is no UTF-32 support in either Core Foundation or Cocoa.
+// Strangely enough, internally Core Foundation uses
+// UTF-32 internally quite a bit - its just not public (yet).

 
 #include <CoreFoundation/CFString.h>
 #include <CoreFoundation/CFStringEncodingExt.h>
 
 #include <CoreFoundation/CFString.h>
 #include <CoreFoundation/CFStringEncodingExt.h>


@@ -2234,12 +2302,13 @@ private:
 CFStringEncoding wxCFStringEncFromFontEnc(wxFontEncoding encoding)
 {
     CFStringEncoding enc = kCFStringEncodingInvalidId ;
 CFStringEncoding wxCFStringEncFromFontEnc(wxFontEncoding encoding)
 {
     CFStringEncoding enc = kCFStringEncodingInvalidId ;

-    if ( encoding == wxFONTENCODING_DEFAULT )
-    {
-        enc = CFStringGetSystemEncoding();
-    }
-    else switch( encoding)
+
+    switch (encoding)

     {
     {

+        case wxFONTENCODING_DEFAULT :
+            enc = CFStringGetSystemEncoding();
+            break ;
+

         case wxFONTENCODING_ISO8859_1 :
             enc = kCFStringEncodingISOLatin1 ;
             break ;
         case wxFONTENCODING_ISO8859_1 :
             enc = kCFStringEncodingISOLatin1 ;
             break ;


@@ -2295,7 +2364,7 @@ CFStringEncoding wxCFStringEncFromFontEnc(wxFontEncoding encoding)
 //          break ;
 
         case wxFONTENCODING_CP437 :
 //          break ;
 
         case wxFONTENCODING_CP437 :

-            enc =kCFStringEncodingDOSLatinUS ;
+            enc = kCFStringEncodingDOSLatinUS ;

             break ;
         case wxFONTENCODING_CP850 :
             enc = kCFStringEncodingDOSLatin1;
             break ;
         case wxFONTENCODING_CP850 :
             enc = kCFStringEncodingDOSLatin1;


@@ -2307,7 +2376,7 @@ CFStringEncoding wxCFStringEncFromFontEnc(wxFontEncoding encoding)
             enc = kCFStringEncodingDOSCyrillic;
             break ;
         case wxFONTENCODING_CP866 :
             enc = kCFStringEncodingDOSCyrillic;
             break ;
         case wxFONTENCODING_CP866 :

-            enc =kCFStringEncodingDOSRussian ;
+            enc = kCFStringEncodingDOSRussian ;

             break ;
         case wxFONTENCODING_CP874 :
             enc = kCFStringEncodingDOSThai;
             break ;
         case wxFONTENCODING_CP874 :
             enc = kCFStringEncodingDOSThai;


@@ -2316,7 +2385,7 @@ CFStringEncoding wxCFStringEncFromFontEnc(wxFontEncoding encoding)
             enc = kCFStringEncodingDOSJapanese;
             break ;
         case wxFONTENCODING_CP936 :
             enc = kCFStringEncodingDOSJapanese;
             break ;
         case wxFONTENCODING_CP936 :

-            enc =kCFStringEncodingDOSChineseSimplif ;
+            enc = kCFStringEncodingDOSChineseSimplif ;

             break ;
         case wxFONTENCODING_CP949 :
             enc = kCFStringEncodingDOSKorean;
             break ;
         case wxFONTENCODING_CP949 :
             enc = kCFStringEncodingDOSKorean;


@@ -2328,10 +2397,10 @@ CFStringEncoding wxCFStringEncFromFontEnc(wxFontEncoding encoding)
             enc = kCFStringEncodingWindowsLatin2;
             break ;
         case wxFONTENCODING_CP1251 :
             enc = kCFStringEncodingWindowsLatin2;
             break ;
         case wxFONTENCODING_CP1251 :

-            enc =kCFStringEncodingWindowsCyrillic ;
+            enc = kCFStringEncodingWindowsCyrillic ;

             break ;
         case wxFONTENCODING_CP1252 :
             break ;
         case wxFONTENCODING_CP1252 :

-            enc =kCFStringEncodingWindowsLatin1 ;
+            enc = kCFStringEncodingWindowsLatin1 ;

             break ;
         case wxFONTENCODING_CP1253 :
             enc = kCFStringEncodingWindowsGreek;
             break ;
         case wxFONTENCODING_CP1253 :
             enc = kCFStringEncodingWindowsGreek;


@@ -2340,10 +2409,10 @@ CFStringEncoding wxCFStringEncFromFontEnc(wxFontEncoding encoding)
             enc = kCFStringEncodingWindowsLatin5;
             break ;
         case wxFONTENCODING_CP1255 :
             enc = kCFStringEncodingWindowsLatin5;
             break ;
         case wxFONTENCODING_CP1255 :

-            enc =kCFStringEncodingWindowsHebrew ;
+            enc = kCFStringEncodingWindowsHebrew ;

             break ;
         case wxFONTENCODING_CP1256 :
             break ;
         case wxFONTENCODING_CP1256 :

-            enc =kCFStringEncodingWindowsArabic ;
+            enc = kCFStringEncodingWindowsArabic ;

             break ;
         case wxFONTENCODING_CP1257 :
             enc = kCFStringEncodingWindowsBalticRim;
             break ;
         case wxFONTENCODING_CP1257 :
             enc = kCFStringEncodingWindowsBalticRim;


@@ -2481,10 +2550,12 @@ CFStringEncoding wxCFStringEncFromFontEnc(wxFontEncoding encoding)
 //      case wxFONTENCODING_MACKEYBOARD :
 //          enc = kCFStringEncodingMacKeyboardGlyphs ;
 //          break ;
 //      case wxFONTENCODING_MACKEYBOARD :
 //          enc = kCFStringEncodingMacKeyboardGlyphs ;
 //          break ;

+

         default :
             // because gcc is picky
             break ;
         default :
             // because gcc is picky
             break ;

-    } ;
+    }
+

     return enc ;
 }
 
     return enc ;
 }
 


@@ -2554,12 +2625,12 @@ public:
 
         CFRelease(theString);
 
 
         CFRelease(theString);
 

-        szUniCharBuffer[nOutLength] = '\0' ;
+        szUniCharBuffer[nOutLength] = '\0';

 
 #if SIZEOF_WCHAR_T == 4
 
 #if SIZEOF_WCHAR_T == 4

-        wxMBConvUTF16 converter ;
-        converter.MB2WC(szOut, (const char*)szUniCharBuffer , nOutSize ) ;
-        delete[] szUniCharBuffer;
+        wxMBConvUTF16 converter;
+        converter.MB2WC( szOut, (const char*)szUniCharBuffer, nOutSize );
+        delete [] szUniCharBuffer;

 #endif
 
         return nOutLength;
 #endif
 
         return nOutLength;


@@ -2575,9 +2646,9 @@ public:
 
 #if SIZEOF_WCHAR_T == 4
         wxMBConvUTF16 converter ;
 
 #if SIZEOF_WCHAR_T == 4
         wxMBConvUTF16 converter ;

-        nBufSize = converter.WC2MB( NULL , szUnConv , 0 );
-        szUniBuffer = new UniChar[ (nBufSize / sizeof(UniChar)) + 1] ;
-        converter.WC2MB( (char*) szUniBuffer , szUnConv, nBufSize + sizeof(UniChar)) ;
+        nBufSize = converter.WC2MB( NULL, szUnConv, 0 );
+        szUniBuffer = new UniChar[ (nBufSize / sizeof(UniChar)) + 1];
+        converter.WC2MB( (char*) szUniBuffer, szUnConv, nBufSize + sizeof(UniChar));

         nBufSize /= sizeof(UniChar);
 #endif
 
         nBufSize /= sizeof(UniChar);
 #endif
 


@@ -2659,7 +2730,7 @@ public:
 #if wxUSE_FONTMAP
     wxMBConv_mac(const wxChar* name)
     {
 #if wxUSE_FONTMAP
     wxMBConv_mac(const wxChar* name)
     {

-        Init( wxMacGetSystemEncFromFontEnc(wxFontMapperBase::Get()->CharsetToEncoding(name, false) ) ) ;
+        Init( wxMacGetSystemEncFromFontEnc( wxFontMapperBase::Get()->CharsetToEncoding(name, false) ) );

     }
 #endif
 
     }
 #endif
 


@@ -2680,7 +2751,7 @@ public:
     {
         OSStatus status = noErr ;
         m_char_encoding = encoding ;
     {
         OSStatus status = noErr ;
         m_char_encoding = encoding ;

-        m_unicode_encoding = CreateTextEncoding(kTextEncodingUnicodeDefault,0,kUnicode16BitFormat) ;
+        m_unicode_encoding = CreateTextEncoding(kTextEncodingUnicodeDefault, 0, kUnicode16BitFormat) ;

 
         status = TECCreateConverter(&m_MB2WC_converter,
                                     m_char_encoding,
 
         status = TECCreateConverter(&m_MB2WC_converter,
                                     m_char_encoding,


@@ -2694,35 +2765,41 @@ public:
     {
         OSStatus status = noErr ;
         ByteCount byteOutLen ;
     {
         OSStatus status = noErr ;
         ByteCount byteOutLen ;

-        ByteCount byteInLen = strlen(psz) ;
+        ByteCount byteInLen = strlen(psz) + 1;

         wchar_t *tbuf = NULL ;
         UniChar* ubuf = NULL ;
         size_t res = 0 ;
 
         if (buf == NULL)
         {
         wchar_t *tbuf = NULL ;
         UniChar* ubuf = NULL ;
         size_t res = 0 ;
 
         if (buf == NULL)
         {

-            //apple specs say at least 32
-            n = wxMax( 32 , byteInLen ) ;
-            tbuf = (wchar_t*) malloc( n * SIZEOF_WCHAR_T) ;
+            // Apple specs say at least 32
+            n = wxMax( 32, byteInLen ) ;
+            tbuf = (wchar_t*) malloc( n * SIZEOF_WCHAR_T ) ;

         }
         }

+

         ByteCount byteBufferLen = n * sizeof( UniChar ) ;
         ByteCount byteBufferLen = n * sizeof( UniChar ) ;

+

 #if SIZEOF_WCHAR_T == 4
         ubuf = (UniChar*) malloc( byteBufferLen + 2 ) ;
 #else
         ubuf = (UniChar*) (buf ? buf : tbuf) ;
 #endif
 #if SIZEOF_WCHAR_T == 4
         ubuf = (UniChar*) malloc( byteBufferLen + 2 ) ;
 #else
         ubuf = (UniChar*) (buf ? buf : tbuf) ;
 #endif

-        status = TECConvertText(m_MB2WC_converter, (ConstTextPtr) psz , byteInLen, &byteInLen,
-          (TextPtr) ubuf , byteBufferLen, &byteOutLen);
+
+        status = TECConvertText(
+            m_MB2WC_converter, (ConstTextPtr) psz, byteInLen, &byteInLen,
+            (TextPtr) ubuf, byteBufferLen, &byteOutLen);
+

 #if SIZEOF_WCHAR_T == 4
         // we have to terminate here, because n might be larger for the trailing zero, and if UniChar
         // is not properly terminated we get random characters at the end
         ubuf[byteOutLen / sizeof( UniChar ) ] = 0 ;
         wxMBConvUTF16 converter ;
 #if SIZEOF_WCHAR_T == 4
         // we have to terminate here, because n might be larger for the trailing zero, and if UniChar
         // is not properly terminated we get random characters at the end
         ubuf[byteOutLen / sizeof( UniChar ) ] = 0 ;
         wxMBConvUTF16 converter ;

-        res = converter.MB2WC( (buf ? buf : tbuf) , (const char*)ubuf , n ) ;
+        res = converter.MB2WC( (buf ? buf : tbuf), (const char*)ubuf, n ) ;

         free( ubuf ) ;
 #else
         res = byteOutLen / sizeof( UniChar ) ;
 #endif
         free( ubuf ) ;
 #else
         res = byteOutLen / sizeof( UniChar ) ;
 #endif

+

         if ( buf == NULL )
              free(tbuf) ;
 
         if ( buf == NULL )
              free(tbuf) ;
 


@@ -2742,27 +2819,32 @@ public:
 
         if (buf == NULL)
         {
 
         if (buf == NULL)
         {

-            //apple specs say at least 32
-            n = wxMax( 32 , ((byteInLen / SIZEOF_WCHAR_T) * 8) + SIZEOF_WCHAR_T );
+            // Apple specs say at least 32
+            n = wxMax( 32, ((byteInLen / SIZEOF_WCHAR_T) * 8) + SIZEOF_WCHAR_T );

             tbuf = (char*) malloc( n ) ;
         }
 
         ByteCount byteBufferLen = n ;
         UniChar* ubuf = NULL ;
             tbuf = (char*) malloc( n ) ;
         }
 
         ByteCount byteBufferLen = n ;
         UniChar* ubuf = NULL ;

+

 #if SIZEOF_WCHAR_T == 4
         wxMBConvUTF16 converter ;
 #if SIZEOF_WCHAR_T == 4
         wxMBConvUTF16 converter ;

-        size_t unicharlen = converter.WC2MB( NULL , psz , 0 ) ;
+        size_t unicharlen = converter.WC2MB( NULL, psz, 0 ) ;

         byteInLen = unicharlen ;
         ubuf = (UniChar*) malloc( byteInLen + 2 ) ;
         byteInLen = unicharlen ;
         ubuf = (UniChar*) malloc( byteInLen + 2 ) ;

-        converter.WC2MB( (char*) ubuf , psz, unicharlen + 2 ) ;
+        converter.WC2MB( (char*) ubuf, psz, unicharlen + 2 ) ;

 #else
         ubuf = (UniChar*) psz ;
 #endif
 #else
         ubuf = (UniChar*) psz ;
 #endif

-        status = TECConvertText(m_WC2MB_converter, (ConstTextPtr) ubuf , byteInLen, &byteInLen,
-            (TextPtr) (buf ? buf : tbuf) , byteBufferLen, &byteOutLen);
+
+        status = TECConvertText(
+            m_WC2MB_converter, (ConstTextPtr) ubuf, byteInLen, &byteInLen,
+            (TextPtr) (buf ? buf : tbuf), byteBufferLen, &byteOutLen);
+

 #if SIZEOF_WCHAR_T == 4
         free( ubuf ) ;
 #endif
 #if SIZEOF_WCHAR_T == 4
         free( ubuf ) ;
 #endif

+

         if ( buf == NULL )
             free(tbuf) ;
 
         if ( buf == NULL )
             free(tbuf) ;
 


@@ -2791,14 +2873,14 @@ public:
     virtual wxMBConv *Clone() const { return new wxMBConv_mac(*this); }
 
     bool IsOk() const
     virtual wxMBConv *Clone() const { return new wxMBConv_mac(*this); }
 
     bool IsOk() const

-        { return m_MB2WC_converter !=  NULL && m_WC2MB_converter != NULL  ; }
+        { return m_MB2WC_converter != NULL && m_WC2MB_converter != NULL; }

 
 private:
 
 private:

-    TECObjectRef m_MB2WC_converter ;
-    TECObjectRef m_WC2MB_converter ;
+    TECObjectRef m_MB2WC_converter;
+    TECObjectRef m_WC2MB_converter;

 
 

-    TextEncodingBase m_char_encoding ;
-    TextEncodingBase m_unicode_encoding ;
+    TextEncodingBase m_char_encoding;
+    TextEncodingBase m_unicode_encoding;

 };
 
 #endif // defined(__WXMAC__) && defined(TARGET_CARBON)
 };
 
 #endif // defined(__WXMAC__) && defined(TARGET_CARBON)


@@ -2843,7 +2925,7 @@ public:
         size_t inbuf = strlen(psz);
         if (buf)
         {
         size_t inbuf = strlen(psz);
         if (buf)
         {

-            if (!m2w.Convert(psz,buf))
+            if (!m2w.Convert(psz, buf))

                 return wxCONV_FAILED;
         }
         return inbuf;
                 return wxCONV_FAILED;
         }
         return inbuf;


@@ -2854,7 +2936,7 @@ public:
         const size_t inbuf = wxWcslen(psz);
         if (buf)
         {
         const size_t inbuf = wxWcslen(psz);
         if (buf)
         {

-            if (!w2m.Convert(psz,buf))
+            if (!w2m.Convert(psz, buf))

                 return wxCONV_FAILED;
         }
 
                 return wxCONV_FAILED;
         }
 


@@ -2902,6 +2984,7 @@ WXDLLIMPEXP_BASE wxMBConv* new_wxMBConv_wxwin( const wxChar* name )
         delete result;
         return 0;
     }
         delete result;
         return 0;
     }

+

     return result;
 }
 
     return result;
 }
 


@@ -2991,7 +3074,6 @@ void wxCSConv::SetName(const wxChar *charset)
 }
 
 #if wxUSE_FONTMAP
 }
 
 #if wxUSE_FONTMAP

-#include "wx/hashmap.h"

 
 WX_DECLARE_HASH_MAP( wxFontEncoding, wxString, wxIntegerHash, wxIntegerEqual,
                      wxEncodingNameCache );
 
 WX_DECLARE_HASH_MAP( wxFontEncoding, wxString, wxIntegerHash, wxIntegerEqual,
                      wxEncodingNameCache );


@@ -3097,13 +3179,13 @@ wxMBConv *wxCSConv::DoCreate() const
 #endif
     }
 #endif // wxHAVE_WIN32_MB2WC
 #endif
     }
 #endif // wxHAVE_WIN32_MB2WC

+

 #if defined(__WXMAC__)
     {
         // leave UTF16 and UTF32 to the built-ins of wx
         if ( m_name || ( m_encoding < wxFONTENCODING_UTF16BE ||
             ( m_encoding >= wxFONTENCODING_MACMIN && m_encoding <= wxFONTENCODING_MACMAX ) ) )
         {
 #if defined(__WXMAC__)
     {
         // leave UTF16 and UTF32 to the built-ins of wx
         if ( m_name || ( m_encoding < wxFONTENCODING_UTF16BE ||
             ( m_encoding >= wxFONTENCODING_MACMIN && m_encoding <= wxFONTENCODING_MACMAX ) ) )
         {

-

 #if wxUSE_FONTMAP
             wxMBConv_mac *conv = m_name ? new wxMBConv_mac(m_name)
                                         : new wxMBConv_mac(m_encoding);
 #if wxUSE_FONTMAP
             wxMBConv_mac *conv = m_name ? new wxMBConv_mac(m_name)
                                         : new wxMBConv_mac(m_encoding);


@@ -3117,17 +3199,18 @@ wxMBConv *wxCSConv::DoCreate() const
         }
     }
 #endif
         }
     }
 #endif

+

 #if defined(__WXCOCOA__)
     {
         if ( m_name || ( m_encoding <= wxFONTENCODING_UTF16 ) )
         {
 #if defined(__WXCOCOA__)
     {
         if ( m_name || ( m_encoding <= wxFONTENCODING_UTF16 ) )
         {

-

 #if wxUSE_FONTMAP
             wxMBConv_cocoa *conv = m_name ? new wxMBConv_cocoa(m_name)
                                           : new wxMBConv_cocoa(m_encoding);
 #else
             wxMBConv_cocoa *conv = new wxMBConv_cocoa(m_encoding);
 #endif
 #if wxUSE_FONTMAP
             wxMBConv_cocoa *conv = m_name ? new wxMBConv_cocoa(m_name)
                                           : new wxMBConv_cocoa(m_encoding);
 #else
             wxMBConv_cocoa *conv = new wxMBConv_cocoa(m_encoding);
 #endif

+

             if ( conv->IsOk() )
                  return conv;
 
             if ( conv->IsOk() )
                  return conv;
 


@@ -3169,7 +3252,7 @@ wxMBConv *wxCSConv::DoCreate() const
 
         default:
              // nothing to do but put here to suppress gcc warnings
 
         default:
              // nothing to do but put here to suppress gcc warnings

-             ;
+             break;

     }
 
     // step (3)
     }
 
     // step (3)


@@ -3204,6 +3287,7 @@ wxMBConv *wxCSConv::DoCreate() const
                          wxString::Format(_("encoding %s"), m_encoding).c_str()
 #endif // wxUSE_FONTMAP/!wxUSE_FONTMAP
               );
                          wxString::Format(_("encoding %s"), m_encoding).c_str()
 #endif // wxUSE_FONTMAP/!wxUSE_FONTMAP
               );

+

         alreadyLoggingError = false;
     }
 
         alreadyLoggingError = false;
     }
 


@@ -3264,6 +3348,7 @@ size_t wxCSConv::WC2MB(char *buf, const wchar_t *psz, size_t n) const
         {
             if (psz[c] > 0xFF)
                 return wxCONV_FAILED;
         {
             if (psz[c] > 0xFF)
                 return wxCONV_FAILED;

+

             buf[c] = (char)psz[c];
         }
     }
             buf[c] = (char)psz[c];
         }
     }


@@ -3314,6 +3399,7 @@ WXDLLIMPEXP_DATA_BASE(wxCSConv&) wxConvISO8859_1 = wxConvISO8859_1Obj;
 WXDLLIMPEXP_DATA_BASE(wxMBConvUTF7&) wxConvUTF7 = wxConvUTF7Obj;
 WXDLLIMPEXP_DATA_BASE(wxMBConvUTF8&) wxConvUTF8 = wxConvUTF8Obj;
 WXDLLIMPEXP_DATA_BASE(wxMBConv *) wxConvCurrent = &wxConvLibcObj;
 WXDLLIMPEXP_DATA_BASE(wxMBConvUTF7&) wxConvUTF7 = wxConvUTF7Obj;
 WXDLLIMPEXP_DATA_BASE(wxMBConvUTF8&) wxConvUTF8 = wxConvUTF8Obj;
 WXDLLIMPEXP_DATA_BASE(wxMBConv *) wxConvCurrent = &wxConvLibcObj;

+WXDLLIMPEXP_DATA_BASE(wxMBConv *) wxConvUI = &wxConvLocal;

 WXDLLIMPEXP_DATA_BASE(wxMBConv *) wxConvFileName = &
 #ifdef __WXOSX__
                                     wxConvUTF8Obj;
 WXDLLIMPEXP_DATA_BASE(wxMBConv *) wxConvFileName = &
 #ifdef __WXOSX__
                                     wxConvUTF8Obj;


@@ -3321,7 +3407,6 @@ WXDLLIMPEXP_DATA_BASE(wxMBConv *) wxConvFileName = &
                                     wxConvLibcObj;
 #endif
 
                                     wxConvLibcObj;
 #endif
 

-

 #else // !wxUSE_WCHAR_T
 
 // stand-ins in absence of wchar_t
 #else // !wxUSE_WCHAR_T
 
 // stand-ins in absence of wchar_t