+ wxCharacterSet(const wxChar*name)
+ : cname(name) {}
+ virtual ~wxCharacterSet()
+ {}
+ virtual size_t MB2WC(wchar_t *buf, const char *psz, size_t n)
+ { return (size_t)-1; }
+ virtual size_t WC2MB(char *buf, const wchar_t *psz, size_t n)
+ { return (size_t)-1; }
+ virtual bool usable()
+ { return FALSE; }
+public:
+ const wxChar*cname;
+};
+
+class ID_CharSet : public wxCharacterSet
+{
+public:
+ ID_CharSet(const wxChar *name,wxMBConv *cnv)
+ : wxCharacterSet(name), work(cnv) {}
+
+ size_t MB2WC(wchar_t *buf, const char *psz, size_t n)
+ { return work ? work->MB2WC(buf,psz,n) : (size_t)-1; }
+
+ size_t WC2MB(char *buf, const wchar_t *psz, size_t n)
+ { return work ? work->WC2MB(buf,psz,n) : (size_t)-1; }
+
+ bool usable()
+ { return work!=NULL; }
+public:
+ wxMBConv*work;
+};
+
+
+#ifdef HAVE_ICONV_H
+
+bool g_wcNeedsSwap = FALSE;
+static const char *g_wcCharset = NULL;
+
+// VS: glibc 2.1.3 is broken in that iconv() conversion to/from UCS4 fails with E2BIG
+// if output buffer is _exactly_ as big as needed. Such case is (unless there's
+// yet another bug in glibc) the only case when iconv() returns with (size_t)-1
+// (which means error) and says there are 0 bytes left in the input buffer --
+// when _real_ error occurs, bytes-left-in-input buffer is non-zero. Hence,
+// this alternative test for iconv() failure.
+// [This bug does not appear in glibc 2.2.]
+#if defined(__GLIBC__) && __GLIBC__ == 2 && __GLIBC_MINOR__ <= 1
+#define ICONV_FAILED(cres, bufLeft) ((cres == (size_t)-1) && \
+ (errno != E2BIG || bufLeft != 0))
+#else
+#define ICONV_FAILED(cres, bufLeft) (cres == (size_t)-1)
+#endif
+
+class IC_CharSet : public wxCharacterSet
+{
+public:
+ IC_CharSet(const wxChar *name)
+ : wxCharacterSet(name)
+ {
+ // check for charset that represents wchar_t:
+ if (g_wcCharset == NULL)
+ {
+ g_wcNeedsSwap = FALSE;
+
+ // try charset with explicit bytesex info (e.g. "UCS-4LE"):
+ g_wcCharset = WC_NAME_BEST;
+ m2w = iconv_open(g_wcCharset, wxConvLibc.cWX2MB(name));
+
+ if (m2w == (iconv_t)-1)
+ {
+ // try charset w/o bytesex info (e.g. "UCS4")
+ // and check for bytesex ourselves:
+ g_wcCharset = WC_NAME;
+ m2w = iconv_open(g_wcCharset, wxConvLibc.cWX2MB(name));
+
+ // last bet, try if it knows WCHAR_T pseudo-charset
+ if (m2w == (iconv_t)-1)
+ {
+ g_wcCharset = "WCHAR_T";
+ m2w = iconv_open(g_wcCharset, wxConvLibc.cWX2MB(name));
+ }
+
+ if (m2w != (iconv_t)-1)
+ {
+ char buf[2], *bufPtr;
+ wchar_t wbuf[2], *wbufPtr;
+ size_t insz, outsz;
+ size_t res;
+
+ buf[0] = 'A';
+ buf[1] = 0;
+ wbuf[0] = 0;
+ insz = 2;
+ outsz = SIZEOF_WCHAR_T * 2;
+ wbufPtr = wbuf;
+ bufPtr = buf;
+
+ #ifdef WX_ICONV_TAKES_CHAR
+ res = iconv(m2w, (char**)&bufPtr, &insz, (char**)&wbufPtr, &outsz);
+ #else
+ res = iconv(m2w, (const char**)&bufPtr, &insz, (char**)&wbufPtr, &outsz);
+ #endif
+ if (ICONV_FAILED(res, insz))
+ {
+ g_wcCharset = NULL;
+ wxLogLastError(wxT("iconv"));
+ wxLogError(_("Convertion to charset '%s' doesn't work."), name);
+ }
+ else
+ {
+ g_wcNeedsSwap = (wbuf[0] != (wchar_t)buf[0]);
+ }
+ }
+ else
+ {
+ g_wcCharset = NULL;
+ wxLogError(_("Don't know how to convert to/from charset '%s'."), name);
+ }
+ }
+ wxLogTrace(wxT("strconv"), wxT("wchar_t charset is '%s', needs swap: %i"), g_wcCharset, g_wcNeedsSwap);
+ }
+ else
+ m2w = iconv_open(g_wcCharset, wxConvLibc.cWX2MB(name));
+
+ w2m = iconv_open(wxConvLibc.cWX2MB(name), g_wcCharset);
+ }
+
+ ~IC_CharSet()
+ {
+ if ( m2w != (iconv_t)-1 )
+ iconv_close(m2w);
+ if ( w2m != (iconv_t)-1 )
+ iconv_close(w2m);
+ }
+
+ size_t MB2WC(wchar_t *buf, const char *psz, size_t n)
+ {
+ size_t inbuf = strlen(psz);
+ size_t outbuf = n * SIZEOF_WCHAR_T;
+ size_t res, cres;
+ // VS: Use these instead of psz, buf because iconv() modifies its arguments:
+ wchar_t *bufPtr = buf;
+ const char *pszPtr = psz;
+
+ if (buf)
+ {
+ // have destination buffer, convert there
+#ifdef WX_ICONV_TAKES_CHAR
+ cres = iconv(m2w, (char**)&pszPtr, &inbuf, (char**)&bufPtr, &outbuf);
+#else
+ cres = iconv(m2w, &pszPtr, &inbuf, (char**)&bufPtr, &outbuf);
+#endif
+ res = n - (outbuf / SIZEOF_WCHAR_T);
+
+ if (g_wcNeedsSwap)
+ {
+ // convert to native endianness
+ WC_BSWAP(buf /* _not_ bufPtr */, res)
+ }
+ }
+ else
+ {
+ // no destination buffer... convert using temp buffer
+ // to calculate destination buffer requirement
+ wchar_t tbuf[8];
+ res = 0;
+ do {
+ bufPtr = tbuf; outbuf = 8*SIZEOF_WCHAR_T;
+#ifdef WX_ICONV_TAKES_CHAR
+ cres = iconv( m2w, (char**)&pszPtr, &inbuf, (char**)&bufPtr, &outbuf );
+#else
+ cres = iconv( m2w, &pszPtr, &inbuf, (char**)&bufPtr, &outbuf );
+#endif
+ res += 8-(outbuf/SIZEOF_WCHAR_T);
+ } while ((cres==(size_t)-1) && (errno==E2BIG));
+ }
+
+ if (ICONV_FAILED(cres, inbuf))
+ {
+ //VS: it is ok if iconv fails, hence trace only
+ wxLogTrace(wxT("strconv"), wxT("iconv failed: %s"), wxSysErrorMsg(wxSysErrorCode()));
+ return (size_t)-1;
+ }
+
+ return res;
+ }
+
+ size_t WC2MB(char *buf, const wchar_t *psz, size_t n)
+ {
+#if defined(__BORLANDC__) && (__BORLANDC__ > 0x530)
+ size_t inbuf = std::wcslen(psz) * SIZEOF_WCHAR_T;
+#else
+ size_t inbuf = ::wcslen(psz) * SIZEOF_WCHAR_T;
+#endif
+ size_t outbuf = n;
+ size_t res, cres;
+
+ wchar_t *tmpbuf = 0;
+
+ if (g_wcNeedsSwap)
+ {
+ // need to copy to temp buffer to switch endianness
+ // this absolutely doesn't rock!
+ // (no, doing WC_BSWAP twice on the original buffer won't help, as it
+ // could be in read-only memory, or be accessed in some other thread)
+ tmpbuf=(wchar_t*)malloc((inbuf+1)*SIZEOF_WCHAR_T);
+ memcpy(tmpbuf,psz,(inbuf+1)*SIZEOF_WCHAR_T);
+ WC_BSWAP(tmpbuf, inbuf)
+ psz=tmpbuf;
+ }
+
+ if (buf)
+ {
+ // have destination buffer, convert there
+#ifdef WX_ICONV_TAKES_CHAR
+ cres = iconv( w2m, (char**)&psz, &inbuf, &buf, &outbuf );
+#else
+ cres = iconv( w2m, (const char**)&psz, &inbuf, &buf, &outbuf );
+#endif
+ res = n-outbuf;
+ }
+ else
+ {
+ // no destination buffer... convert using temp buffer
+ // to calculate destination buffer requirement
+ char tbuf[16];
+ res = 0;
+ do {
+ buf = tbuf; outbuf = 16;
+#ifdef WX_ICONV_TAKES_CHAR
+ cres = iconv( w2m, (char**)&psz, &inbuf, &buf, &outbuf );
+#else
+ cres = iconv( w2m, (const char**)&psz, &inbuf, &buf, &outbuf );
+#endif
+ res += 16 - outbuf;
+ } while ((cres==(size_t)-1) && (errno==E2BIG));
+ }
+
+ if (g_wcNeedsSwap)
+ {
+ free(tmpbuf);
+ }
+
+ if (ICONV_FAILED(cres, inbuf))
+ {
+ //VS: it is ok if iconv fails, hence trace only
+ wxLogTrace(wxT("strconv"), wxT("iconv failed: %s"), wxSysErrorMsg(wxSysErrorCode()));
+ return (size_t)-1;
+ }
+
+ return res;
+ }
+
+ bool usable()
+ { return (m2w != (iconv_t)-1) && (w2m != (iconv_t)-1); }
+
+protected:
+ iconv_t m2w, w2m;
+};
+#endif
+
+#if defined(__WIN32__) && !defined(__WXMICROWIN__)
+class CP_CharSet : public wxCharacterSet
+{
+public:
+ CP_CharSet(const wxChar* name)
+ : wxCharacterSet(name)
+ {
+ m_CodePage = wxCharsetToCodepage(name);
+ }
+
+ size_t MB2WC(wchar_t *buf, const char *psz, size_t n)
+ {
+ size_t len =
+ MultiByteToWideChar(m_CodePage, 0, psz, -1, buf, buf ? n : 0);
+ //VS: returns # of written chars for buf!=NULL and *size*
+ // needed buffer for buf==NULL
+ return len ? (buf ? len : len-1) : (size_t)-1;
+ }
+
+ size_t WC2MB(char *buf, const wchar_t *psz, size_t n)
+ {
+ size_t len = WideCharToMultiByte(m_CodePage, 0, psz, -1, buf,
+ buf ? n : 0, NULL, NULL);
+ //VS: returns # of written chars for buf!=NULL and *size*
+ // needed buffer for buf==NULL
+ return len ? (buf ? len : len-1) : (size_t)-1;
+ }
+
+ bool usable()
+ { return m_CodePage != -1; }
+
+public:
+ long m_CodePage;
+};
+#endif // __WIN32__
+
+#if wxUSE_FONTMAP
+
+class EC_CharSet : public wxCharacterSet
+{
+public:
+ // temporarily just use wxEncodingConverter stuff,
+ // so that it works while a better implementation is built
+ EC_CharSet(const wxChar* name) : wxCharacterSet(name),
+ enc(wxFONTENCODING_SYSTEM)
+ {
+ if (name)
+ enc = wxTheFontMapper->CharsetToEncoding(name, FALSE);
+ m2w.Init(enc, wxFONTENCODING_UNICODE);
+ w2m.Init(wxFONTENCODING_UNICODE, enc);
+ }
+
+ size_t MB2WC(wchar_t *buf, const char *psz, size_t n)
+ {
+ size_t inbuf = strlen(psz);
+ if (buf)
+ m2w.Convert(psz,buf);
+ return inbuf;
+ }
+
+ size_t WC2MB(char *buf, const wchar_t *psz, size_t n)
+ {
+#if ( defined(__BORLANDC__) && (__BORLANDC__ > 0x530) ) \
+ || ( defined(__MWERKS__) && defined(__WXMSW__) )
+ size_t inbuf = std::wcslen(psz);
+#else
+ size_t inbuf = ::wcslen(psz);
+#endif
+ if (buf)
+ w2m.Convert(psz,buf);
+
+ return inbuf;
+ }
+
+ bool usable()
+ { return (enc!=wxFONTENCODING_SYSTEM) && (enc!=wxFONTENCODING_DEFAULT); }
+
+public:
+ wxFontEncoding enc;
+ wxEncodingConverter m2w, w2m;
projects / wxWidgets.git / blobdiff