X-Git-Url: https://git.saurik.com/wxWidgets.git/blobdiff_plain/8b04d4c45108c8d70df205ece2690f6729e35b1f..88e3652fd0c13feb4fcd843bd0d1167ab84041c1:/src/common/strconv.cpp?ds=inline

diff --git a/src/common/strconv.cpp b/src/common/strconv.cpp
index f26c3285af..d2c107ecbe 100644
--- a/src/common/strconv.cpp
+++ b/src/common/strconv.cpp
@@ -5,7 +5,8 @@
 // Modified by:
 // Created:     29/01/98
 // RCS-ID:      $Id$
-// Copyright:   (c) 1999 Ove Kaaven, Robert Roebling, Vadim Zeitlin, Vaclav Slavik
+// Copyright:   (c) 1999 Ove Kaaven, Robert Roebling, Vaclav Slavik
+//              (c) 2000-2003 Vadim Zeitlin
 // Licence:     wxWindows licence
 /////////////////////////////////////////////////////////////////////////////
 
@@ -33,6 +34,10 @@
     #include "wx/log.h"
 #endif // WX_PRECOMP
 
+#include "wx/strconv.h"
+
+#if wxUSE_WCHAR_T
+
 #ifdef __WXMSW__
     #include "wx/msw/private.h"
 #endif
@@ -45,53 +50,14 @@
 #include <string.h>
 #include <stdlib.h>
 
-#include "wx/module.h"
-#include "wx/strconv.h"
-
-// ----------------------------------------------------------------------------
-// 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)
-
+#if defined(__WIN32__) && !defined(__WXMICROWIN__)
+    #define wxHAVE_WIN32_MB2WC
+#endif // __WIN32__ but !__WXMICROWIN__
 
 // ----------------------------------------------------------------------------
 // headers
 // ----------------------------------------------------------------------------
 
-#if wxUSE_WCHAR_T
-
 #ifdef __SALFORDC__
     #include <clib.h>
 #endif
@@ -110,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]); }
 
-// 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
@@ -134,8 +94,8 @@ IMPLEMENT_DYNAMIC_CLASS(wxStrConvModule, wxModule)
       #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
 
 // ============================================================================
@@ -143,16 +103,15 @@ IMPLEMENT_DYNAMIC_CLASS(wxStrConvModule, wxModule)
 // ============================================================================
 
 // ----------------------------------------------------------------------------
-// UTF-16 en/decoding
+// UTF-16 en/decoding to/from UCS-4
 // ----------------------------------------------------------------------------
 
-#ifdef WC_UTF16
 
-static size_t encode_utf16(wxUint32 input, wchar_t *output)
+static size_t encode_utf16(wxUint32 input, wxUint16 *output)
 {
     if (input<=0xffff)
     {
-        if (output) *output++ = (wchar_t) input;
+        if (output) *output++ = (wxUint16) input;
         return 1;
     }
     else if (input>=0x110000)
@@ -163,14 +122,14 @@ static size_t encode_utf16(wxUint32 input, wchar_t *output)
     {
         if (output)
         {
-            *output++ = (wchar_t) ((input >> 10)+0xd7c0);
-            *output++ = (wchar_t) ((input&0x3ff)+0xdc00);
+            *output++ = (wxUint16) ((input >> 10)+0xd7c0);
+            *output++ = (wxUint16) ((input&0x3ff)+0xdc00);
         }
         return 2;
     }
 }
 
-static size_t decode_utf16(const wchar_t* input, wxUint32& output)
+static size_t decode_utf16(const wxUint16* input, wxUint32& output)
 {
     if ((*input<0xd800) || (*input>0xdfff))
     {
@@ -189,55 +148,16 @@ static size_t decode_utf16(const wchar_t* input, wxUint32& output)
     }
 }
 
-#endif // WC_UTF16
 
 // ----------------------------------------------------------------------------
 // wxMBConv
 // ----------------------------------------------------------------------------
 
-#define IGNORE_LIBC 0
-
 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 )
@@ -266,8 +186,8 @@ const wxCharBuffer wxMBConv::cWC2MB(const wchar_t *pwz) const
         size_t nLen = WC2MB(NULL, pwz, 0);
         if ( nLen != (size_t)-1 )
         {
-            wxCharBuffer buf(nLen);
-            WC2MB(buf.data(), pwz, nLen + 1);
+            wxCharBuffer buf(nLen+3);       // space for a wxUint32 trailing zero
+            WC2MB(buf.data(), pwz, nLen + 4);
 
             return buf;
         }
