reSWIGged

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

diff --git a/src/common/strconv.cpp b/src/common/strconv.cpp
index 4c9d38cf1927787fbb33746e3f9c6cad059a77fc..dd806d2c1c4fd60a683c4ad45ee5f9293e844cc9 100644 (file)
--- a/src/common/strconv.cpp
+++ b/src/common/strconv.cpp
@@ -34,6 +34,10 @@
     #include "wx/log.h"
 #endif // WX_PRECOMP
 
     #include "wx/log.h"
 #endif // WX_PRECOMP
 

+#include "wx/strconv.h"
+
+#if wxUSE_WCHAR_T
+

 #ifdef __WXMSW__
     #include "wx/msw/private.h"
 #endif
 #ifdef __WXMSW__
     #include "wx/msw/private.h"
 #endif


@@ -46,57 +50,14 @@
 #include <string.h>
 #include <stdlib.h>
 
 #include <string.h>
 #include <stdlib.h>
 

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

 #if defined(__WIN32__) && !defined(__WXMICROWIN__)
     #define wxHAVE_WIN32_MB2WC
 #endif // __WIN32__ but !__WXMICROWIN__
 
 #if defined(__WIN32__) && !defined(__WXMICROWIN__)
     #define wxHAVE_WIN32_MB2WC
 #endif // __WIN32__ but !__WXMICROWIN__
 

-// ----------------------------------------------------------------------------
-// globals
-// ----------------------------------------------------------------------------
-
-#if wxUSE_WCHAR_T
-    WXDLLIMPEXP_DATA_BASE(wxMBConv) wxConvLibc;
-    WXDLLIMPEXP_DATA_BASE(wxCSConv) wxConvLocal((const wxChar *)NULL);
-    WXDLLIMPEXP_DATA_BASE(wxCSConv) wxConvISO8859_1(_T("iso-8859-1"));
-#else
-    // stand-ins in absence of wchar_t
-    WXDLLIMPEXP_DATA_BASE(wxMBConv) wxConvLibc,
-                                    wxConvFile,
-                                    wxConvISO8859_1,
-                                    wxConvLocal,
-                                    wxConvUTF8;
-#endif // wxUSE_WCHAR_T
-
-WXDLLIMPEXP_DATA_BASE(wxMBConv *) wxConvCurrent = &wxConvLibc;
-
-class wxStrConvModule: public wxModule
-{
-public:
-    wxStrConvModule() : wxModule() { }
-    virtual bool OnInit() { return true; }
-    virtual void OnExit()
-    {
-#if wxUSE_WCHAR_T
-         wxConvLocal.Clear();
-         wxConvISO8859_1.Clear();
-#endif
-    }
-
-    DECLARE_DYNAMIC_CLASS(wxStrConvModule)
-};
-
-IMPLEMENT_DYNAMIC_CLASS(wxStrConvModule, wxModule)
-
-

 // ----------------------------------------------------------------------------
 // headers
 // ----------------------------------------------------------------------------
 
 // ----------------------------------------------------------------------------
 // headers
 // ----------------------------------------------------------------------------
 

-#if wxUSE_WCHAR_T
-

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


@@ -115,12 +76,6 @@ IMPLEMENT_DYNAMIC_CLASS(wxStrConvModule, wxModule)
 #define BSWAP_UCS4(str, len) { unsigned _c; for (_c=0; _c<len; _c++) str[_c]=wxUINT32_SWAP_ALWAYS(str[_c]); }
 #define BSWAP_UTF16(str, len) { unsigned _c; for (_c=0; _c<len; _c++) str[_c]=wxUINT16_SWAP_ALWAYS(str[_c]); }
 
 #define BSWAP_UCS4(str, len) { unsigned _c; for (_c=0; _c<len; _c++) str[_c]=wxUINT32_SWAP_ALWAYS(str[_c]); }
 #define BSWAP_UTF16(str, len) { unsigned _c; for (_c=0; _c<len; _c++) str[_c]=wxUINT16_SWAP_ALWAYS(str[_c]); }
 

