Hopefully fixed library names generated by wx-config for OS/2's PM port.

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

diff --git a/src/common/strconv.cpp b/src/common/strconv.cpp
index 2e3c0c8eaa33b4896b55eb9cc160863b27d851f7..aea1e1a18af397c745fed35b26afb06974b988e3 100644 (file)
--- a/src/common/strconv.cpp
+++ b/src/common/strconv.cpp
@@ -152,7 +152,7 @@ static size_t decode_utf16(const wxUint16* input, wxUint32& output)
         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 (size_t)-1;
     {
         output = *input;
         return (size_t)-1;


@@ -270,15 +270,15 @@ const wxWCharBuffer wxMBConv::cMB2WC(const char *szString, size_t nStringLen, si
         }
 
         //Increment to next (sub)string
         }
 
         //Increment to next (sub)string

-        //Note that we have to use strlen here instead of nLen
-        //here because XX2XX gives us the size of the output buffer,
-        //not neccessarly the length of the string
+        //Note that we have to use strlen instead of nLen here
+        //because XX2XX gives us the size of the output buffer,
+        //which is not necessarily the length of the string

         szPos += strlen(szPos) + 1;
     }
 
     //success - return actual length and the buffer
     *pOutSize = nActualLength;
         szPos += strlen(szPos) + 1;
     }
 
     //success - return actual length and the buffer
     *pOutSize = nActualLength;

-    return theBuffer;  
+    return theBuffer;

 }
 
 const wxCharBuffer wxMBConv::cWC2MB(const wchar_t *szString, size_t nStringLen, size_t* pOutSize) const
 }
 
 const wxCharBuffer wxMBConv::cWC2MB(const wchar_t *szString, size_t nStringLen, size_t* pOutSize) const


@@ -313,7 +313,7 @@ const wxCharBuffer wxMBConv::cWC2MB(const wchar_t *szString, size_t nStringLen,
 
         //Increase the actual length (+1 for current null character)
         nActualLength += nLen + 1;
 
         //Increase the actual length (+1 for current null character)
         nActualLength += nLen + 1;

-        
+

         //if buffer too big, realloc the buffer
         if (nActualLength > (nCurrentSize+1))
         {
         //if buffer too big, realloc the buffer
         if (nActualLength > (nCurrentSize+1))
         {


@@ -332,15 +332,15 @@ const wxCharBuffer wxMBConv::cWC2MB(const wchar_t *szString, size_t nStringLen,
         }
 
         //Increment to next (sub)string
         }
 
         //Increment to next (sub)string

-        //Note that we have to use wxWcslen here instead of nLen
-        //here because XX2XX gives us the size of the output buffer,
-        //not neccessarly the length of the string
+        //Note that we have to use wxWcslen instead of nLen here
+        //because XX2XX gives us the size of the output buffer,
+        //which is not necessarily the length of the string

         szPos += wxWcslen(szPos) + 1;
     }
 
     //success - return actual length and the buffer
     *pOutSize = nActualLength;
         szPos += wxWcslen(szPos) + 1;
     }
 
     //success - return actual length and the buffer
     *pOutSize = nActualLength;

-    return theBuffer;  
+    return theBuffer;

 }
 
 // ----------------------------------------------------------------------------
 }
 
 // ----------------------------------------------------------------------------


@@ -357,42 +357,41 @@ size_t wxMBConvLibc::WC2MB(char *buf, const wchar_t *psz, size_t n) const
     return wxWC2MB(buf, psz, n);
 }
 
     return wxWC2MB(buf, psz, n);
 }
 

+#ifdef __UNIX__
+

 // ----------------------------------------------------------------------------
 // ----------------------------------------------------------------------------

-// wxConvBrokenFileNames is made for GTK2 in Unicode mode when
-// files are accidentally written in an encoding which is not
-// the system encoding. Typically, the system encoding will be
-// UTF8 but there might be files stored in ISO8859-1 in disk. 
+// wxConvBrokenFileNames 

 // ----------------------------------------------------------------------------
 
 // ----------------------------------------------------------------------------
 