@@ -279,10 +199,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"
@@ -313,8 +245,6 @@ size_t wxMBConvUTF7::WC2MB(char * WXUNUSED(buf),
 // UTF-8
 // ----------------------------------------------------------------------------
 
-WXDLLIMPEXP_DATA_BASE(wxMBConvUTF8) wxConvUTF8;
-
 static wxUint32 utf8_max[]=
     { 0x7f, 0x7ff, 0xffff, 0x1fffff, 0x3ffffff, 0x7fffffff, 0xffffffff };
 
@@ -363,7 +293,8 @@ size_t wxMBConvUTF8::MB2WC(wchar_t *buf, const char *psz, size_t n) const
                     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)
@@ -390,7 +321,8 @@ size_t wxMBConvUTF8::WC2MB(char *buf, const wchar_t *psz, size_t n) const
     {
         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;
@@ -422,45 +354,472 @@ size_t wxMBConvUTF8::WC2MB(char *buf, const wchar_t *psz, size_t n) const
     return len;
 }
 
-// ============================================================================
-// wxCharacterSet and derived classes
-// ============================================================================
+
+
 
 // ----------------------------------------------------------------------------
-// wxCharacterSet is the ABC for the classes below
+// UTF-16
 // ----------------------------------------------------------------------------
 
-class wxCharacterSet
+#ifdef WORDS_BIGENDIAN
+    #define wxMBConvUTF16straight wxMBConvUTF16BE
+    #define wxMBConvUTF16swap     wxMBConvUTF16LE
+#else
+    #define wxMBConvUTF16swap     wxMBConvUTF16BE
+    #define wxMBConvUTF16straight wxMBConvUTF16LE
+#endif
+
+
+#ifdef WC_UTF16
+
+// copy 16bit MB to 16bit String
+size_t wxMBConvUTF16straight::MB2WC(wchar_t *buf, const char *psz, size_t n) const
 {
-public:
-    wxCharacterSet() { }
-    virtual ~wxCharacterSet() {}
+    size_t len=0;
+
+    while (*(wxUint16*)psz && (!buf || len < n))
+    {
+        if (buf)
+            *buf++ = *(wxUint16*)psz;
+        len++;
+
+        psz += sizeof(wxUint16);
+    }
+    if (buf && len<n)   *buf=0;
+
+    return len;
+}
+
+
+// copy 16bit String to 16bit MB
+size_t wxMBConvUTF16straight::WC2MB(char *buf, const wchar_t *psz, size_t n) const
+{
+    size_t len=0;
+
+    while (*psz && (!buf || len < n))
+    {
+        if (buf)
+        {
+            *(wxUint16*)buf = *psz;
+            buf += sizeof(wxUint16);
+        }
+        len += sizeof(wxUint16);
+        psz++;
+    }
+    if (buf && len<=n-sizeof(wxUint16))   *(wxUint16*)buf=0;
+
+    return len;
+}
+
+
+// swap 16bit MB to 16bit String
+size_t wxMBConvUTF16swap::MB2WC(wchar_t *buf, const char *psz, size_t n) const
+{
+    size_t len=0;
+
+    while (*(wxUint16*)psz && (!buf || len < n))
+    {
+        if (buf)
+        {
+            ((char *)buf)[0] = psz[1];
+            ((char *)buf)[1] = psz[0];
+            buf++;
+        }
+        len++;
+        psz += sizeof(wxUint16);
+    }
+    if (buf && len<n)   *buf=0;
+
+    return len;
+}
+
+
+// swap 16bit MB to 16bit String
+size_t wxMBConvUTF16swap::WC2MB(char *buf, const wchar_t *psz, size_t n) const
+{
+    size_t len=0;
+
+    while (*psz && (!buf || len < n))
+    {
+        if (buf)
+        {
+            *buf++ = ((char*)psz)[1];
+            *buf++ = ((char*)psz)[0];
+        }
+        len += sizeof(wxUint16);
+        psz++;
+    }
+    if (buf && len<=n-sizeof(wxUint16))   *(wxUint16*)buf=0;
+
+    return len;
+}
+
+
+#else // WC_UTF16
+
+
+// copy 16bit MB to 32bit String
+size_t wxMBConvUTF16straight::MB2WC(wchar_t *buf, const char *psz, size_t n) const
+{
+    size_t len=0;
+
+    while (*(wxUint16*)psz && (!buf || len < n))
+    {
+        wxUint32 cc;
+        size_t pa=decode_utf16((wxUint16*)psz, cc);
+        if (pa == (size_t)-1)
+            return pa;
+
+        if (buf)
+            *buf++ = cc;
+        len++;
+        psz += pa * sizeof(wxUint16);
+    }
+    if (buf && len<n)   *buf=0;
+
+    return len;
+}
+
+
+// copy 32bit String to 16bit MB
+size_t wxMBConvUTF16straight::WC2MB(char *buf, const wchar_t *psz, size_t n) const
+{
+    size_t len=0;
+
+    while (*psz && (!buf || len < n))
+    {
+        wxUint16 cc[2];
+        size_t pa=encode_utf16(*psz, cc);
+
+        if (pa == (size_t)-1)
+            return pa;
+
+        if (buf)
+        {
+            *(wxUint16*)buf = cc[0];
+            buf += sizeof(wxUint16);
+            if (pa > 1)
+            {
+                *(wxUint16*)buf = cc[1];
+                buf += sizeof(wxUint16);
+            }
+        }
+
+        len += pa*sizeof(wxUint16);
+        psz++;
+    }
+    if (buf && len<=n-sizeof(wxUint16))   *(wxUint16*)buf=0;
+
+    return len;
+}
+
+
+// swap 16bit MB to 32bit String
+size_t wxMBConvUTF16swap::MB2WC(wchar_t *buf, const char *psz, size_t n) const
+{
+    size_t len=0;
+
+    while (*(wxUint16*)psz && (!buf || len < n))
+    {
+        wxUint32 cc;
+        char tmp[4];
+        tmp[0]=psz[1];  tmp[1]=psz[0];
+        tmp[2]=psz[3];  tmp[3]=psz[2];
+
+        size_t pa=decode_utf16((wxUint16*)tmp, cc);
+        if (pa == (size_t)-1)
+            return pa;
+
+        if (buf)
+            *buf++ = cc;
+
+        len++;
+        psz += pa * sizeof(wxUint16);
+    }
+    if (buf && len<n)   *buf=0;
+
+    return len;
+}
+
+
+// swap 32bit String to 16bit MB
+size_t wxMBConvUTF16swap::WC2MB(char *buf, const wchar_t *psz, size_t n) const
+{
+    size_t len=0;
+
+    while (*psz && (!buf || len < n))
+    {
+        wxUint16 cc[2];
+        size_t pa=encode_utf16(*psz, cc);
+
+        if (pa == (size_t)-1)
+            return pa;
+
+        if (buf)
+        {
+            *buf++ = ((char*)cc)[1];
+            *buf++ = ((char*)cc)[0];
+            if (pa > 1)
+            {
+                *buf++ = ((char*)cc)[3];
+                *buf++ = ((char*)cc)[2];
+            }
+        }
+
+        len += pa*sizeof(wxUint16);
+        psz++;
+    }
+    if (buf && len<=n-sizeof(wxUint16))   *(wxUint16*)buf=0;
+
+    return len;
+}
+
+#endif // WC_UTF16
 