-// under Unix SIZEOF_WCHAR_T is defined by configure, but under other platforms
-// it might be not defined - assume the most common value
-#ifndef SIZEOF_WCHAR_T
-    #define SIZEOF_WCHAR_T 2
-#endif // !defined(SIZEOF_WCHAR_T)
-

 #if SIZEOF_WCHAR_T == 4
     #define WC_NAME         "UCS4"
     #define WC_BSWAP         BSWAP_UCS4
 #if SIZEOF_WCHAR_T == 4
     #define WC_NAME         "UCS4"
     #define WC_BSWAP         BSWAP_UCS4


@@ -139,8 +94,8 @@ IMPLEMENT_DYNAMIC_CLASS(wxStrConvModule, wxModule)
       #define WC_NAME_BEST  "UTF-16LE"
     #endif
 #else // sizeof(wchar_t) != 2 nor 4
       #define WC_NAME_BEST  "UTF-16LE"
     #endif
 #else // sizeof(wchar_t) != 2 nor 4

-    // I don't know what to do about this
-    #error "Weird sizeof(wchar_t): please report your platform details to wx-users mailing list"
+    // does this ever happen?
+    #error "Unknown sizeof(wchar_t): please report this to wx-dev@lists.wxwindows.org"

 #endif
 
 // ============================================================================
 #endif
 
 // ============================================================================


@@ -156,7 +111,8 @@ 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;
     }
     else if (input>=0x110000)
         return 1;
     }
     else if (input>=0x110000)


@@ -168,7 +124,7 @@ static size_t encode_utf16(wxUint32 input, wxUint16 *output)
         if (output)
         {
             *output++ = (wxUint16) ((input >> 10)+0xd7c0);
         if (output)
         {
             *output++ = (wxUint16) ((input >> 10)+0xd7c0);

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

         }
         return 2;
     }
         }
         return 2;
     }


@@ -198,49 +154,11 @@ static size_t decode_utf16(const wxUint16* input, wxUint32& output)
 // wxMBConv
 // ----------------------------------------------------------------------------
 
 // wxMBConv
 // ----------------------------------------------------------------------------
 

-#define IGNORE_LIBC 0
-

 wxMBConv::~wxMBConv()
 {
     // nothing to do here
 }
 
 wxMBConv::~wxMBConv()
 {
     // nothing to do here
 }
 

-size_t wxMBConv::MB2WC(wchar_t *buf, const char *psz, size_t n) const
-{
-#if IGNORE_LIBC
-    if (buf)
-    {
-        for (size_t i = 0; i < strlen( psz )+1; i++)
-            buf[i] = (wchar_t) psz[i];
-        return strlen( psz );
-    }
-    else
-    {
-        return strlen( psz );
-    }
-#else
-    return wxMB2WC(buf, psz, n);
-#endif
-}
-
-size_t wxMBConv::WC2MB(char *buf, const wchar_t *psz, size_t n) const
-{
-#if IGNORE_LIBC
-    if (buf)
-    {
-        for (size_t i = 0; i < wxStrlen( psz )+1; i++)
-            buf[i] = (char) psz[i];
-        return wxStrlen( psz );
-    }
-    else
-    {
-        return wxStrlen( psz );
-    }
-#else
-    return wxWC2MB(buf, psz, n);
-#endif
-}
-

 const wxWCharBuffer wxMBConv::cMB2WC(const char *psz) const
 {
     if ( psz )
 const wxWCharBuffer wxMBConv::cMB2WC(const char *psz) const
 {
     if ( psz )


@@ -282,10 +200,22 @@ const wxCharBuffer wxMBConv::cWC2MB(const wchar_t *pwz) const
 }
 
 // ----------------------------------------------------------------------------
 }
 
 // ----------------------------------------------------------------------------

-// UTF-7
+// wxMBConvLibc

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