-class wxConvBrokenFileNames: public wxMBConvLibc
+wxConvBrokenFileNames::wxConvBrokenFileNames(const wxChar *charset)

 {
 {

-public:
-    virtual size_t MB2WC(wchar_t *outputBuf, const char *psz, size_t outputSize) const;
-    virtual size_t WC2MB(char *outputBuf, const wchar_t *psz, size_t outputSize) const;
-};
+    if ( !charset || wxStricmp(charset, _T("UTF-8")) == 0
+                  || wxStricmp(charset, _T("UTF8")) == 0  )
+        m_conv = new wxMBConvUTF8(wxMBConvUTF8::MAP_INVALID_UTF8_TO_OCTAL);
+    else
+        m_conv = new wxCSConv(charset);
+}

 
 

-size_t wxConvBrokenFileNames::MB2WC(wchar_t *outputBuf, const char *psz, size_t outputSize) const
+size_t
+wxConvBrokenFileNames::MB2WC(wchar_t *outputBuf,
+                             const char *psz,
+                             size_t outputSize) const

 {
 {

-#if 0
-    if (we find some invalid characters)
-    {
-       Convert to Unicode range.
-    }
-    else
-#endif
-    return wxMBConvLibc::MB2WC( outputBuf, psz, outputSize );
+    return m_conv->MB2WC( outputBuf, psz, outputSize );

 }
 
 }
 

-size_t wxConvBrokenFileNames::WC2MB(char *outputBuf, const wchar_t *psz, size_t outputSize) const
+size_t
+wxConvBrokenFileNames::WC2MB(char *outputBuf,
+                             const wchar_t *psz,
+                             size_t outputSize) const

 {
 {

-#if 0
-    Convert back from Unicode range.
-#endif
-    return wxMBConvLibc::WC2MB( outputBuf, psz, outputSize );
+    return m_conv->WC2MB( outputBuf, psz, outputSize );

 }
 
 }
 

+#endif
+

 // ----------------------------------------------------------------------------
 // ----------------------------------------------------------------------------

-// UTF-7 
+// UTF-7

 // ----------------------------------------------------------------------------
 
 // Implementation (C) 2004 Fredrik Roubert
 // ----------------------------------------------------------------------------
 
 // Implementation (C) 2004 Fredrik Roubert


@@ -545,7 +544,7 @@ size_t wxMBConvUTF7::WC2MB(char *buf, const wchar_t *psz, size_t n) const
         }
 #ifndef WC_UTF16
         else if (((wxUint32)cc) > 0xffff)
         }
 #ifndef WC_UTF16
         else if (((wxUint32)cc) > 0xffff)

-           {
+        {

             // no surrogate pair generation (yet?)
             return (size_t)-1;
         }
             // no surrogate pair generation (yet?)
             return (size_t)-1;
         }


@@ -602,12 +601,19 @@ size_t wxMBConvUTF7::WC2MB(char *buf, const wchar_t *psz, size_t n) const
 static wxUint32 utf8_max[]=
     { 0x7f, 0x7ff, 0xffff, 0x1fffff, 0x3ffffff, 0x7fffffff, 0xffffffff };
 
 static wxUint32 utf8_max[]=
     { 0x7f, 0x7ff, 0xffff, 0x1fffff, 0x3ffffff, 0x7fffffff, 0xffffffff };
 