-    virtual size_t MB2WC(wchar_t *buf, const char *psz, size_t n) = 0;
-    virtual size_t WC2MB(char *buf, const wchar_t *psz, size_t n) = 0;
-    virtual bool usable() const = 0;
-};
 
 // ----------------------------------------------------------------------------
-// ID_CharSet: implementation of wxCharacterSet using an existing wxMBConv
+// UTF-32
 // ----------------------------------------------------------------------------
 
-class ID_CharSet : public wxCharacterSet
+#ifdef WORDS_BIGENDIAN
+#define wxMBConvUTF32straight  wxMBConvUTF32BE
+#define wxMBConvUTF32swap      wxMBConvUTF32LE
+#else
+#define wxMBConvUTF32swap      wxMBConvUTF32BE
+#define wxMBConvUTF32straight  wxMBConvUTF32LE
+#endif
+
+
+WXDLLIMPEXP_DATA_BASE(wxMBConvUTF32LE) wxConvUTF32LE;
+WXDLLIMPEXP_DATA_BASE(wxMBConvUTF32BE) wxConvUTF32BE;
+
+
+#ifdef WC_UTF16
+
+// copy 32bit MB to 16bit String
+size_t wxMBConvUTF32straight::MB2WC(wchar_t *buf, const char *psz, size_t n) const
 {
-public:
-    ID_CharSet(wxMBConv *cnv) : work(cnv) {}
+    size_t len=0;
 
-    size_t MB2WC(wchar_t *buf, const char *psz, size_t n)
-        { return work ? work->MB2WC(buf,psz,n) : (size_t)-1; }
+    while (*(wxUint32*)psz && (!buf || len < n))
+    {
+        wxUint16 cc[2];
 
-    size_t WC2MB(char *buf, const wchar_t *psz, size_t n)
-        { return work ? work->WC2MB(buf,psz,n) : (size_t)-1; }
+        size_t pa=encode_utf16(*(wxUint32*)psz, cc);
+        if (pa == (size_t)-1)
+            return pa;
+
+        if (buf)
+        {
+            *buf++ = cc[0];
+            if (pa > 1)
+                *buf++ = cc[1];
+        }
+        len += pa;
+        psz += sizeof(wxUint32);
+    }
+    if (buf && len<n)   *buf=0;
+
+    return len;
+}
+
+
+// copy 16bit String to 32bit MB
+size_t wxMBConvUTF32straight::WC2MB(char *buf, const wchar_t *psz, size_t n) const
+{
+    size_t len=0;
+
+    while (*psz && (!buf || len < n))
+    {
+        wxUint32 cc;
+
+        // cast is ok for WC_UTF16
+        size_t pa = decode_utf16((const wxUint16 *)psz, cc);
+        if (pa == (size_t)-1)
+            return pa;
+
+        if (buf)
+        {
+            *(wxUint32*)buf = cc;
+            buf += sizeof(wxUint32);
+        }
+        len += sizeof(wxUint32);
+        psz += pa;
+    }
+
+    if (buf && len<=n-sizeof(wxUint32))
+        *(wxUint32*)buf=0;
+
+    return len;
+}
 