-WXDLLIMPEXP_DATA_BASE(wxMBConvUTF7) wxConvUTF7;
+size_t wxMBConvLibc::MB2WC(wchar_t *buf, const char *psz, size_t n) const
+{
+    return wxMB2WC(buf, psz, n);
+}
+
+size_t wxMBConvLibc::WC2MB(char *buf, const wchar_t *psz, size_t n) const
+{
+    return wxWC2MB(buf, psz, n);
+}
+
+// ----------------------------------------------------------------------------
+// UTF-7
+// ----------------------------------------------------------------------------

 
 #if 0
 static char utf7_setD[]="ABCDEFGHIJKLMNOPQRSTUVWXYZ"
 
 #if 0
 static char utf7_setD[]="ABCDEFGHIJKLMNOPQRSTUVWXYZ"


@@ -316,8 +246,6 @@ size_t wxMBConvUTF7::WC2MB(char * WXUNUSED(buf),
 // UTF-8
 // ----------------------------------------------------------------------------
 
 // UTF-8
 // ----------------------------------------------------------------------------
 

-WXDLLIMPEXP_DATA_BASE(wxMBConvUTF8) wxConvUTF8;
-

 static wxUint32 utf8_max[]=
     { 0x7f, 0x7ff, 0xffff, 0x1fffff, 0x3ffffff, 0x7fffffff, 0xffffffff };
 
 static wxUint32 utf8_max[]=
     { 0x7f, 0x7ff, 0xffff, 0x1fffff, 0x3ffffff, 0x7fffffff, 0xffffffff };
 


@@ -366,7 +294,8 @@ size_t wxMBConvUTF8::MB2WC(wchar_t *buf, const char *psz, size_t n) const
                     return (size_t)-1;
                 }
 #ifdef WC_UTF16
                     return (size_t)-1;
                 }
 #ifdef WC_UTF16

-                size_t pa = encode_utf16(res, buf);
+                // 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)
                 if (pa == (size_t)-1)
                   return (size_t)-1;
                 if (buf)