+// boundaries of the private use area we use to (temporarily) remap invalid
+// characters invalid in a UTF-8 encoded string
+const wxUint32 wxUnicodePUA = 0x100000;
+const wxUint32 wxUnicodePUAEnd = wxUnicodePUA + 256;
+

 size_t wxMBConvUTF8::MB2WC(wchar_t *buf, const char *psz, size_t n) const
 {
     size_t len = 0;
 
     while (*psz && ((!buf) || (len < n)))
     {
 size_t wxMBConvUTF8::MB2WC(wchar_t *buf, const char *psz, size_t n) const
 {
     size_t len = 0;
 
     while (*psz && ((!buf) || (len < n)))
     {

+        const char *opsz = psz;
+        bool invalid = false;

         unsigned char cc = *psz++, fc = cc;
         unsigned cnt;
         for (cnt = 0; fc & 0x80; cnt++)
         unsigned char cc = *psz++, fc = cc;
         unsigned cnt;
         for (cnt = 0; fc & 0x80; cnt++)


@@ -618,6 +624,15 @@ size_t wxMBConvUTF8::MB2WC(wchar_t *buf, const char *psz, size_t n) const
             if (buf)
                 *buf++ = cc;
             len++;
             if (buf)
                 *buf++ = cc;
             len++;

+
+            // escape the escape character for octal escapes
+            if ((m_options & MAP_INVALID_UTF8_TO_OCTAL)
+                    && cc == '\\' && (!buf || len < n))
+            {
+                if (buf)
+                    *buf++ = cc;
+                len++;
+            }

         }
         else
         {
         }
         else
         {


@@ -625,7 +640,7 @@ size_t wxMBConvUTF8::MB2WC(wchar_t *buf, const char *psz, size_t n) const
             if (!cnt)
             {
                 // invalid UTF-8 sequence
             if (!cnt)
             {
                 // invalid UTF-8 sequence

-                return (size_t)-1;
+                invalid = true;

             }
             else
             {
             }
             else
             {


@@ -633,32 +648,93 @@ size_t wxMBConvUTF8::MB2WC(wchar_t *buf, const char *psz, size_t n) const
                 wxUint32 res = cc & (0x3f >> cnt);
                 while (cnt--)
                 {
                 wxUint32 res = cc & (0x3f >> cnt);
                 while (cnt--)
                 {

-                    cc = *psz++;
+                    cc = *psz;

                     if ((cc & 0xC0) != 0x80)
                     {
                         // invalid UTF-8 sequence
                     if ((cc & 0xC0) != 0x80)
                     {
                         // invalid UTF-8 sequence

-                        return (size_t)-1;
+                        invalid = true;
+                        break;

                     }
                     }

+                    psz++;

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

-                if (res <= utf8_max[ocnt])
+                if (invalid || res <= utf8_max[ocnt])

                 {
                     // illegal UTF-8 encoding
                 {
                     // illegal UTF-8 encoding

-                    return (size_t)-1;
+                    invalid = true;

                 }
                 }

+                else if ((m_options & MAP_INVALID_UTF8_TO_PUA) &&
+                        res >= wxUnicodePUA && res < wxUnicodePUAEnd)
+                {
+                    // if one of our PUA characters turns up externally
+                    // it must also be treated as an illegal sequence
+                    // (a bit like you have to escape an escape character)
+                    invalid = true;
+                }
+                else
+                {

 #ifdef WC_UTF16
 #ifdef WC_UTF16

-                // cast is ok because wchar_t == wxUuint16 if WC_UTF16
-                size_t pa = encode_utf16(res, (wxUint16 *)buf);
-                if (pa == (size_t)-1)
-                  return (size_t)-1;
-                if (buf)
-                    buf += pa;
-                len += pa;
+                    // cast is ok because wchar_t == wxUuint16 if WC_UTF16
+                    size_t pa = encode_utf16(res, (wxUint16 *)buf);
+                    if (pa == (size_t)-1)
+                    {
+                        invalid = true;
+                    }
+                    else
+                    {
+                        if (buf)
+                            buf += pa;
+                        len += pa;
+                    }

 #else // !WC_UTF16
 #else // !WC_UTF16

-                if (buf)
-                    *buf++ = res;
-                len++;
+                    if (buf)
+                        *buf++ = res;
+                    len++;

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

+                }
+            }
+            if (invalid)
+            {
+                if (m_options & MAP_INVALID_UTF8_TO_PUA)
+                {
+                    while (opsz < psz && (!buf || len < n))
+                    {
+#ifdef WC_UTF16
+                        // cast is ok because wchar_t == wxUuint16 if WC_UTF16
+                        size_t pa = encode_utf16((unsigned char)*opsz + wxUnicodePUA, (wxUint16 *)buf);
+                        wxASSERT(pa != (size_t)-1);
+                        if (buf)
+                            buf += pa;
+                        opsz++;
+                        len += pa;
+#else
+                        if (buf)
+                            *buf++ = wxUnicodePUA + (unsigned char)*opsz;
+                        opsz++;
+                        len++;
+#endif
+                    }
+                }
+                else if (m_options & MAP_INVALID_UTF8_TO_OCTAL)
+                {
+                    while (opsz < psz && (!buf || len < n))
+                    {
+                        if ( buf && len + 3 < n )
+                        {
+                            unsigned char n = *opsz;
+                            *buf++ = L'\\';
+                            *buf++ = (wchar_t)( L'0' + n / 0100 );
+                            *buf++ = (wchar_t)( L'0' + (n % 0100) / 010 );
+                            *buf++ = (wchar_t)( L'0' + n % 010 );
+                        }
+                        opsz++;
+                        len += 4;
+                    }
+                }
+                else // MAP_INVALID_UTF8_NOT
+                {
+                    return (size_t)-1;
+                }

             }
         }
     }
             }
         }
     }


@@ -667,6 +743,11 @@ size_t wxMBConvUTF8::MB2WC(wchar_t *buf, const char *psz, size_t n) const
     return len;
 }
 
     return len;
 }
 