-    bool usable() const
-        { return work!=NULL; }
-public:
-    wxMBConv*work;
-};
+
+
+// swap 32bit MB to 16bit String
+size_t wxMBConvUTF32swap::MB2WC(wchar_t *buf, const char *psz, size_t n) const
+{
+    size_t len=0;
+
+    while (*(wxUint32*)psz && (!buf || len < n))
+    {
+        char tmp[4];
+        tmp[0] = psz[3];   tmp[1] = psz[2];
+        tmp[2] = psz[1];   tmp[3] = psz[0];
+
+
+        wxUint16 cc[2];
+
+        size_t pa=encode_utf16(*(wxUint32*)tmp, cc);
+        if (pa == (size_t)-1)
+            return pa;
+
+        if (buf)
+        {
+            *buf++ = cc[0];
+            if (pa > 1)
+                *buf++ = cc[1];
+        }
+        len += pa;
+        psz += sizeof(wxUint32);
+    }
+
+    if (buf && len<n)
+        *buf=0;
+
+    return len;
+}
+
+
+// swap 16bit String to 32bit MB
+size_t wxMBConvUTF32swap::WC2MB(char *buf, const wchar_t *psz, size_t n) const
+{
+    size_t len=0;
+
+    while (*psz && (!buf || len < n))
+    {
+        char cc[4];
+
+        // cast is ok for WC_UTF16
+        size_t pa=decode_utf16((const wxUint16 *)psz, *(wxUint32*)cc);
+        if (pa == (size_t)-1)
+            return pa;
+
+        if (buf)
+        {
+            *buf++ = cc[3];
+            *buf++ = cc[2];
+            *buf++ = cc[1];
+            *buf++ = cc[0];
+        }
+        len += sizeof(wxUint32);
+        psz += pa;
+    }
+
+    if (buf && len<=n-sizeof(wxUint32))
+        *(wxUint32*)buf=0;
+
+    return len;
+}
+
+#else // WC_UTF16
+
+
+// copy 32bit MB to 32bit String
+size_t wxMBConvUTF32straight::MB2WC(wchar_t *buf, const char *psz, size_t n) const
+{
+    size_t len=0;
+
+    while (*(wxUint32*)psz && (!buf || len < n))
+    {
+        if (buf)
+            *buf++ = *(wxUint32*)psz;
+        len++;
+        psz += sizeof(wxUint32);
+    }
+
+    if (buf && len<n)
+        *buf=0;
+
+    return len;
+}
+
+
+// copy 32bit String to 32bit MB
+size_t wxMBConvUTF32straight::WC2MB(char *buf, const wchar_t *psz, size_t n) const
+{
+    size_t len=0;
+
+    while (*psz && (!buf || len < n))
+    {
+        if (buf)
+        {
+            *(wxUint32*)buf = *psz;
+            buf += sizeof(wxUint32);
+        }
+
+        len += sizeof(wxUint32);
+        psz++;
+    }
+
+    if (buf && len<=n-sizeof(wxUint32))
+        *(wxUint32*)buf=0;
+
+    return len;
+}
+
+
+// swap 32bit MB to 32bit String
+size_t wxMBConvUTF32swap::MB2WC(wchar_t *buf, const char *psz, size_t n) const
+{
+    size_t len=0;
+
+    while (*(wxUint32*)psz && (!buf || len < n))
+    {
+        if (buf)
+        {
+            ((char *)buf)[0] = psz[3];
+            ((char *)buf)[1] = psz[2];
+            ((char *)buf)[2] = psz[1];
+            ((char *)buf)[3] = psz[0];
+            buf++;
+        }
+        len++;
+        psz += sizeof(wxUint32);
+    }
+
+    if (buf && len<n)
+        *buf=0;
+
+    return len;
+}
+
+
+// swap 32bit String to 32bit MB
+size_t wxMBConvUTF32swap::WC2MB(char *buf, const wchar_t *psz, size_t n) const
+{
+    size_t len=0;
+
+    while (*psz && (!buf || len < n))
+    {
+        if (buf)
+        {
+            *buf++ = ((char *)psz)[3];
+            *buf++ = ((char *)psz)[2];
+            *buf++ = ((char *)psz)[1];
+            *buf++ = ((char *)psz)[0];
+        }
+        len += sizeof(wxUint32);
+        psz++;
+    }
+
+    if (buf && len<=n-sizeof(wxUint32))
+        *(wxUint32*)buf=0;
+
+    return len;
+}
+
+
+#endif // WC_UTF16
 
 
 // ============================================================================