@@ -393,7 +322,8 @@ size_t wxMBConvUTF8::WC2MB(char *buf, const wchar_t *psz, size_t n) const
     {
         wxUint32 cc;
 #ifdef WC_UTF16
     {
         wxUint32 cc;
 #ifdef WC_UTF16

-        size_t pa = decode_utf16(psz, cc);
+        // cast is ok for WC_UTF16
+        size_t pa = decode_utf16((const wxUint16 *)psz, cc);

         psz += (pa == (size_t)-1) ? 1 : pa;
 #else
         cc=(*psz++) & 0x7fffffff;
         psz += (pa == (size_t)-1) ? 1 : pa;
 #else
         cc=(*psz++) & 0x7fffffff;


@@ -433,24 +363,16 @@ size_t wxMBConvUTF8::WC2MB(char *buf, const wchar_t *psz, size_t n) const
 // ----------------------------------------------------------------------------
 
 #ifdef WORDS_BIGENDIAN
 // ----------------------------------------------------------------------------
 
 #ifdef WORDS_BIGENDIAN

-#define wxMBConvUTF16straight wxMBConvUTF16BE
-#define wxMBConvUTF16swap     wxMBConvUTF16LE
+    #define wxMBConvUTF16straight wxMBConvUTF16BE
+    #define wxMBConvUTF16swap     wxMBConvUTF16LE

 #else
 #else

-#define wxMBConvUTF16swap     wxMBConvUTF16BE
-#define wxMBConvUTF16straight wxMBConvUTF16LE
+    #define wxMBConvUTF16swap     wxMBConvUTF16BE
+    #define wxMBConvUTF16straight wxMBConvUTF16LE

 #endif
 
 
 #endif
 
 

-WXDLLIMPEXP_DATA_BASE(wxMBConvUTF16LE) wxConvUTF16LE;
-WXDLLIMPEXP_DATA_BASE(wxMBConvUTF16BE) wxConvUTF16BE;
-
-
-
-
-

 #ifdef WC_UTF16
 
 #ifdef WC_UTF16
 

-

 // copy 16bit MB to 16bit String
 size_t wxMBConvUTF16straight::MB2WC(wchar_t *buf, const char *psz, size_t n) const
 {
 // copy 16bit MB to 16bit String
 size_t wxMBConvUTF16straight::MB2WC(wchar_t *buf, const char *psz, size_t n) const
 {


@@ -576,7 +498,7 @@ size_t wxMBConvUTF16straight::WC2MB(char *buf, const wchar_t *psz, size_t n) con
         if (buf)
         {
             *(wxUint16*)buf = cc[0];
         if (buf)
         {
             *(wxUint16*)buf = cc[0];

-            buf += sizeof(wxUint16); 
+            buf += sizeof(wxUint16);

             if (pa > 1)
             {
                 *(wxUint16*)buf = cc[1];
             if (pa > 1)
             {
                 *(wxUint16*)buf = cc[1];


@@ -712,7 +634,8 @@ size_t wxMBConvUTF32straight::WC2MB(char *buf, const wchar_t *psz, size_t n) con
     {
         wxUint32 cc;
 
     {
         wxUint32 cc;
 

-        size_t pa=decode_utf16(psz, cc);
+        // cast is ok for WC_UTF16
+        size_t pa = decode_utf16((const wxUint16 *)psz, cc);

         if (pa == (size_t)-1)
             return pa;
 
         if (pa == (size_t)-1)
             return pa;
 


@@ -724,7 +647,9 @@ size_t wxMBConvUTF32straight::WC2MB(char *buf, const wchar_t *psz, size_t n) con
         len += sizeof(wxUint32);
         psz += pa;
     }
         len += sizeof(wxUint32);
         psz += pa;
     }

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

 
     return len;
 }
 
     return len;
 }


@@ -758,7 +683,9 @@ size_t wxMBConvUTF32swap::MB2WC(wchar_t *buf, const char *psz, size_t n) const
         len += pa;
         psz += sizeof(wxUint32);
     }
         len += pa;
         psz += sizeof(wxUint32);
     }

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

 
     return len;
 }
 
     return len;
 }


@@ -773,7 +700,8 @@ size_t wxMBConvUTF32swap::WC2MB(char *buf, const wchar_t *psz, size_t n) const
     {
         char cc[4];
 
     {
         char cc[4];
 

-        size_t pa=decode_utf16(psz, *(wxUint32*)cc);
+        // cast is ok for WC_UTF16
+        size_t pa=decode_utf16((const wxUint16 *)psz, *(wxUint32*)cc);

         if (pa == (size_t)-1)
             return pa;
 
         if (pa == (size_t)-1)
             return pa;
 


@@ -787,7 +715,9 @@ size_t wxMBConvUTF32swap::WC2MB(char *buf, const wchar_t *psz, size_t n) const
         len += sizeof(wxUint32);
         psz += pa;
     }
         len += sizeof(wxUint32);
         psz += pa;
     }

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

 
     return len;
 }
 
     return len;
 }


@@ -807,7 +737,9 @@ size_t wxMBConvUTF32straight::MB2WC(wchar_t *buf, const char *psz, size_t n) con
         len++;
         psz += sizeof(wxUint32);
     }
         len++;
         psz += sizeof(wxUint32);
     }

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

 
     return len;
 }
 
     return len;
 }


@@ -830,7 +762,8 @@ size_t wxMBConvUTF32straight::WC2MB(char *buf, const wchar_t *psz, size_t n) con
         psz++;
     }
 
         psz++;
     }
 

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

 
     return len;
 }
 
     return len;
 }


@@ -854,7 +787,9 @@ size_t wxMBConvUTF32swap::MB2WC(wchar_t *buf, const char *psz, size_t n) const
         len++;
         psz += sizeof(wxUint32);
     }
         len++;
         psz += sizeof(wxUint32);
     }

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

 
     return len;
 }
 
     return len;
 }


@@ -877,7 +812,9 @@ size_t wxMBConvUTF32swap::WC2MB(char *buf, const wchar_t *psz, size_t n) const
         len += sizeof(wxUint32);
         psz++;
     }
         len += sizeof(wxUint32);
         psz++;
     }

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

 
     return len;
 }
 
     return len;
 }