+static inline bool isoctal(wchar_t wch)
+{
+    return L'0' <= wch && wch <= L'7';
+}
+

 size_t wxMBConvUTF8::WC2MB(char *buf, const wchar_t *psz, size_t n) const
 {
     size_t len = 0;
 size_t wxMBConvUTF8::WC2MB(char *buf, const wchar_t *psz, size_t n) const
 {
     size_t len = 0;


@@ -681,36 +762,67 @@ size_t wxMBConvUTF8::WC2MB(char *buf, const wchar_t *psz, size_t n) const
 #else
         cc=(*psz++) & 0x7fffffff;
 #endif
 #else
         cc=(*psz++) & 0x7fffffff;
 #endif

-        unsigned cnt;
-        for (cnt = 0; cc > utf8_max[cnt]; cnt++) {}
-        if (!cnt)
+
+        if ( (m_options & MAP_INVALID_UTF8_TO_PUA)
+                && cc >= wxUnicodePUA && cc < wxUnicodePUAEnd )

         {
         {

-            // plain ASCII char

             if (buf)
             if (buf)

-                *buf++ = (char) cc;
+                *buf++ = (char)(cc - wxUnicodePUA);

             len++;
         }
             len++;
         }

+        else if ( (m_options & MAP_INVALID_UTF8_TO_OCTAL)
+                    && cc == L'\\' && psz[0] == L'\\' )
+        {
+            if (buf)
+                *buf++ = (char)cc;
+            psz++;
+            len++;
+        }
+        else if ( (m_options & MAP_INVALID_UTF8_TO_OCTAL) &&
+                    cc == L'\\' &&
+                        isoctal(psz[0]) && isoctal(psz[1]) && isoctal(psz[2]) )
+        {
+            if (buf)
+            {
+                *buf++ = (char) ((psz[0] - L'0')*0100 +
+                                 (psz[1] - L'0')*010 +
+                                 (psz[2] - L'0'));
+            }

 
 

+            psz += 3;
+            len++;
+        }

         else
         {
         else
         {

-            len += cnt + 1;
-            if (buf)
+            unsigned cnt;
+            for (cnt = 0; cc > utf8_max[cnt]; cnt++) {}
+            if (!cnt)

             {
             {

-                *buf++ = (char) ((-128 >> cnt) | ((cc >> (cnt * 6)) & (0x3f >> cnt)));
-                while (cnt--)
-                    *buf++ = (char) (0x80 | ((cc >> (cnt * 6)) & 0x3f));
+                // plain ASCII char
+                if (buf)
+                    *buf++ = (char) cc;
+                len++;
+            }
+
+            else
+            {
+                len += cnt + 1;
+                if (buf)
+                {
+                    *buf++ = (char) ((-128 >> cnt) | ((cc >> (cnt * 6)) & (0x3f >> cnt)));
+                    while (cnt--)
+                        *buf++ = (char) (0x80 | ((cc >> (cnt * 6)) & 0x3f));
+                }

             }
         }
     }
 
             }
         }
     }
 

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

 
     return len;
 }
 
 
     return len;
 }
 

-
-
-

 // ----------------------------------------------------------------------------
 // UTF-16
 // ----------------------------------------------------------------------------
 // ----------------------------------------------------------------------------
 // UTF-16
 // ----------------------------------------------------------------------------