@@ -486,19 +845,19 @@ public:
 #define ICONV_CHAR_CAST(x)  ((ICONV_CONST char **)(x))
 
 // ----------------------------------------------------------------------------
-// IC_CharSet: encapsulates an iconv character set
+// wxMBConv_iconv: encapsulates an iconv character set
 // ----------------------------------------------------------------------------
 
-class IC_CharSet : public wxCharacterSet
+class wxMBConv_iconv : public wxMBConv
 {
 public:
-    IC_CharSet(const wxChar *name);
-    virtual ~IC_CharSet();
+    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 usable() const
+    bool IsOk() const
         { return (m2w != (iconv_t)-1) && (w2m != (iconv_t)-1); }
 
 protected:
@@ -508,7 +867,7 @@ protected:
             w2m;
 
 private:
-    // the name (for iconv_open()) of a wide char charset - if none is
+    // the name (for iconv_open()) of a wide char charset -- if none is
     // available on this machine, it will remain NULL
     static const char *ms_wcCharsetName;
 
@@ -517,11 +876,10 @@ private:
     static bool ms_wcNeedsSwap;
 };
 
-const char *IC_CharSet::ms_wcCharsetName = NULL;
-bool IC_CharSet::ms_wcNeedsSwap = FALSE;
+const char *wxMBConv_iconv::ms_wcCharsetName = NULL;
+bool wxMBConv_iconv::ms_wcNeedsSwap = false;
 
-IC_CharSet::IC_CharSet(const wxChar *name)
-          : wxCharacterSet(name)
+wxMBConv_iconv::wxMBConv_iconv(const wxChar *name)
 {
     // Do it the hard way
     char cname[100];
@@ -531,7 +889,7 @@ IC_CharSet::IC_CharSet(const wxChar *name)
     // check for charset that represents wchar_t:
     if (ms_wcCharsetName == NULL)
     {
-        ms_wcNeedsSwap = FALSE;
+        ms_wcNeedsSwap = false;
 
         // try charset with explicit bytesex info (e.g. "UCS-4LE"):
         ms_wcCharsetName = WC_NAME_BEST;
@@ -608,7 +966,7 @@ IC_CharSet::IC_CharSet(const wxChar *name)
     }
 }
 
-IC_CharSet::~IC_CharSet()
+wxMBConv_iconv::~wxMBConv_iconv()
 {
     if ( m2w != (iconv_t)-1 )
         iconv_close(m2w);
@@ -616,7 +974,7 @@ IC_CharSet::~IC_CharSet()
         iconv_close(w2m);
 }
 
-size_t IC_CharSet::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;
@@ -673,7 +1031,7 @@ size_t IC_CharSet::MB2WC(wchar_t *buf, const char *psz, size_t n)
     return res;
 }
 
-size_t IC_CharSet::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;
@@ -738,30 +1096,36 @@ size_t IC_CharSet::WC2MB(char *buf, const wchar_t *psz, size_t n)
 
 #endif // HAVE_ICONV
 