@@ -918,8 +855,8 @@ public:
     wxMBConv_iconv(const wxChar *name);
     virtual ~wxMBConv_iconv();
 
     wxMBConv_iconv(const wxChar *name);
     virtual ~wxMBConv_iconv();
 

-    virtual size_t MB2WC(wchar_t *buf, const char *psz, size_t n);
-    virtual size_t WC2MB(char *buf, const wchar_t *psz, size_t n);
+    virtual size_t MB2WC(wchar_t *buf, const char *psz, size_t n) const;
+    virtual size_t WC2MB(char *buf, const wchar_t *psz, size_t n) const;

 
     bool IsOk() const
         { return (m2w != (iconv_t)-1) && (w2m != (iconv_t)-1); }
 
     bool IsOk() const
         { return (m2w != (iconv_t)-1) && (w2m != (iconv_t)-1); }


@@ -1038,7 +975,7 @@ wxMBConv_iconv::~wxMBConv_iconv()
         iconv_close(w2m);
 }
 
         iconv_close(w2m);
 }
 

-size_t wxMBConv_iconv::MB2WC(wchar_t *buf, const char *psz, size_t n)
+size_t wxMBConv_iconv::MB2WC(wchar_t *buf, const char *psz, size_t n) const

 {
     size_t inbuf = strlen(psz);
     size_t outbuf = n * SIZEOF_WCHAR_T;
 {
     size_t inbuf = strlen(psz);
     size_t outbuf = n * SIZEOF_WCHAR_T;


@@ -1095,7 +1032,7 @@ size_t wxMBConv_iconv::MB2WC(wchar_t *buf, const char *psz, size_t n)
     return res;
 }
 
     return res;
 }
 