@@ -1344,7 +1456,7 @@ size_t wxMBConv_iconv::MB2WC(wchar_t *buf, const char *psz, size_t n) const
     //     as MB<->WC conversion would fail "randomly".
     wxMutexLocker lock(wxConstCast(this, wxMBConv_iconv)->m_iconvMutex);
 #endif
     //     as MB<->WC conversion would fail "randomly".
     wxMutexLocker lock(wxConstCast(this, wxMBConv_iconv)->m_iconvMutex);
 #endif

- 
+

     size_t inbuf = strlen(psz);
     size_t outbuf = n * SIZEOF_WCHAR_T;
     size_t res, cres;
     size_t inbuf = strlen(psz);
     size_t outbuf = n * SIZEOF_WCHAR_T;
     size_t res, cres;


@@ -1406,7 +1518,7 @@ size_t wxMBConv_iconv::WC2MB(char *buf, const wchar_t *psz, size_t n) const
     // NB: explained in MB2WC
     wxMutexLocker lock(wxConstCast(this, wxMBConv_iconv)->m_iconvMutex);
 #endif
     // NB: explained in MB2WC
     wxMutexLocker lock(wxConstCast(this, wxMBConv_iconv)->m_iconvMutex);
 #endif

-    
+

     size_t inbuf = wxWcslen(psz) * SIZEOF_WCHAR_T;
     size_t outbuf = n;
     size_t res, cres;
     size_t inbuf = wxWcslen(psz) * SIZEOF_WCHAR_T;
     size_t outbuf = n;
     size_t res, cres;


@@ -1979,9 +2091,9 @@ public:
 #if SIZEOF_WCHAR_T == 4
         UniChar* szUniCharBuffer = new UniChar[nOutSize];
 #endif
 #if SIZEOF_WCHAR_T == 4
         UniChar* szUniCharBuffer = new UniChar[nOutSize];
 #endif

- 
+

         CFStringGetCharacters(theString, theRange, szUniCharBuffer);
         CFStringGetCharacters(theString, theRange, szUniCharBuffer);

-        
+

         CFRelease(theString);
 
         szUniCharBuffer[nOutLength] = '\0' ;
         CFRelease(theString);
 
         szUniCharBuffer[nOutLength] = '\0' ;


@@ -1991,20 +2103,20 @@ public:
         converter.MB2WC(szOut, (const char*)szUniCharBuffer , nOutSize ) ;
         delete[] szUniCharBuffer;
 #endif
         converter.MB2WC(szOut, (const char*)szUniCharBuffer , nOutSize ) ;
         delete[] szUniCharBuffer;
 #endif

-    
+

         return nOutLength;
     }
 
     size_t WC2MB(char *szOut, const wchar_t *szUnConv, size_t nOutSize) const
     {
         wxASSERT(szUnConv);
         return nOutLength;
     }
 
     size_t WC2MB(char *szOut, const wchar_t *szUnConv, size_t nOutSize) const
     {
         wxASSERT(szUnConv);

-        
+

         size_t nRealOutSize;
         size_t nBufSize = wxWcslen(szUnConv);
         UniChar* szUniBuffer = (UniChar*) szUnConv;
 
 #if SIZEOF_WCHAR_T == 4
         size_t nRealOutSize;
         size_t nBufSize = wxWcslen(szUnConv);
         UniChar* szUniBuffer = (UniChar*) szUnConv;
 
 #if SIZEOF_WCHAR_T == 4

-        wxMBConvUTF16BE converter ;
+        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)) ;


@@ -2026,7 +2138,7 @@ public:
         {
             if (szOut != NULL)
                 CFStringGetCharacters(theString, CFRangeMake(0, nOutSize - 1), (UniChar*) szOut);
         {
             if (szOut != NULL)
                 CFStringGetCharacters(theString, CFRangeMake(0, nOutSize - 1), (UniChar*) szOut);

-            
+

             nRealOutSize = CFStringGetLength(theString) + 1;
         }
         else
             nRealOutSize = CFStringGetLength(theString) + 1;
         }
         else


@@ -2039,7 +2151,7 @@ public:
                     //0 tells CFString to return NULL if it meets such a character
                 false, //not an external representation
                 (UInt8*) szOut,
                     //0 tells CFString to return NULL if it meets such a character
                 false, //not an external representation
                 (UInt8*) szOut,