+
 // ============================================================================
 // Win32 conversion classes
 // ============================================================================
 
-#if defined(__WIN32__) && !defined(__WXMICROWIN__) && !defined(__WXUNIVERSAL__)
+#ifdef wxHAVE_WIN32_MB2WC
 
 // from utils.cpp
 extern WXDLLIMPEXP_BASE long wxCharsetToCodepage(const wxChar *charset);
 extern WXDLLIMPEXP_BASE long wxEncodingToCodepage(wxFontEncoding encoding);
 
-class CP_CharSet : public wxCharacterSet
+class wxMBConv_win32 : public wxMBConv
 {
 public:
-    CP_CharSet(const wxChar* name)
-        {
-            m_CodePage = wxCharsetToCodepage(name);
-        }
+    wxMBConv_win32()
+    {
+        m_CodePage = CP_ACP;
+    }
 
-    CP_CharSet(wxFontEncoding encoding)
-        {
-            m_CodePage = wxEncodingToCodepage(encoding);
-        }
+    wxMBConv_win32(const wxChar* name)
+    {
+        m_CodePage = wxCharsetToCodepage(name);
+    }
 
-    size_t MB2WC(wchar_t *buf, const char *psz, size_t n)
+    wxMBConv_win32(wxFontEncoding encoding)
+    {
+        m_CodePage = wxEncodingToCodepage(encoding);
+    }
+
+    size_t MB2WC(wchar_t *buf, const char *psz, size_t n) const
     {
         const size_t len = ::MultiByteToWideChar
                              (
@@ -773,12 +1137,13 @@ public:
                                 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
                              (
@@ -792,17 +1157,19 @@ public:
                                 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 usable() const
+    bool IsOk() const
         { return m_CodePage != -1; }
 
 public:
     long m_CodePage;
 };
-#endif // defined(__WIN32__) && !defined(__WXMICROWIN__) && !defined(__WXUNIVERSAL__)
+
+#endif // wxHAVE_WIN32_MB2WC
+
 
 // ============================================================================
 // wxEncodingConverter based conversion classes
@@ -810,7 +1177,7 @@ public:
 
 #if wxUSE_FONTMAP
 
-class EC_CharSet : public wxCharacterSet
+class wxMBConv_wxwin : public wxMBConv
 {
 private:
     void Init()
@@ -822,24 +1189,24 @@ private:
 public:
     // temporarily just use wxEncodingConverter stuff,
     // so that it works while a better implementation is built
-    EC_CharSet(const wxChar* name)
+    wxMBConv_wxwin(const wxChar* name)
     {
         if (name)
-            m_enc = wxFontMapper::Get()->CharsetToEncoding(name, FALSE);
+            m_enc = wxFontMapper::Get()->CharsetToEncoding(name, false);
         else
             m_enc = wxFONTENCODING_SYSTEM;
 
         Init();
     }
 
-    EC_CharSet(wxFontEncoding enc)
+    wxMBConv_wxwin(wxFontEncoding enc)
     {
         m_enc = enc;
 
         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)
@@ -847,7 +1214,7 @@ public:
         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)
@@ -856,7 +1223,7 @@ public:
         return inbuf;
     }
 
-    bool usable() const { return m_ok; }
+    bool IsOk() const { return m_ok; }
 
 public:
     wxFontEncoding m_enc;
@@ -865,120 +1232,43 @@ public:
     // were we initialized successfully?
     bool m_ok;
 
-    DECLARE_NO_COPY_CLASS(EC_CharSet)
+    DECLARE_NO_COPY_CLASS(wxMBConv_wxwin)
 };
 
 #endif // wxUSE_FONTMAP
 
-// ----------------------------------------------------------------------------
-// the function creating the wxCharacterSet for the specified charset on the
-// current system, trying all possibilities
-//
-// it uses the name if it is given or encoding if name == NULL
-// ----------------------------------------------------------------------------
-
-static wxCharacterSet *
-wxGetCharacterSet(const wxChar *name, wxFontEncoding encoding)
-{
-    // check for the special case of ASCII charset
-    if ( (!name && encoding == wxFONTENCODING_DEFAULT)
-#if wxUSE_FONTMAP
-            || wxFontMapper::Get()->
-                    CharsetToEncoding(name) == wxFONTENCODING_DEFAULT
-#endif // wxUSE_FONTMAP
-       )
-    {
-        // don't convert at all
-        return NULL;
-    }
-
-    wxCharacterSet *cset;
-
-    if ( (name &&
-            (wxStricmp(name, wxT("UTF8")) == 0 ||
-             wxStricmp(name, wxT("UTF-8")) == 0)) ||
-          encoding == wxFONTENCODING_UTF8 )
-    {
-        cset = new ID_CharSet(&wxConvUTF8);
-    }
-    else // !UTF-8
-    {
-#ifdef HAVE_ICONV
-        if ( name )
-        {
-            cset = new IC_CharSet(name);
-        }
-        else
-#endif // HAVE_ICONV
-        {
-            cset = NULL;
-        }
-    }
-
-    // it can only be NULL in this case
-#ifndef HAVE_ICONV
-    if ( cset )
-#endif // !HAVE_ICONV
-    {
-        if ( cset->usable() )
-            return cset;
-
-        delete cset;
-        cset = NULL;
-    }
-
-#if defined(__WIN32__) && !defined(__WXMICROWIN__) && !defined(__WXUNIVERSAL__)
-    cset = name ? new CP_CharSet(name) : new CP_CharSet(encoding);
-    if ( cset->usable() )
-        return cset;
-
-    delete cset;
-    cset = NULL;
-#endif // defined(__WIN32__) && !defined(__WXMICROWIN__) && !defined(__WXUNIVERSAL__)
-
-#if wxUSE_FONTMAP
-    cset = name ? new EC_CharSet(name) : new EC_CharSet(encoding);
-    if ( cset->usable() )
-        return cset;
-
-    delete cset;
-    cset = NULL;
-#endif // wxUSE_FONTMAP
-
-    wxLogError(_("Cannot convert from encoding '%s'!"),
-               name ? name
-                    :
-#if wxUSE_FONTMAP
-                     wxFontMapper::GetEncodingDescription(encoding).c_str()
-#else // !wxUSE_FONTMAP
-                     wxString::Format(_T("%s"), encoding).c_str()
-#endif // wxUSE_FONTMAP/!wxUSE_FONTMAP
-              );
-
-    return NULL;
-}
-
 // ============================================================================
 // wxCSConv implementation
 // ============================================================================
 
 void wxCSConv::Init()
 {
-    m_name = (wxChar *)NULL;
-    m_cset = (wxCharacterSet *) NULL;
-    m_deferred = TRUE;
+    m_name = NULL;
+    m_convReal =  NULL;
+    m_deferred = true;
 }
 
 wxCSConv::wxCSConv(const wxChar *charset)
 {
     Init();
-    m_encoding = wxFONTENCODING_DEFAULT;
 
-    SetName(charset);
+    if ( charset )
+    {
+        SetName(charset);
+    }
+
+    m_encoding = wxFONTENCODING_SYSTEM;
 }
 
 wxCSConv::wxCSConv(wxFontEncoding encoding)
 {
+    if ( encoding == wxFONTENCODING_MAX || encoding == wxFONTENCODING_DEFAULT )
+    {
+        wxFAIL_MSG( _T("invalid encoding value in wxCSConv ctor") );
+
+        encoding = wxFONTENCODING_SYSTEM;
+    }
+
     Init();
 
     m_encoding = encoding;
@@ -1011,10 +1301,10 @@ wxCSConv& wxCSConv::operator=(const wxCSConv& conv)
 void wxCSConv::Clear()
 {
     free(m_name);
-    delete m_cset;
+    delete m_convReal;
 
     m_name = NULL;
-    m_cset = NULL;
+    m_convReal = NULL;
 }
 
 void wxCSConv::SetName(const wxChar *charset)
@@ -1022,39 +1312,151 @@ void wxCSConv::SetName(const wxChar *charset)
     if (charset)
     {
         m_name = wxStrdup(charset);
-        m_deferred = TRUE;
+        m_deferred = true;
     }
 }
 
-void wxCSConv::LoadNow()
+static inline bool DoesntNeedConv(wxFontEncoding enc)
+{
+    return enc == wxFONTENCODING_DEFAULT ||
+            enc == wxFONTENCODING_SYSTEM ||
+             enc == wxFONTENCODING_ISO8859_1;
+}
+
+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
+       )
+    {
+        // don't convert at all
+        return NULL;
+    }
+
+    // we trust OS to do conversion better than we can so try external
+    // conversion methods first
+    //
+    // the full order is:
+    //      1. OS conversion (iconv() under Unix or Win32 API)
+    //      2. hard coded conversions for UTF
+    //      3. wxEncodingConverter as fall back
+
+    // step (1)
+#ifdef HAVE_ICONV
+    if ( m_name )
+    {
+        wxMBConv_iconv *conv = new wxMBConv_iconv(m_name);
+        if ( conv->IsOk() )
+            return conv;
+
+        delete conv;
+    }
+#endif // HAVE_ICONV
+
+#ifdef wxHAVE_WIN32_MB2WC
+    {
+        wxMBConv_win32 *conv = m_name ? new wxMBConv_win32(m_name)
+                                      : new wxMBConv_win32(m_encoding);
+        if ( conv->IsOk() )
+            return conv;
+
+        delete conv;
+    }
+#endif // wxHAVE_WIN32_MB2WC
+
+    // step (2)
+    wxFontEncoding enc = m_encoding;
+#if wxUSE_FONTMAP
+    if ( enc == wxFONTENCODING_SYSTEM )
+        enc = encFromName;
+#endif // wxUSE_FONTMAP
+
+    switch ( enc )
+    {
+        case wxFONTENCODING_UTF7:
+             return new wxMBConvUTF7;
+
+        case wxFONTENCODING_UTF8:
+             return new wxMBConvUTF8;
+
+        case wxFONTENCODING_UTF16BE:
+             return new wxMBConvUTF16BE;
+
+        case wxFONTENCODING_UTF16LE:
+             return new wxMBConvUTF16LE;
+
+        case wxFONTENCODING_UTF32BE:
+             return new wxMBConvUTF32BE;
+
+        case wxFONTENCODING_UTF32LE:
+             return new wxMBConvUTF32LE;
+
+        default:
+             // nothing to do but put here to suppress gcc warnings
+             ;
+    }
+
+    // step (3)
+#if wxUSE_FONTMAP
+    {
+        wxMBConv_wxwin *conv = m_name ? new wxMBConv_wxwin(m_name)
+                                      : new wxMBConv_wxwin(m_encoding);
+        if ( conv->IsOk() )
+            return conv;
+
+        delete conv;
+    }
+#endif // wxUSE_FONTMAP
+
+    wxLogError(_("Cannot convert from the charset '%s'!"),
+               m_name ? m_name
+                      :
+#if wxUSE_FONTMAP
+                         wxFontMapper::GetEncodingDescription(m_encoding).c_str()
+#else // !wxUSE_FONTMAP
+                         wxString::Format(_("encoding %s"), m_encoding).c_str()
+#endif // wxUSE_FONTMAP/!wxUSE_FONTMAP
+              );
+
+    return NULL;
+}
+
+void wxCSConv::CreateConvIfNeeded() const
 {
     if ( m_deferred )
     {
-        // it would probably be better to make GetSystemEncodingName() always
-        // available (i.e. even when wxUSE_INTL == 0)?
+        wxCSConv *self = (wxCSConv *)this; // const_cast
+
 #if wxUSE_INTL
-        if ( !m_name && m_encoding == wxFONTENCODING_DEFAULT )
+        // 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 )
         {
-            wxString name = wxLocale::GetSystemEncodingName();
-            if ( !name.empty() )
-            {
-                SetName(name);
-            }
+            self->m_encoding = wxLocale::GetSystemEncoding();
         }
 #endif // wxUSE_INTL
 
-        // wxGetCharacterSet() complains about NULL name
-        m_cset = wxGetCharacterSet(m_name, m_encoding);
-        m_deferred = FALSE;
+        self->m_convReal = DoCreate();
+        self->m_deferred = false;
     }
 }
 
 size_t wxCSConv::MB2WC(wchar_t *buf, const char *psz, size_t n) const
 {
-    ((wxCSConv *)this)->LoadNow(); // discard constness
+    CreateConvIfNeeded();
 
-    if (m_cset)
-        return m_cset->MB2WC(buf, psz, n);
+    if (m_convReal)
+        return m_convReal->MB2WC(buf, psz, n);
 
     // latin-1 (direct)
     size_t len = strlen(psz);
@@ -1070,10 +1472,10 @@ size_t wxCSConv::MB2WC(wchar_t *buf, const char *psz, size_t n) const
 
 size_t wxCSConv::WC2MB(char *buf, const wchar_t *psz, size_t n) const
 {
-    ((wxCSConv *)this)->LoadNow(); // discard constness
+    CreateConvIfNeeded();
 
-    if (m_cset)
-        return m_cset->WC2MB(buf, psz, n);
+    if (m_convReal)
+        return m_convReal->WC2MB(buf, psz, n);
 
     // latin-1 (direct)
     const size_t len = wxWcslen(psz);
@@ -1086,6 +1488,37 @@ size_t wxCSConv::WC2MB(char *buf, const wchar_t *psz, size_t n) const
     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