-size_t wxMBConv_iconv::WC2MB(char *buf, const wchar_t *psz, size_t n)
+size_t wxMBConv_iconv::WC2MB(char *buf, const wchar_t *psz, size_t n) const

 {
     size_t inbuf = wxWcslen(psz) * SIZEOF_WCHAR_T;
     size_t outbuf = n;
 {
     size_t inbuf = wxWcslen(psz) * SIZEOF_WCHAR_T;
     size_t outbuf = n;


@@ -1174,17 +1111,22 @@ extern WXDLLIMPEXP_BASE long wxEncodingToCodepage(wxFontEncoding encoding);
 class wxMBConv_win32 : public wxMBConv
 {
 public:
 class wxMBConv_win32 : public wxMBConv
 {
 public:

+    wxMBConv_win32()
+    {
+        m_CodePage = CP_ACP;
+    }
+

     wxMBConv_win32(const wxChar* name)
     wxMBConv_win32(const wxChar* name)

-        {
-            m_CodePage = wxCharsetToCodepage(name);
-        }
+    {
+        m_CodePage = wxCharsetToCodepage(name);
+    }

 
     wxMBConv_win32(wxFontEncoding encoding)
 
     wxMBConv_win32(wxFontEncoding encoding)

-        {
-            m_CodePage = wxEncodingToCodepage(encoding);
-        }
+    {
+        m_CodePage = wxEncodingToCodepage(encoding);
+    }

 
 

-    size_t MB2WC(wchar_t *buf, const char *psz, size_t n)
+    size_t MB2WC(wchar_t *buf, const char *psz, size_t n) const

     {
         const size_t len = ::MultiByteToWideChar
                              (
     {
         const size_t len = ::MultiByteToWideChar
                              (


@@ -1196,12 +1138,13 @@ public:
                                 buf ? n : 0     // size of output buffer
                              );
 
                                 buf ? n : 0     // size of output buffer
                              );
 

-        // note that it returns # of written chars for buf != NULL and *size*
-        // of the needed buffer for buf == NULL
-        return len ? (buf ? len : len - 1) : (size_t)-1;
+        // note that it returns count of written chars for buf != NULL and size
+        // of the needed buffer for buf == NULL so in either case the length of
+        // the string (which never includes the terminating NUL) is one less
+        return len ? len - 1 : (size_t)-1;

     }
 
     }
 

-    size_t WC2MB(char *buf, const wchar_t *psz, size_t n)
+    size_t WC2MB(char *buf, const wchar_t *psz, size_t n) const

     {
         const size_t len = ::WideCharToMultiByte
                              (
     {
         const size_t len = ::WideCharToMultiByte
                              (


@@ -1215,8 +1158,8 @@ public:
                                 NULL            // [out] was it used?
                              );
 
                                 NULL            // [out] was it used?
                              );
 

-        // see the comment above!
-        return len ? (buf ? len : len - 1) : (size_t)-1;
+        // see the comment above for the reason of "len - 1"
+        return len ? len - 1 : (size_t)-1;

     }
 
     bool IsOk() const
     }
 
     bool IsOk() const


@@ -1264,7 +1207,7 @@ public:
         Init();
     }
 
         Init();
     }
 

-    size_t MB2WC(wchar_t *buf, const char *psz, size_t WXUNUSED(n))
+    size_t MB2WC(wchar_t *buf, const char *psz, size_t WXUNUSED(n)) const

     {
         size_t inbuf = strlen(psz);
         if (buf)
     {
         size_t inbuf = strlen(psz);
         if (buf)


@@ -1272,7 +1215,7 @@ public:
         return inbuf;
     }
 
         return inbuf;
     }
 

-    size_t WC2MB(char *buf, const wchar_t *psz, size_t WXUNUSED(n))
+    size_t WC2MB(char *buf, const wchar_t *psz, size_t WXUNUSED(n)) const

     {
         const size_t inbuf = wxWcslen(psz);
         if (buf)
     {
         const size_t inbuf = wxWcslen(psz);
         if (buf)


@@ -1306,37 +1249,21 @@ void wxCSConv::Init()
     m_deferred = true;
 }
 
     m_deferred = true;
 }
 

-// find a valid value for the encoding
-void wxCSConv::SetEncoding()
-{
-#if wxUSE_INTL
-    m_encoding = wxLocale::GetSystemEncoding();
-#else
-    m_encoding = wxFONTENCODING_SYSTEM;
-#endif
-}
-

 wxCSConv::wxCSConv(const wxChar *charset)
 {
     Init();
 
     if ( charset )
     {
 wxCSConv::wxCSConv(const wxChar *charset)
 {
     Init();
 
     if ( charset )
     {

-        // not used
-        m_encoding = wxFONTENCODING_SYSTEM;
-

         SetName(charset);
     }
         SetName(charset);
     }

-    else // no charset specified
-    {
-        SetEncoding();
-    }
+
+    m_encoding = wxFONTENCODING_SYSTEM;

 }
 
 wxCSConv::wxCSConv(wxFontEncoding encoding)
 {
 }
 
 wxCSConv::wxCSConv(wxFontEncoding encoding)
 {

-    if ( encoding == wxFONTENCODING_MAX ||
-            encoding == wxFONTENCODING_DEFAULT )
+    if ( encoding == wxFONTENCODING_MAX || encoding == wxFONTENCODING_DEFAULT )

     {
         wxFAIL_MSG( _T("invalid encoding value in wxCSConv ctor") );
 
     {
         wxFAIL_MSG( _T("invalid encoding value in wxCSConv ctor") );
 


@@ -1345,14 +1272,7 @@ wxCSConv::wxCSConv(wxFontEncoding encoding)
 
     Init();
 
 
     Init();
 

-    if ( encoding == wxFONTENCODING_SYSTEM )
-    {
-        SetEncoding();
-    }
-    else // have valid encoding, use it
-    {
-        m_encoding = encoding;
-    }
+    m_encoding = encoding;

 }
 
 wxCSConv::~wxCSConv()
 }
 
 wxCSConv::~wxCSConv()


@@ -1397,28 +1317,12 @@ void wxCSConv::SetName(const wxChar *charset)
     }
 }
 
     }
 }
 

