/////////////////////////////////////////////////////////////////////////////
-// Name: strconv.cpp
+// Name: src/common/strconv.cpp
// Purpose: Unicode conversion classes
// Author: Ove Kaaven, Robert Roebling, Vadim Zeitlin, Vaclav Slavik,
// Ryan Norton, Fredrik Roubert (UTF7)
// headers
// ----------------------------------------------------------------------------
-#if defined(__GNUG__) && !defined(NO_GCC_PRAGMA)
- #pragma implementation "strconv.h"
-#endif
-
// For compilers that support precompilation, includes "wx.h".
#include "wx/wxprec.h"
#define wxHAVE_WIN32_MB2WC
#endif // __WIN32__ but !__WXMICROWIN__
-// ----------------------------------------------------------------------------
-// headers
-// ----------------------------------------------------------------------------
-
#ifdef __SALFORDC__
#include <clib.h>
#endif
#define TRACE_STRCONV _T("strconv")
-// ----------------------------------------------------------------------------
-// macros
-// ----------------------------------------------------------------------------
-
-#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]); }
-
-#if SIZEOF_WCHAR_T == 4
- #define WC_NAME "UCS4"
- #define WC_BSWAP BSWAP_UCS4
- #ifdef WORDS_BIGENDIAN
- #define WC_NAME_BEST "UCS-4BE"
- #else
- #define WC_NAME_BEST "UCS-4LE"
- #endif
-#elif SIZEOF_WCHAR_T == 2
- #define WC_NAME "UTF16"
- #define WC_BSWAP BSWAP_UTF16
+#if SIZEOF_WCHAR_T == 2
#define WC_UTF16
- #ifdef WORDS_BIGENDIAN
- #define WC_NAME_BEST "UTF-16BE"
- #else
- #define WC_NAME_BEST "UTF-16LE"
- #endif
-#else // sizeof(wchar_t) != 2 nor 4
- // does this ever happen?
- #error "Unknown sizeof(wchar_t): please report this to wx-dev@lists.wxwindows.org"
#endif
// ============================================================================
{
// BASE64 encode string
unsigned int lsb, d, l;
- for (d = 0, l = 0;; psz++)
+ for (d = 0, l = 0; /*nothing*/; psz++)
{
for (lsb = 0; lsb < 2; lsb ++)
{
}
#else // !WC_UTF16
if (buf)
- *buf++ = res;
+ *buf++ = (wchar_t)res;
len++;
#endif // WC_UTF16/!WC_UTF16
}
len += pa;
#else
if (buf)
- *buf++ = wxUnicodePUA + (unsigned char)*opsz;
+ *buf++ = (wchar_t)(wxUnicodePUA + (unsigned char)*opsz);
opsz++;
len++;
#endif
{
if ( buf && len + 3 < n )
{
- unsigned char n = *opsz;
+ unsigned char on = *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 );
+ *buf++ = (wchar_t)( L'0' + on / 0100 );
+ *buf++ = (wchar_t)( L'0' + (on % 0100) / 010 );
+ *buf++ = (wchar_t)( L'0' + on % 010 );
}
opsz++;
len += 4;
return pa;
if (buf)
- *buf++ = cc;
+ *buf++ = (wchar_t)cc;
len++;
psz += pa * sizeof(wxUint16);
}
return pa;
if (buf)
- *buf++ = cc;
+ *buf++ = (wchar_t)cc;
len++;
psz += pa * sizeof(wxUint16);
while (*(wxUint32*)psz && (!buf || len < n))
{
if (buf)
- *buf++ = *(wxUint32*)psz;
+ *buf++ = (wchar_t)(*(wxUint32*)psz);
len++;
psz += sizeof(wxUint32);
}
#define ICONV_CHAR_CAST(x) ((ICONV_CONST char **)(x))
+#define ICONV_T_INVALID ((iconv_t)-1)
+
+#if SIZEOF_WCHAR_T == 4
+ #define WC_BSWAP wxUINT32_SWAP_ALWAYS
+ #define WC_ENC wxFONTENCODING_UTF32
+#elif SIZEOF_WCHAR_T == 2
+ #define WC_BSWAP wxUINT16_SWAP_ALWAYS
+ #define WC_ENC wxFONTENCODING_UTF16
+#else // sizeof(wchar_t) != 2 nor 4
+ // does this ever happen?
+ #error "Unknown sizeof(wchar_t): please report this to wx-dev@lists.wxwindows.org"
+#endif
+
// ----------------------------------------------------------------------------
// wxMBConv_iconv: encapsulates an iconv character set
// ----------------------------------------------------------------------------
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); }
+ { return (m2w != ICONV_T_INVALID) && (w2m != ICONV_T_INVALID); }
protected:
// the iconv handlers used to translate from multibyte to wide char and in
private:
// 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;
+ static wxString ms_wcCharsetName;
// true if the wide char encoding we use (i.e. ms_wcCharsetName) has
// different endian-ness than the native one
return result;
}
-const char *wxMBConv_iconv::ms_wcCharsetName = NULL;
+wxString wxMBConv_iconv::ms_wcCharsetName;
bool wxMBConv_iconv::ms_wcNeedsSwap = false;
wxMBConv_iconv::wxMBConv_iconv(const wxChar *name)
const wxCharBuffer cname(wxString(name).ToAscii());
// check for charset that represents wchar_t:
- if (ms_wcCharsetName == NULL)
+ if ( ms_wcCharsetName.empty() )
{
- ms_wcNeedsSwap = false;
+ wxLogTrace(TRACE_STRCONV, _T("Looking for wide char codeset:"));
- // try charset with explicit bytesex info (e.g. "UCS-4LE"):
- ms_wcCharsetName = WC_NAME_BEST;
- m2w = iconv_open(ms_wcCharsetName, cname);
+#if wxUSE_FONTMAP
+ const wxChar **names = wxFontMapperBase::GetAllEncodingNames(WC_ENC);
+#else // !wxUSE_FONTMAP
+ static const wxChar *names[] =
+ {
+#if SIZEOF_WCHAR_T == 4
+ _T("UCS-4"),
+#elif SIZEOF_WCHAR_T = 2
+ _T("UCS-2"),
+#endif
+ NULL
+ };
+#endif // wxUSE_FONTMAP/!wxUSE_FONTMAP
- if (m2w == (iconv_t)-1)
+ for ( ; *names && ms_wcCharsetName.empty(); ++names )
{
- // try charset w/o bytesex info (e.g. "UCS4")
- // and check for bytesex ourselves:
- ms_wcCharsetName = WC_NAME;
- m2w = iconv_open(ms_wcCharsetName, cname);
+ const wxString nameCS(*names);
- // last bet, try if it knows WCHAR_T pseudo-charset
- if (m2w == (iconv_t)-1)
- {
- ms_wcCharsetName = "WCHAR_T";
- m2w = iconv_open(ms_wcCharsetName, cname);
- }
+ // first try charset with explicit bytesex info (e.g. "UCS-4LE"):
+ wxString nameXE(nameCS);
+ #ifdef WORDS_BIGENDIAN
+ nameXE += _T("BE");
+ #else // little endian
+ nameXE += _T("LE");
+ #endif
+
+ wxLogTrace(TRACE_STRCONV, _T(" trying charset \"%s\""),
+ nameXE.c_str());
- if (m2w != (iconv_t)-1)
+ m2w = iconv_open(nameXE.ToAscii(), cname);
+ if ( m2w == ICONV_T_INVALID )
{
- 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;
-
- res = iconv(m2w, ICONV_CHAR_CAST(&bufPtr), &insz,
- (char**)&wbufPtr, &outsz);
-
- if (ICONV_FAILED(res, insz))
- {
- ms_wcCharsetName = NULL;
- wxLogLastError(wxT("iconv"));
- wxLogError(_("Conversion to charset '%s' doesn't work."), name);
- }
- else
+ // try charset w/o bytesex info (e.g. "UCS4")
+ wxLogTrace(TRACE_STRCONV, _T(" trying charset \"%s\""),
+ nameCS.c_str());
+ m2w = iconv_open(nameCS.ToAscii(), cname);
+
+ // and check for bytesex ourselves:
+ if ( m2w != ICONV_T_INVALID )
{
- ms_wcNeedsSwap = wbuf[0] != (wchar_t)buf[0];
+ 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;
+
+ res = iconv(m2w, ICONV_CHAR_CAST(&bufPtr), &insz,
+ (char**)&wbufPtr, &outsz);
+
+ if (ICONV_FAILED(res, insz))
+ {
+ wxLogLastError(wxT("iconv"));
+ wxLogError(_("Conversion to charset '%s' doesn't work."),
+ nameCS.c_str());
+ }
+ else // ok, can convert to this encoding, remember it
+ {
+ ms_wcCharsetName = nameCS;
+ ms_wcNeedsSwap = wbuf[0] != (wchar_t)buf[0];
+ }
}
}
- else
+ else // use charset not requiring byte swapping
{
- ms_wcCharsetName = NULL;
-
- // VS: we must not output an error here, since wxWidgets will safely
- // fall back to using wxEncodingConverter.
- wxLogTrace(TRACE_STRCONV, wxT("Impossible to convert to/from charset '%s' with iconv, falling back to wxEncodingConverter."), name);
+ ms_wcCharsetName = nameXE;
}
}
+
wxLogTrace(TRACE_STRCONV,
- wxT("wchar_t charset is '%s', needs swap: %i"),
- ms_wcCharsetName ? ms_wcCharsetName : "<none>", ms_wcNeedsSwap);
+ wxT("iconv wchar_t charset is \"%s\"%s"),
+ ms_wcCharsetName.empty() ? _T("<none>")
+ : ms_wcCharsetName.c_str(),
+ ms_wcNeedsSwap ? _T(" (needs swap)")
+ : _T(""));
}
else // we already have ms_wcCharsetName
{
- m2w = iconv_open(ms_wcCharsetName, cname);
+ m2w = iconv_open(ms_wcCharsetName.ToAscii(), cname);
}
- // NB: don't ever pass NULL to iconv_open(), it may crash!
- if ( ms_wcCharsetName )
+ if ( ms_wcCharsetName.empty() )
{
- w2m = iconv_open( cname, ms_wcCharsetName);
+ w2m = ICONV_T_INVALID;
}
else
{
- w2m = (iconv_t)-1;
+ w2m = iconv_open(cname, ms_wcCharsetName.ToAscii());
+ if ( w2m == ICONV_T_INVALID )
+ {
+ wxLogTrace(TRACE_STRCONV,
+ wxT("\"%s\" -> \"%s\" works but not the converse!?"),
+ ms_wcCharsetName.c_str(), cname.data());
+ }
}
}
wxMBConv_iconv::~wxMBConv_iconv()
{
- if ( m2w != (iconv_t)-1 )
+ if ( m2w != ICONV_T_INVALID )
iconv_close(m2w);
- if ( w2m != (iconv_t)-1 )
+ if ( w2m != ICONV_T_INVALID )
iconv_close(w2m);
}
if (ms_wcNeedsSwap)
{
// convert to native endianness
- WC_BSWAP(buf /* _not_ bufPtr */, res)
+ for ( unsigned i = 0; i < res; i++ )
+ buf[n] = WC_BSWAP(buf[i]);
}
// NB: iconv was given only strlen(psz) characters on input, and so
wxMutexLocker lock(wxConstCast(this, wxMBConv_iconv)->m_iconvMutex);
#endif
- size_t inbuf = wxWcslen(psz) * SIZEOF_WCHAR_T;
+ size_t inlen = wxWcslen(psz);
+ size_t inbuf = inlen * SIZEOF_WCHAR_T;
size_t outbuf = n;
size_t res, cres;
if (ms_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
+ // (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;
+ tmpbuf = (wchar_t *)malloc(inbuf + SIZEOF_WCHAR_T);
+ for ( size_t i = 0; i < inlen; i++ )
+ tmpbuf[n] = WC_BSWAP(psz[i]);
+ tmpbuf[inlen] = L'\0';
+ psz = tmpbuf;
}
if (buf)
if (ICONV_FAILED(cres, inbuf))
{
- //VS: it is ok if iconv fails, hence trace only
wxLogTrace(TRACE_STRCONV, wxT("iconv failed: %s"), wxSysErrorMsg(wxSysErrorCode()));
return (size_t)-1;
}
// own wxMBConvUTF7 doesn't detect errors (e.g. lone "+" which is
// explicitly ill-formed according to RFC 2152) neither so we don't
// even have any fallback here...
- int flags = m_CodePage == CP_UTF7 ? 0 : MB_ERR_INVALID_CHARS;
+ //
+ // Moreover, MB_ERR_INVALID_CHARS is only supported on Win 2K SP4 or
+ // Win XP or newer and if it is specified on older versions, conversion
+ // from CP_UTF8 (which can have flags only 0 or MB_ERR_INVALID_CHARS)
+ // fails. So we can only use the flag on newer Windows versions.
+ // Additionally, the flag is not supported by UTF7, symbol and CJK
+ // encodings. See here:
+ // http://blogs.msdn.com/michkap/archive/2005/04/19/409566.aspx
+ // http://msdn.microsoft.com/library/en-us/intl/unicode_17si.asp
+ int flags = 0;
+ if ( m_CodePage != CP_UTF7 && m_CodePage != CP_SYMBOL &&
+ m_CodePage < 50000 &&
+ IsAtLeastWin2kSP4() )
+ {
+ flags = MB_ERR_INVALID_CHARS;
+ }
+ else if ( m_CodePage == CP_UTF8 )
+ {
+ // Avoid round-trip in the special case of UTF-8 by using our
+ // own UTF-8 conversion code:
+ return wxMBConvUTF8().MB2WC(buf, psz, n);
+ }
const size_t len = ::MultiByteToWideChar
(
buf, // output string
buf ? n : 0 // size of output buffer
);
+ if ( !len )
+ {
+ // function totally failed
+ return (size_t)-1;
+ }
+
+ // if we were really converting and didn't use MB_ERR_INVALID_CHARS,
+ // check if we succeeded, by doing a double trip:
+ if ( !flags && buf )
+ {
+ wxCharBuffer mbBuf(n);
+ if ( ::WideCharToMultiByte
+ (
+ m_CodePage,
+ 0,
+ buf,
+ -1,
+ mbBuf.data(),
+ n,
+ NULL,
+ NULL
+ ) == 0 ||
+ strcmp(mbBuf, psz) != 0 )
+ {
+ // we didn't obtain the same thing we started from, hence
+ // the conversion was lossy and we consider that it failed
+ return (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;
+ return len - 1;
}
size_t WC2MB(char *buf, const wchar_t *pwz, size_t n) const
return s_isWin98Or2k == 1;
}
+ static bool IsAtLeastWin2kSP4()
+ {
+#ifdef __WXWINCE__
+ return false;
+#else
+ static int s_isAtLeastWin2kSP4 = -1;
+
+ if ( s_isAtLeastWin2kSP4 == -1 )
+ {
+ OSVERSIONINFOEX ver;
+
+ memset(&ver, 0, sizeof(ver));
+ ver.dwOSVersionInfoSize = sizeof(ver);
+ GetVersionEx((OSVERSIONINFO*)&ver);
+
+ s_isAtLeastWin2kSP4 =
+ ((ver.dwMajorVersion > 5) || // Vista+
+ (ver.dwMajorVersion == 5 && ver.dwMinorVersion > 0) || // XP/2003
+ (ver.dwMajorVersion == 5 && ver.dwMinorVersion == 0 &&
+ ver.wServicePackMajor >= 4)) // 2000 SP4+
+ ? 1 : 0;
+ }
+
+ return s_isAtLeastWin2kSP4 == 1;
+#endif
+ }
+
long m_CodePage;
};
SetName(charset);
}
+#if wxUSE_FONTMAP
+ m_encoding = wxFontMapperBase::GetEncodingFromName(charset);
+#else
m_encoding = wxFONTENCODING_SYSTEM;
+#endif
}
wxCSConv::wxCSConv(wxFontEncoding encoding)
// 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 )
+ if ( m_encoding == wxFONTENCODING_ISO8859_1 ||
+ m_encoding == wxFONTENCODING_DEFAULT )
{
// don't convert at all
return NULL;
delete conv;
}
- gs_nameCache[encoding] = ""; // cache the failure
+ gs_nameCache[encoding] = _T(""); // cache the failure
}
#endif // wxUSE_FONTMAP
}
wxConvUTF8;
#endif // wxUSE_WCHAR_T/!wxUSE_WCHAR_T
-
-
projects / wxWidgets.git / blobdiff