-                nOutSize, 
+                nOutSize,

                 (CFIndex*) &nRealOutSize
                         );
         }
                 (CFIndex*) &nRealOutSize
                         );
         }


@@ -2055,7 +2167,7 @@ public:
 
     bool IsOk() const
     {
 
     bool IsOk() const
     {

-        return m_encoding != kCFStringEncodingInvalidId && 
+        return m_encoding != kCFStringEncodingInvalidId &&

               CFStringIsEncodingAvailable(m_encoding);
     }
 
               CFStringIsEncodingAvailable(m_encoding);
     }
 


@@ -2140,7 +2252,7 @@ public:
         // 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 ;
         // 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 ;

-        wxMBConvUTF16BE converter ;
+        wxMBConvUTF16 converter ;

         res = converter.MB2WC( (buf ? buf : tbuf) , (const char*)ubuf , n ) ;
         free( ubuf ) ;
 #else
         res = converter.MB2WC( (buf ? buf : tbuf) , (const char*)ubuf , n ) ;
         free( ubuf ) ;
 #else


@@ -2173,7 +2285,7 @@ public:
         ByteCount byteBufferLen = n ;
         UniChar* ubuf = NULL ;
 #if SIZEOF_WCHAR_T == 4
         ByteCount byteBufferLen = n ;
         UniChar* ubuf = NULL ;
 #if SIZEOF_WCHAR_T == 4

-        wxMBConvUTF16BE converter ;
+        wxMBConvUTF16 converter ;

         size_t unicharlen = converter.WC2MB( NULL , psz , 0 ) ;
         byteInLen = unicharlen ;
         ubuf = (UniChar*) malloc( byteInLen + 2 ) ;
         size_t unicharlen = converter.WC2MB( NULL , psz , 0 ) ;
         byteInLen = unicharlen ;
         ubuf = (UniChar*) malloc( byteInLen + 2 ) ;


@@ -2193,7 +2305,7 @@ public:
         if ( buf  && res < n)
         {
             buf[res] = 0;
         if ( buf  && res < n)
         {
             buf[res] = 0;

-            
+

             //we need to double-trip to verify it didn't insert any ? in place
             //of bogus characters
             wxWCharBuffer wcBuf(n);
             //we need to double-trip to verify it didn't insert any ? in place
             //of bogus characters
             wxWCharBuffer wcBuf(n);


@@ -2432,7 +2544,7 @@ wxMBConv *wxCSConv::DoCreate() const
 #if defined(__WXMAC__)
     {
         // leave UTF16 and UTF32 to the built-ins of wx
 #if defined(__WXMAC__)
     {
         // leave UTF16 and UTF32 to the built-ins of wx

-        if ( m_name || ( m_encoding < wxFONTENCODING_UTF16BE || 
+        if ( m_name || ( m_encoding < wxFONTENCODING_UTF16BE ||

             ( m_encoding >= wxFONTENCODING_MACMIN && m_encoding <= wxFONTENCODING_MACMAX ) ) )
         {
 
             ( m_encoding >= wxFONTENCODING_MACMIN && m_encoding <= wxFONTENCODING_MACMAX ) ) )
         {
 


@@ -2636,9 +2748,9 @@ WXDLLIMPEXP_DATA_BASE(wxMBConvUTF8&) wxConvUTF8 = wxConvUTF8Obj;
 WXDLLIMPEXP_DATA_BASE(wxMBConv *) wxConvCurrent = &wxConvLibcObj;
 WXDLLIMPEXP_DATA_BASE(wxMBConv *) wxConvFileName = &
 #ifdef __WXOSX__
 WXDLLIMPEXP_DATA_BASE(wxMBConv *) wxConvCurrent = &wxConvLibcObj;
 WXDLLIMPEXP_DATA_BASE(wxMBConv *) wxConvFileName = &
 #ifdef __WXOSX__

-                                                    wxConvUTF8Obj;
+                                    wxConvUTF8Obj;

 #else
 #else

-                                                    wxConvLibcObj;
+                                    wxConvLibcObj;

 #endif
 
 
 #endif