-static inline bool DoesntNeedConv(wxFontEncoding enc)
-{
-    return enc == wxFONTENCODING_DEFAULT ||
-            enc == wxFONTENCODING_SYSTEM ||
-             enc == wxFONTENCODING_ISO8859_1;
-}
-

 wxMBConv *wxCSConv::DoCreate() const
 {
 wxMBConv *wxCSConv::DoCreate() const
 {

-#if wxUSE_FONTMAP
-    wxFontMapper * const fontMapper = wxFontMapper::Get();
-
-    wxFontEncoding encFromName = m_name ? fontMapper->CharsetToEncoding(m_name)
-                                        : wxFONTENCODING_SYSTEM;
-#endif // wxUSE_FONTMAP
-
-    // check for the special case of ASCII charset
-    if ( (!m_name && DoesntNeedConv(m_encoding))
-#if wxUSE_FONTMAP
-            || (m_name && DoesntNeedConv(encFromName))
-#endif // wxUSE_FONTMAP
-       )
+    // check for the special case of ASCII or ISO8859-1 charset: as we have
+    // special knowledge of it anyhow, we don't need to create a special
+    // conversion object
+    if ( m_encoding == wxFONTENCODING_ISO8859_1 )

     {
         // don't convert at all
         return NULL;
     {
         // don't convert at all
         return NULL;


@@ -1434,9 +1338,18 @@ wxMBConv *wxCSConv::DoCreate() const
 
     // step (1)
 #ifdef HAVE_ICONV
 
     // step (1)
 #ifdef HAVE_ICONV

+#if !wxUSE_FONTMAP

     if ( m_name )
     if ( m_name )

+#endif // !wxUSE_FONTMAP

     {
     {

-        wxMBConv_iconv *conv = new wxMBConv_iconv(m_name);
+        wxString name(m_name);
+
+#if wxUSE_FONTMAP
+        if ( name.empty() )
+            name = wxFontMapper::Get()->GetEncodingName(m_encoding);
+#endif // wxUSE_FONTMAP
+
+        wxMBConv_iconv *conv = new wxMBConv_iconv(name);

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


@@ -1458,8 +1371,13 @@ wxMBConv *wxCSConv::DoCreate() const
     // step (2)
     wxFontEncoding enc = m_encoding;
 #if wxUSE_FONTMAP
     // step (2)
     wxFontEncoding enc = m_encoding;
 #if wxUSE_FONTMAP

-    if ( enc == wxFONTENCODING_SYSTEM )
-        enc = encFromName;
+    if ( enc == wxFONTENCODING_SYSTEM && m_name )
+    {
+        // use "false" to suppress interactive dialogs -- we can be called from
+        // anywhere and popping up a dialog from here is the last thing we want to
+        // do
+        enc = wxFontMapper::Get()->CharsetToEncoding(m_name, false);
+    }

 #endif // wxUSE_FONTMAP
 
     switch ( enc )
 #endif // wxUSE_FONTMAP
 
     switch ( enc )


@@ -1470,18 +1388,12 @@ wxMBConv *wxCSConv::DoCreate() const
         case wxFONTENCODING_UTF8:
              return new wxMBConvUTF8;
 
         case wxFONTENCODING_UTF8:
              return new wxMBConvUTF8;
 

-        case wxFONTENCODING_UTF16:
-             return new wxMBConvUTF16;
-

         case wxFONTENCODING_UTF16BE:
              return new wxMBConvUTF16BE;
 
         case wxFONTENCODING_UTF16LE:
              return new wxMBConvUTF16LE;
 
         case wxFONTENCODING_UTF16BE:
              return new wxMBConvUTF16BE;
 
         case wxFONTENCODING_UTF16LE:
              return new wxMBConvUTF16LE;
 

-        case wxFONTENCODING_UTF32:
-             return new wxMBConvUTF32;
-

         case wxFONTENCODING_UTF32BE:
              return new wxMBConvUTF32BE;
 
         case wxFONTENCODING_UTF32BE:
              return new wxMBConvUTF32BE;
 


@@ -1505,8 +1417,19 @@ wxMBConv *wxCSConv::DoCreate() const
     }
 #endif // wxUSE_FONTMAP
 
     }
 #endif // wxUSE_FONTMAP
 

-    wxLogError(_("Cannot convert from the charset '%s'!"),
-               m_name ? m_name
+    // NB: This is a hack to prevent deadlock. What could otherwise happen
+    //     in Unicode build: wxConvLocal creation ends up being here
+    //     because of some failure and logs the error. But wxLog will try to
+    //     attach timestamp, for which it will need wxConvLocal (to convert
+    //     time to char* and then wchar_t*), but that fails, tries to log
+    //     error, but wxLog has a (already locked) critical section that
+    //     guards static buffer.
+    static bool alreadyLoggingError = false;
+    if (!alreadyLoggingError)
+    {
+        alreadyLoggingError = true;
+        wxLogError(_("Cannot convert from the charset '%s'!"),
+                   m_name ? m_name

                       :
 #if wxUSE_FONTMAP
                          wxFontMapper::GetEncodingDescription(m_encoding).c_str()
                       :
 #if wxUSE_FONTMAP
                          wxFontMapper::GetEncodingDescription(m_encoding).c_str()


@@ -1514,6 +1437,8 @@ 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;
+    }

 
     return NULL;
 }
 
     return NULL;
 }


@@ -1523,6 +1448,16 @@ void wxCSConv::CreateConvIfNeeded() const
     if ( m_deferred )
     {
         wxCSConv *self = (wxCSConv *)this; // const_cast
     if ( m_deferred )
     {
         wxCSConv *self = (wxCSConv *)this; // const_cast

+
+#if wxUSE_INTL
+        // if we don't have neither the name nor the encoding, use the default
+        // encoding for this system
+        if ( !m_name && m_encoding == wxFONTENCODING_SYSTEM )
+        {
+            self->m_name = wxStrdup(wxLocale::GetSystemEncodingName());
+        }
+#endif // wxUSE_INTL
+

         self->m_convReal = DoCreate();
         self->m_deferred = false;
     }
         self->m_convReal = DoCreate();
         self->m_deferred = false;
     }


@@ -1559,12 +1494,55 @@ size_t wxCSConv::WC2MB(char *buf, const wchar_t *psz, size_t n) const
     if (buf)
     {
         for (size_t c = 0; c <= len; c++)
     if (buf)
     {
         for (size_t c = 0; c <= len; c++)

-            buf[c] = (psz[c] > 0xff) ? '?' : psz[c];
+        {
+            if (psz[c] > 0xFF)
+                return (size_t)-1;
+            buf[c] = psz[c];
+        }
+    }
+    else
+    {
+        for (size_t c = 0; c <= len; c++)
+        {
+            if (psz[c] > 0xFF)
+                return (size_t)-1;
+        }

     }
 
     return len;
 }
 
     }
 
     return len;
 }
 

-#endif // wxUSE_WCHAR_T
+// ----------------------------------------------------------------------------
+// globals
+// ----------------------------------------------------------------------------
+
+#ifdef __WINDOWS__
+    static wxMBConv_win32 wxConvLibcObj;
+#else
+    static wxMBConvLibc wxConvLibcObj;
+#endif
+
+static wxCSConv wxConvLocalObj(wxFONTENCODING_SYSTEM);
+static wxCSConv wxConvISO8859_1Obj(wxFONTENCODING_ISO8859_1);
+static wxMBConvUTF7 wxConvUTF7Obj;
+static wxMBConvUTF8 wxConvUTF8Obj;
+
+
+WXDLLIMPEXP_DATA_BASE(wxMBConv&) wxConvLibc = wxConvLibcObj;
+WXDLLIMPEXP_DATA_BASE(wxCSConv&) wxConvLocal = wxConvLocalObj;
+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;
+
+#else // !wxUSE_WCHAR_T
+
+// stand-ins in absence of wchar_t
+WXDLLIMPEXP_DATA_BASE(wxMBConv) wxConvLibc,
+                                wxConvISO8859_1,
+                                wxConvLocal,
+                                wxConvUTF8;
+
+#endif // wxUSE_WCHAR_T/!wxUSE_WCHAR_T