1 /////////////////////////////////////////////////////////////////////////////
2 // Name: src/common/strconv.cpp
3 // Purpose: Unicode conversion classes
4 // Author: Ove Kaaven, Robert Roebling, Vadim Zeitlin, Vaclav Slavik,
5 // Ryan Norton, Fredrik Roubert (UTF7)
9 // Copyright: (c) 1999 Ove Kaaven, Robert Roebling, Vaclav Slavik
10 // (c) 2000-2003 Vadim Zeitlin
11 // (c) 2004 Ryan Norton, Fredrik Roubert
12 // Licence: wxWindows licence
13 /////////////////////////////////////////////////////////////////////////////
15 // ============================================================================
17 // ============================================================================
19 // ----------------------------------------------------------------------------
21 // ----------------------------------------------------------------------------
23 // For compilers that support precompilation, includes "wx.h".
24 #include "wx/wxprec.h"
35 #include "wx/strconv.h"
40 #include "wx/msw/private.h"
41 #include "wx/msw/missing.h"
52 #if defined(__WIN32__) && !defined(__WXMICROWIN__)
53 #define wxHAVE_WIN32_MB2WC
54 #endif // __WIN32__ but !__WXMICROWIN__
62 #include "wx/thread.h"
65 #include "wx/encconv.h"
66 #include "wx/fontmap.h"
71 #include <ATSUnicode.h>
72 #include <TextCommon.h>
73 #include <TextEncodingConverter.h>
76 #include "wx/mac/private.h" // includes mac headers
79 #define TRACE_STRCONV _T("strconv")
81 #if SIZEOF_WCHAR_T == 2
85 // ============================================================================
87 // ============================================================================
89 // ----------------------------------------------------------------------------
90 // UTF-16 en/decoding to/from UCS-4
91 // ----------------------------------------------------------------------------
94 static size_t encode_utf16(wxUint32 input
, wxUint16
*output
)
99 *output
= (wxUint16
) input
;
102 else if (input
>=0x110000)
110 *output
++ = (wxUint16
) ((input
>> 10)+0xd7c0);
111 *output
= (wxUint16
) ((input
&0x3ff)+0xdc00);
117 static size_t decode_utf16(const wxUint16
* input
, wxUint32
& output
)
119 if ((*input
<0xd800) || (*input
>0xdfff))
124 else if ((input
[1]<0xdc00) || (input
[1]>0xdfff))
131 output
= ((input
[0] - 0xd7c0) << 10) + (input
[1] - 0xdc00);
137 // ----------------------------------------------------------------------------
139 // ----------------------------------------------------------------------------
141 wxMBConv::~wxMBConv()
143 // nothing to do here (necessary for Darwin linking probably)
146 const wxWCharBuffer
wxMBConv::cMB2WC(const char *psz
) const
150 // calculate the length of the buffer needed first
151 size_t nLen
= MB2WC(NULL
, psz
, 0);
152 if ( nLen
!= (size_t)-1 )
154 // now do the actual conversion
155 wxWCharBuffer
buf(nLen
);
156 nLen
= MB2WC(buf
.data(), psz
, nLen
+ 1); // with the trailing NULL
157 if ( nLen
!= (size_t)-1 )
164 wxWCharBuffer
buf((wchar_t *)NULL
);
169 const wxCharBuffer
wxMBConv::cWC2MB(const wchar_t *pwz
) const
173 size_t nLen
= WC2MB(NULL
, pwz
, 0);
174 if ( nLen
!= (size_t)-1 )
176 wxCharBuffer
buf(nLen
+3); // space for a wxUint32 trailing zero
177 nLen
= WC2MB(buf
.data(), pwz
, nLen
+ 4);
178 if ( nLen
!= (size_t)-1 )
185 wxCharBuffer
buf((char *)NULL
);
190 const wxWCharBuffer
wxMBConv::cMB2WC(const char *szString
, size_t nStringLen
, size_t* pOutSize
) const
192 wxASSERT(pOutSize
!= NULL
);
194 const char* szEnd
= szString
+ nStringLen
+ 1;
195 const char* szPos
= szString
;
196 const char* szStart
= szPos
;
198 size_t nActualLength
= 0;
199 size_t nCurrentSize
= nStringLen
; //try normal size first (should never resize?)
201 wxWCharBuffer
theBuffer(nCurrentSize
);
203 //Convert the string until the length() is reached, continuing the
204 //loop every time a null character is reached
205 while(szPos
!= szEnd
)
207 wxASSERT(szPos
< szEnd
); //something is _really_ screwed up if this rings true
209 //Get the length of the current (sub)string
210 size_t nLen
= MB2WC(NULL
, szPos
, 0);
212 //Invalid conversion?
213 if( nLen
== (size_t)-1 )
216 theBuffer
.data()[0u] = wxT('\0');
221 //Increase the actual length (+1 for current null character)
222 nActualLength
+= nLen
+ 1;
224 //if buffer too big, realloc the buffer
225 if (nActualLength
> (nCurrentSize
+1))
227 wxWCharBuffer
theNewBuffer(nCurrentSize
<< 1);
228 memcpy(theNewBuffer
.data(), theBuffer
.data(), nCurrentSize
* sizeof(wchar_t));
229 theBuffer
= theNewBuffer
;
233 //Convert the current (sub)string
234 if ( MB2WC(&theBuffer
.data()[szPos
- szStart
], szPos
, nLen
+ 1) == (size_t)-1 )
237 theBuffer
.data()[0u] = wxT('\0');
241 //Increment to next (sub)string
242 //Note that we have to use strlen instead of nLen here
243 //because XX2XX gives us the size of the output buffer,
244 //which is not necessarily the length of the string
245 szPos
+= strlen(szPos
) + 1;
248 //success - return actual length and the buffer
249 *pOutSize
= nActualLength
;
253 const wxCharBuffer
wxMBConv::cWC2MB(const wchar_t *szString
, size_t nStringLen
, size_t* pOutSize
) const
255 wxASSERT(pOutSize
!= NULL
);
257 const wchar_t* szEnd
= szString
+ nStringLen
+ 1;
258 const wchar_t* szPos
= szString
;
259 const wchar_t* szStart
= szPos
;
261 size_t nActualLength
= 0;
262 size_t nCurrentSize
= nStringLen
<< 2; //try * 4 first
264 wxCharBuffer
theBuffer(nCurrentSize
);
266 //Convert the string until the length() is reached, continuing the
267 //loop every time a null character is reached
268 while(szPos
!= szEnd
)
270 wxASSERT(szPos
< szEnd
); //something is _really_ screwed up if this rings true
272 //Get the length of the current (sub)string
273 size_t nLen
= WC2MB(NULL
, szPos
, 0);
275 //Invalid conversion?
276 if( nLen
== (size_t)-1 )
279 theBuffer
.data()[0u] = wxT('\0');
283 //Increase the actual length (+1 for current null character)
284 nActualLength
+= nLen
+ 1;
286 //if buffer too big, realloc the buffer
287 if (nActualLength
> (nCurrentSize
+1))
289 wxCharBuffer
theNewBuffer(nCurrentSize
<< 1);
290 memcpy(theNewBuffer
.data(), theBuffer
.data(), nCurrentSize
);
291 theBuffer
= theNewBuffer
;
295 //Convert the current (sub)string
296 if(WC2MB(&theBuffer
.data()[szPos
- szStart
], szPos
, nLen
+ 1) == (size_t)-1 )
299 theBuffer
.data()[0u] = wxT('\0');
303 //Increment to next (sub)string
304 //Note that we have to use wxWcslen instead of nLen here
305 //because XX2XX gives us the size of the output buffer,
306 //which is not necessarily the length of the string
307 szPos
+= wxWcslen(szPos
) + 1;
310 //success - return actual length and the buffer
311 *pOutSize
= nActualLength
;
315 // ----------------------------------------------------------------------------
317 // ----------------------------------------------------------------------------
319 size_t wxMBConvLibc::MB2WC(wchar_t *buf
, const char *psz
, size_t n
) const
321 return wxMB2WC(buf
, psz
, n
);
324 size_t wxMBConvLibc::WC2MB(char *buf
, const wchar_t *psz
, size_t n
) const
326 return wxWC2MB(buf
, psz
, n
);
331 // ----------------------------------------------------------------------------
332 // wxConvBrokenFileNames
333 // ----------------------------------------------------------------------------
335 wxConvBrokenFileNames::wxConvBrokenFileNames(const wxChar
*charset
)
337 if ( !charset
|| wxStricmp(charset
, _T("UTF-8")) == 0
338 || wxStricmp(charset
, _T("UTF8")) == 0 )
339 m_conv
= new wxMBConvUTF8(wxMBConvUTF8::MAP_INVALID_UTF8_TO_OCTAL
);
341 m_conv
= new wxCSConv(charset
);
345 wxConvBrokenFileNames::MB2WC(wchar_t *outputBuf
,
347 size_t outputSize
) const
349 return m_conv
->MB2WC( outputBuf
, psz
, outputSize
);
353 wxConvBrokenFileNames::WC2MB(char *outputBuf
,
355 size_t outputSize
) const
357 return m_conv
->WC2MB( outputBuf
, psz
, outputSize
);
362 // ----------------------------------------------------------------------------
364 // ----------------------------------------------------------------------------
366 // Implementation (C) 2004 Fredrik Roubert
369 // BASE64 decoding table
371 static const unsigned char utf7unb64
[] =
373 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff,
374 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff,
375 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff,
376 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff,
377 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff,
378 0xff, 0xff, 0xff, 0x3e, 0xff, 0xff, 0xff, 0x3f,
379 0x34, 0x35, 0x36, 0x37, 0x38, 0x39, 0x3a, 0x3b,
380 0x3c, 0x3d, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff,
381 0xff, 0x00, 0x01, 0x02, 0x03, 0x04, 0x05, 0x06,
382 0x07, 0x08, 0x09, 0x0a, 0x0b, 0x0c, 0x0d, 0x0e,
383 0x0f, 0x10, 0x11, 0x12, 0x13, 0x14, 0x15, 0x16,
384 0x17, 0x18, 0x19, 0xff, 0xff, 0xff, 0xff, 0xff,
385 0xff, 0x1a, 0x1b, 0x1c, 0x1d, 0x1e, 0x1f, 0x20,
386 0x21, 0x22, 0x23, 0x24, 0x25, 0x26, 0x27, 0x28,
387 0x29, 0x2a, 0x2b, 0x2c, 0x2d, 0x2e, 0x2f, 0x30,
388 0x31, 0x32, 0x33, 0xff, 0xff, 0xff, 0xff, 0xff,
389 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff,
390 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff,
391 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff,
392 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff,
393 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff,
394 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff,
395 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff,
396 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff,
397 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff,
398 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff,
399 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff,
400 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff,
401 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff,
402 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff,
403 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff,
404 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff
407 size_t wxMBConvUTF7::MB2WC(wchar_t *buf
, const char *psz
, size_t n
) const
411 while (*psz
&& ((!buf
) || (len
< n
)))
413 unsigned char cc
= *psz
++;
421 else if (*psz
== '-')
431 // BASE64 encoded string
435 for (lsb
= false, d
= 0, l
= 0;
436 (cc
= utf7unb64
[(unsigned char)*psz
]) != 0xff; psz
++)
440 for (l
+= 6; l
>= 8; lsb
= !lsb
)
442 c
= (unsigned char)((d
>> (l
-= 8)) % 256);
451 *buf
= (wchar_t)(c
<< 8);
458 if (buf
&& (len
< n
))
464 // BASE64 encoding table
466 static const unsigned char utf7enb64
[] =
468 'A', 'B', 'C', 'D', 'E', 'F', 'G', 'H',
469 'I', 'J', 'K', 'L', 'M', 'N', 'O', 'P',
470 'Q', 'R', 'S', 'T', 'U', 'V', 'W', 'X',
471 'Y', 'Z', 'a', 'b', 'c', 'd', 'e', 'f',
472 'g', 'h', 'i', 'j', 'k', 'l', 'm', 'n',
473 'o', 'p', 'q', 'r', 's', 't', 'u', 'v',
474 'w', 'x', 'y', 'z', '0', '1', '2', '3',
475 '4', '5', '6', '7', '8', '9', '+', '/'
479 // UTF-7 encoding table
481 // 0 - Set D (directly encoded characters)
482 // 1 - Set O (optional direct characters)
483 // 2 - whitespace characters (optional)
484 // 3 - special characters
486 static const unsigned char utf7encode
[128] =
488 3, 3, 3, 3, 3, 3, 3, 3, 3, 2, 2, 3, 3, 2, 3, 3,
489 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3,
490 2, 1, 1, 1, 1, 1, 1, 0, 0, 0, 1, 3, 0, 0, 0, 3,
491 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 1, 1, 1, 1, 0,
492 1, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
493 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 1, 3, 1, 1, 1,
494 1, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
495 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 1, 1, 1, 3, 3
498 size_t wxMBConvUTF7::WC2MB(char *buf
, const wchar_t *psz
, size_t n
) const
504 while (*psz
&& ((!buf
) || (len
< n
)))
507 if (cc
< 0x80 && utf7encode
[cc
] < 1)
515 else if (((wxUint32
)cc
) > 0xffff)
517 // no surrogate pair generation (yet?)
528 // BASE64 encode string
529 unsigned int lsb
, d
, l
;
530 for (d
= 0, l
= 0; /*nothing*/; psz
++)
532 for (lsb
= 0; lsb
< 2; lsb
++)
535 d
+= lsb
? cc
& 0xff : (cc
& 0xff00) >> 8;
537 for (l
+= 8; l
>= 6; )
541 *buf
++ = utf7enb64
[(d
>> l
) % 64];
546 if (!(cc
) || (cc
< 0x80 && utf7encode
[cc
] < 1))
552 *buf
++ = utf7enb64
[((d
% 16) << (6 - l
)) % 64];
561 if (buf
&& (len
< n
))
566 // ----------------------------------------------------------------------------
568 // ----------------------------------------------------------------------------
570 static wxUint32 utf8_max
[]=
571 { 0x7f, 0x7ff, 0xffff, 0x1fffff, 0x3ffffff, 0x7fffffff, 0xffffffff };
573 // boundaries of the private use area we use to (temporarily) remap invalid
574 // characters invalid in a UTF-8 encoded string
575 const wxUint32 wxUnicodePUA
= 0x100000;
576 const wxUint32 wxUnicodePUAEnd
= wxUnicodePUA
+ 256;
578 size_t wxMBConvUTF8::MB2WC(wchar_t *buf
, const char *psz
, size_t n
) const
582 while (*psz
&& ((!buf
) || (len
< n
)))
584 const char *opsz
= psz
;
585 bool invalid
= false;
586 unsigned char cc
= *psz
++, fc
= cc
;
588 for (cnt
= 0; fc
& 0x80; cnt
++)
597 // escape the escape character for octal escapes
598 if ((m_options
& MAP_INVALID_UTF8_TO_OCTAL
)
599 && cc
== '\\' && (!buf
|| len
< n
))
611 // invalid UTF-8 sequence
616 unsigned ocnt
= cnt
- 1;
617 wxUint32 res
= cc
& (0x3f >> cnt
);
621 if ((cc
& 0xC0) != 0x80)
623 // invalid UTF-8 sequence
628 res
= (res
<< 6) | (cc
& 0x3f);
630 if (invalid
|| res
<= utf8_max
[ocnt
])
632 // illegal UTF-8 encoding
635 else if ((m_options
& MAP_INVALID_UTF8_TO_PUA
) &&
636 res
>= wxUnicodePUA
&& res
< wxUnicodePUAEnd
)
638 // if one of our PUA characters turns up externally
639 // it must also be treated as an illegal sequence
640 // (a bit like you have to escape an escape character)
646 // cast is ok because wchar_t == wxUuint16 if WC_UTF16
647 size_t pa
= encode_utf16(res
, (wxUint16
*)buf
);
648 if (pa
== (size_t)-1)
660 *buf
++ = (wchar_t)res
;
662 #endif // WC_UTF16/!WC_UTF16
667 if (m_options
& MAP_INVALID_UTF8_TO_PUA
)
669 while (opsz
< psz
&& (!buf
|| len
< n
))
672 // cast is ok because wchar_t == wxUuint16 if WC_UTF16
673 size_t pa
= encode_utf16((unsigned char)*opsz
+ wxUnicodePUA
, (wxUint16
*)buf
);
674 wxASSERT(pa
!= (size_t)-1);
681 *buf
++ = (wchar_t)(wxUnicodePUA
+ (unsigned char)*opsz
);
687 else if (m_options
& MAP_INVALID_UTF8_TO_OCTAL
)
689 while (opsz
< psz
&& (!buf
|| len
< n
))
691 if ( buf
&& len
+ 3 < n
)
693 unsigned char on
= *opsz
;
695 *buf
++ = (wchar_t)( L
'0' + on
/ 0100 );
696 *buf
++ = (wchar_t)( L
'0' + (on
% 0100) / 010 );
697 *buf
++ = (wchar_t)( L
'0' + on
% 010 );
703 else // MAP_INVALID_UTF8_NOT
710 if (buf
&& (len
< n
))
715 static inline bool isoctal(wchar_t wch
)
717 return L
'0' <= wch
&& wch
<= L
'7';
720 size_t wxMBConvUTF8::WC2MB(char *buf
, const wchar_t *psz
, size_t n
) const
724 while (*psz
&& ((!buf
) || (len
< n
)))
728 // cast is ok for WC_UTF16
729 size_t pa
= decode_utf16((const wxUint16
*)psz
, cc
);
730 psz
+= (pa
== (size_t)-1) ? 1 : pa
;
732 cc
=(*psz
++) & 0x7fffffff;
735 if ( (m_options
& MAP_INVALID_UTF8_TO_PUA
)
736 && cc
>= wxUnicodePUA
&& cc
< wxUnicodePUAEnd
)
739 *buf
++ = (char)(cc
- wxUnicodePUA
);
742 else if ( (m_options
& MAP_INVALID_UTF8_TO_OCTAL
)
743 && cc
== L
'\\' && psz
[0] == L
'\\' )
750 else if ( (m_options
& MAP_INVALID_UTF8_TO_OCTAL
) &&
752 isoctal(psz
[0]) && isoctal(psz
[1]) && isoctal(psz
[2]) )
756 *buf
++ = (char) ((psz
[0] - L
'0')*0100 +
757 (psz
[1] - L
'0')*010 +
767 for (cnt
= 0; cc
> utf8_max
[cnt
]; cnt
++) {}
781 *buf
++ = (char) ((-128 >> cnt
) | ((cc
>> (cnt
* 6)) & (0x3f >> cnt
)));
783 *buf
++ = (char) (0x80 | ((cc
>> (cnt
* 6)) & 0x3f));
795 // ----------------------------------------------------------------------------
797 // ----------------------------------------------------------------------------
799 #ifdef WORDS_BIGENDIAN
800 #define wxMBConvUTF16straight wxMBConvUTF16BE
801 #define wxMBConvUTF16swap wxMBConvUTF16LE
803 #define wxMBConvUTF16swap wxMBConvUTF16BE
804 #define wxMBConvUTF16straight wxMBConvUTF16LE
810 // copy 16bit MB to 16bit String
811 size_t wxMBConvUTF16straight::MB2WC(wchar_t *buf
, const char *psz
, size_t n
) const
815 while (*(wxUint16
*)psz
&& (!buf
|| len
< n
))
818 *buf
++ = *(wxUint16
*)psz
;
821 psz
+= sizeof(wxUint16
);
823 if (buf
&& len
<n
) *buf
=0;
829 // copy 16bit String to 16bit MB
830 size_t wxMBConvUTF16straight::WC2MB(char *buf
, const wchar_t *psz
, size_t n
) const
834 while (*psz
&& (!buf
|| len
< n
))
838 *(wxUint16
*)buf
= *psz
;
839 buf
+= sizeof(wxUint16
);
841 len
+= sizeof(wxUint16
);
844 if (buf
&& len
<=n
-sizeof(wxUint16
)) *(wxUint16
*)buf
=0;
850 // swap 16bit MB to 16bit String
851 size_t wxMBConvUTF16swap::MB2WC(wchar_t *buf
, const char *psz
, size_t n
) const
855 while (*(wxUint16
*)psz
&& (!buf
|| len
< n
))
859 ((char *)buf
)[0] = psz
[1];
860 ((char *)buf
)[1] = psz
[0];
864 psz
+= sizeof(wxUint16
);
866 if (buf
&& len
<n
) *buf
=0;
872 // swap 16bit MB to 16bit String
873 size_t wxMBConvUTF16swap::WC2MB(char *buf
, const wchar_t *psz
, size_t n
) const
877 while (*psz
&& (!buf
|| len
< n
))
881 *buf
++ = ((char*)psz
)[1];
882 *buf
++ = ((char*)psz
)[0];
884 len
+= sizeof(wxUint16
);
887 if (buf
&& len
<=n
-sizeof(wxUint16
)) *(wxUint16
*)buf
=0;
896 // copy 16bit MB to 32bit String
897 size_t wxMBConvUTF16straight::MB2WC(wchar_t *buf
, const char *psz
, size_t n
) const
901 while (*(wxUint16
*)psz
&& (!buf
|| len
< n
))
904 size_t pa
=decode_utf16((wxUint16
*)psz
, cc
);
905 if (pa
== (size_t)-1)
909 *buf
++ = (wchar_t)cc
;
911 psz
+= pa
* sizeof(wxUint16
);
913 if (buf
&& len
<n
) *buf
=0;
919 // copy 32bit String to 16bit MB
920 size_t wxMBConvUTF16straight::WC2MB(char *buf
, const wchar_t *psz
, size_t n
) const
924 while (*psz
&& (!buf
|| len
< n
))
927 size_t pa
=encode_utf16(*psz
, cc
);
929 if (pa
== (size_t)-1)
934 *(wxUint16
*)buf
= cc
[0];
935 buf
+= sizeof(wxUint16
);
938 *(wxUint16
*)buf
= cc
[1];
939 buf
+= sizeof(wxUint16
);
943 len
+= pa
*sizeof(wxUint16
);
946 if (buf
&& len
<=n
-sizeof(wxUint16
)) *(wxUint16
*)buf
=0;
952 // swap 16bit MB to 32bit String
953 size_t wxMBConvUTF16swap::MB2WC(wchar_t *buf
, const char *psz
, size_t n
) const
957 while (*(wxUint16
*)psz
&& (!buf
|| len
< n
))
961 tmp
[0]=psz
[1]; tmp
[1]=psz
[0];
962 tmp
[2]=psz
[3]; tmp
[3]=psz
[2];
964 size_t pa
=decode_utf16((wxUint16
*)tmp
, cc
);
965 if (pa
== (size_t)-1)
969 *buf
++ = (wchar_t)cc
;
972 psz
+= pa
* sizeof(wxUint16
);
974 if (buf
&& len
<n
) *buf
=0;
980 // swap 32bit String to 16bit MB
981 size_t wxMBConvUTF16swap::WC2MB(char *buf
, const wchar_t *psz
, size_t n
) const
985 while (*psz
&& (!buf
|| len
< n
))
988 size_t pa
=encode_utf16(*psz
, cc
);
990 if (pa
== (size_t)-1)
995 *buf
++ = ((char*)cc
)[1];
996 *buf
++ = ((char*)cc
)[0];
999 *buf
++ = ((char*)cc
)[3];
1000 *buf
++ = ((char*)cc
)[2];
1004 len
+= pa
*sizeof(wxUint16
);
1007 if (buf
&& len
<=n
-sizeof(wxUint16
)) *(wxUint16
*)buf
=0;
1015 // ----------------------------------------------------------------------------
1017 // ----------------------------------------------------------------------------
1019 #ifdef WORDS_BIGENDIAN
1020 #define wxMBConvUTF32straight wxMBConvUTF32BE
1021 #define wxMBConvUTF32swap wxMBConvUTF32LE
1023 #define wxMBConvUTF32swap wxMBConvUTF32BE
1024 #define wxMBConvUTF32straight wxMBConvUTF32LE
1028 WXDLLIMPEXP_DATA_BASE(wxMBConvUTF32LE
) wxConvUTF32LE
;
1029 WXDLLIMPEXP_DATA_BASE(wxMBConvUTF32BE
) wxConvUTF32BE
;
1034 // copy 32bit MB to 16bit String
1035 size_t wxMBConvUTF32straight::MB2WC(wchar_t *buf
, const char *psz
, size_t n
) const
1039 while (*(wxUint32
*)psz
&& (!buf
|| len
< n
))
1043 size_t pa
=encode_utf16(*(wxUint32
*)psz
, cc
);
1044 if (pa
== (size_t)-1)
1054 psz
+= sizeof(wxUint32
);
1056 if (buf
&& len
<n
) *buf
=0;
1062 // copy 16bit String to 32bit MB
1063 size_t wxMBConvUTF32straight::WC2MB(char *buf
, const wchar_t *psz
, size_t n
) const
1067 while (*psz
&& (!buf
|| len
< n
))
1071 // cast is ok for WC_UTF16
1072 size_t pa
= decode_utf16((const wxUint16
*)psz
, cc
);
1073 if (pa
== (size_t)-1)
1078 *(wxUint32
*)buf
= cc
;
1079 buf
+= sizeof(wxUint32
);
1081 len
+= sizeof(wxUint32
);
1085 if (buf
&& len
<=n
-sizeof(wxUint32
))
1093 // swap 32bit MB to 16bit String
1094 size_t wxMBConvUTF32swap::MB2WC(wchar_t *buf
, const char *psz
, size_t n
) const
1098 while (*(wxUint32
*)psz
&& (!buf
|| len
< n
))
1101 tmp
[0] = psz
[3]; tmp
[1] = psz
[2];
1102 tmp
[2] = psz
[1]; tmp
[3] = psz
[0];
1107 size_t pa
=encode_utf16(*(wxUint32
*)tmp
, cc
);
1108 if (pa
== (size_t)-1)
1118 psz
+= sizeof(wxUint32
);
1128 // swap 16bit String to 32bit MB
1129 size_t wxMBConvUTF32swap::WC2MB(char *buf
, const wchar_t *psz
, size_t n
) const
1133 while (*psz
&& (!buf
|| len
< n
))
1137 // cast is ok for WC_UTF16
1138 size_t pa
=decode_utf16((const wxUint16
*)psz
, *(wxUint32
*)cc
);
1139 if (pa
== (size_t)-1)
1149 len
+= sizeof(wxUint32
);
1153 if (buf
&& len
<=n
-sizeof(wxUint32
))
1162 // copy 32bit MB to 32bit String
1163 size_t wxMBConvUTF32straight::MB2WC(wchar_t *buf
, const char *psz
, size_t n
) const
1167 while (*(wxUint32
*)psz
&& (!buf
|| len
< n
))
1170 *buf
++ = (wchar_t)(*(wxUint32
*)psz
);
1172 psz
+= sizeof(wxUint32
);
1182 // copy 32bit String to 32bit MB
1183 size_t wxMBConvUTF32straight::WC2MB(char *buf
, const wchar_t *psz
, size_t n
) const
1187 while (*psz
&& (!buf
|| len
< n
))
1191 *(wxUint32
*)buf
= *psz
;
1192 buf
+= sizeof(wxUint32
);
1195 len
+= sizeof(wxUint32
);
1199 if (buf
&& len
<=n
-sizeof(wxUint32
))
1206 // swap 32bit MB to 32bit String
1207 size_t wxMBConvUTF32swap::MB2WC(wchar_t *buf
, const char *psz
, size_t n
) const
1211 while (*(wxUint32
*)psz
&& (!buf
|| len
< n
))
1215 ((char *)buf
)[0] = psz
[3];
1216 ((char *)buf
)[1] = psz
[2];
1217 ((char *)buf
)[2] = psz
[1];
1218 ((char *)buf
)[3] = psz
[0];
1222 psz
+= sizeof(wxUint32
);
1232 // swap 32bit String to 32bit MB
1233 size_t wxMBConvUTF32swap::WC2MB(char *buf
, const wchar_t *psz
, size_t n
) const
1237 while (*psz
&& (!buf
|| len
< n
))
1241 *buf
++ = ((char *)psz
)[3];
1242 *buf
++ = ((char *)psz
)[2];
1243 *buf
++ = ((char *)psz
)[1];
1244 *buf
++ = ((char *)psz
)[0];
1246 len
+= sizeof(wxUint32
);
1250 if (buf
&& len
<=n
-sizeof(wxUint32
))
1260 // ============================================================================
1261 // The classes doing conversion using the iconv_xxx() functions
1262 // ============================================================================
1266 // VS: glibc 2.1.3 is broken in that iconv() conversion to/from UCS4 fails with
1267 // E2BIG if output buffer is _exactly_ as big as needed. Such case is
1268 // (unless there's yet another bug in glibc) the only case when iconv()
1269 // returns with (size_t)-1 (which means error) and says there are 0 bytes
1270 // left in the input buffer -- when _real_ error occurs,
1271 // bytes-left-in-input buffer is non-zero. Hence, this alternative test for
1273 // [This bug does not appear in glibc 2.2.]
1274 #if defined(__GLIBC__) && __GLIBC__ == 2 && __GLIBC_MINOR__ <= 1
1275 #define ICONV_FAILED(cres, bufLeft) ((cres == (size_t)-1) && \
1276 (errno != E2BIG || bufLeft != 0))
1278 #define ICONV_FAILED(cres, bufLeft) (cres == (size_t)-1)
1281 #define ICONV_CHAR_CAST(x) ((ICONV_CONST char **)(x))
1283 #define ICONV_T_INVALID ((iconv_t)-1)
1285 #if SIZEOF_WCHAR_T == 4
1286 #define WC_BSWAP wxUINT32_SWAP_ALWAYS
1287 #define WC_ENC wxFONTENCODING_UTF32
1288 #elif SIZEOF_WCHAR_T == 2
1289 #define WC_BSWAP wxUINT16_SWAP_ALWAYS
1290 #define WC_ENC wxFONTENCODING_UTF16
1291 #else // sizeof(wchar_t) != 2 nor 4
1292 // does this ever happen?
1293 #error "Unknown sizeof(wchar_t): please report this to wx-dev@lists.wxwindows.org"
1296 // ----------------------------------------------------------------------------
1297 // wxMBConv_iconv: encapsulates an iconv character set
1298 // ----------------------------------------------------------------------------
1300 class wxMBConv_iconv
: public wxMBConv
1303 wxMBConv_iconv(const wxChar
*name
);
1304 virtual ~wxMBConv_iconv();
1306 virtual size_t MB2WC(wchar_t *buf
, const char *psz
, size_t n
) const;
1307 virtual size_t WC2MB(char *buf
, const wchar_t *psz
, size_t n
) const;
1310 { return (m2w
!= ICONV_T_INVALID
) && (w2m
!= ICONV_T_INVALID
); }
1313 // the iconv handlers used to translate from multibyte to wide char and in
1314 // the other direction
1318 // guards access to m2w and w2m objects
1319 wxMutex m_iconvMutex
;
1323 // the name (for iconv_open()) of a wide char charset -- if none is
1324 // available on this machine, it will remain NULL
1325 static wxString ms_wcCharsetName
;
1327 // true if the wide char encoding we use (i.e. ms_wcCharsetName) has
1328 // different endian-ness than the native one
1329 static bool ms_wcNeedsSwap
;
1332 // make the constructor available for unit testing
1333 WXDLLIMPEXP_BASE wxMBConv
* new_wxMBConv_iconv( const wxChar
* name
)
1335 wxMBConv_iconv
* result
= new wxMBConv_iconv( name
);
1336 if ( !result
->IsOk() )
1344 wxString
wxMBConv_iconv::ms_wcCharsetName
;
1345 bool wxMBConv_iconv::ms_wcNeedsSwap
= false;
1347 wxMBConv_iconv::wxMBConv_iconv(const wxChar
*name
)
1349 // iconv operates with chars, not wxChars, but luckily it uses only ASCII
1350 // names for the charsets
1351 const wxCharBuffer
cname(wxString(name
).ToAscii());
1353 // check for charset that represents wchar_t:
1354 if ( ms_wcCharsetName
.empty() )
1356 wxLogTrace(TRACE_STRCONV
, _T("Looking for wide char codeset:"));
1359 const wxChar
**names
= wxFontMapperBase::GetAllEncodingNames(WC_ENC
);
1360 #else // !wxUSE_FONTMAP
1361 static const wxChar
*names
[] =
1363 #if SIZEOF_WCHAR_T == 4
1365 #elif SIZEOF_WCHAR_T = 2
1370 #endif // wxUSE_FONTMAP/!wxUSE_FONTMAP
1372 for ( ; *names
&& ms_wcCharsetName
.empty(); ++names
)
1374 const wxString
nameCS(*names
);
1376 // first try charset with explicit bytesex info (e.g. "UCS-4LE"):
1377 wxString
nameXE(nameCS
);
1378 #ifdef WORDS_BIGENDIAN
1380 #else // little endian
1384 wxLogTrace(TRACE_STRCONV
, _T(" trying charset \"%s\""),
1387 m2w
= iconv_open(nameXE
.ToAscii(), cname
);
1388 if ( m2w
== ICONV_T_INVALID
)
1390 // try charset w/o bytesex info (e.g. "UCS4")
1391 wxLogTrace(TRACE_STRCONV
, _T(" trying charset \"%s\""),
1393 m2w
= iconv_open(nameCS
.ToAscii(), cname
);
1395 // and check for bytesex ourselves:
1396 if ( m2w
!= ICONV_T_INVALID
)
1398 char buf
[2], *bufPtr
;
1399 wchar_t wbuf
[2], *wbufPtr
;
1407 outsz
= SIZEOF_WCHAR_T
* 2;
1411 res
= iconv(m2w
, ICONV_CHAR_CAST(&bufPtr
), &insz
,
1412 (char**)&wbufPtr
, &outsz
);
1414 if (ICONV_FAILED(res
, insz
))
1416 wxLogLastError(wxT("iconv"));
1417 wxLogError(_("Conversion to charset '%s' doesn't work."),
1420 else // ok, can convert to this encoding, remember it
1422 ms_wcCharsetName
= nameCS
;
1423 ms_wcNeedsSwap
= wbuf
[0] != (wchar_t)buf
[0];
1427 else // use charset not requiring byte swapping
1429 ms_wcCharsetName
= nameXE
;
1433 wxLogTrace(TRACE_STRCONV
,
1434 wxT("iconv wchar_t charset is \"%s\"%s"),
1435 ms_wcCharsetName
.empty() ? _T("<none>")
1436 : ms_wcCharsetName
.c_str(),
1437 ms_wcNeedsSwap
? _T(" (needs swap)")
1440 else // we already have ms_wcCharsetName
1442 m2w
= iconv_open(ms_wcCharsetName
.ToAscii(), cname
);
1445 if ( ms_wcCharsetName
.empty() )
1447 w2m
= ICONV_T_INVALID
;
1451 w2m
= iconv_open(cname
, ms_wcCharsetName
.ToAscii());
1452 if ( w2m
== ICONV_T_INVALID
)
1454 wxLogTrace(TRACE_STRCONV
,
1455 wxT("\"%s\" -> \"%s\" works but not the converse!?"),
1456 ms_wcCharsetName
.c_str(), cname
.data());
1461 wxMBConv_iconv::~wxMBConv_iconv()
1463 if ( m2w
!= ICONV_T_INVALID
)
1465 if ( w2m
!= ICONV_T_INVALID
)
1469 size_t wxMBConv_iconv::MB2WC(wchar_t *buf
, const char *psz
, size_t n
) const
1472 // NB: iconv() is MT-safe, but each thread must use it's own iconv_t handle.
1473 // Unfortunately there is a couple of global wxCSConv objects such as
1474 // wxConvLocal that are used all over wx code, so we have to make sure
1475 // the handle is used by at most one thread at the time. Otherwise
1476 // only a few wx classes would be safe to use from non-main threads
1477 // as MB<->WC conversion would fail "randomly".
1478 wxMutexLocker
lock(wxConstCast(this, wxMBConv_iconv
)->m_iconvMutex
);
1481 size_t inbuf
= strlen(psz
);
1482 size_t outbuf
= n
* SIZEOF_WCHAR_T
;
1484 // VS: Use these instead of psz, buf because iconv() modifies its arguments:
1485 wchar_t *bufPtr
= buf
;
1486 const char *pszPtr
= psz
;
1490 // have destination buffer, convert there
1492 ICONV_CHAR_CAST(&pszPtr
), &inbuf
,
1493 (char**)&bufPtr
, &outbuf
);
1494 res
= n
- (outbuf
/ SIZEOF_WCHAR_T
);
1498 // convert to native endianness
1499 for ( unsigned i
= 0; i
< res
; i
++ )
1500 buf
[n
] = WC_BSWAP(buf
[i
]);
1503 // NB: iconv was given only strlen(psz) characters on input, and so
1504 // it couldn't convert the trailing zero. Let's do it ourselves
1505 // if there's some room left for it in the output buffer.
1511 // no destination buffer... convert using temp buffer
1512 // to calculate destination buffer requirement
1517 outbuf
= 8*SIZEOF_WCHAR_T
;
1520 ICONV_CHAR_CAST(&pszPtr
), &inbuf
,
1521 (char**)&bufPtr
, &outbuf
);
1523 res
+= 8-(outbuf
/SIZEOF_WCHAR_T
);
1524 } while ((cres
==(size_t)-1) && (errno
==E2BIG
));
1527 if (ICONV_FAILED(cres
, inbuf
))
1529 //VS: it is ok if iconv fails, hence trace only
1530 wxLogTrace(TRACE_STRCONV
, wxT("iconv failed: %s"), wxSysErrorMsg(wxSysErrorCode()));
1537 size_t wxMBConv_iconv::WC2MB(char *buf
, const wchar_t *psz
, size_t n
) const
1540 // NB: explained in MB2WC
1541 wxMutexLocker
lock(wxConstCast(this, wxMBConv_iconv
)->m_iconvMutex
);
1544 size_t inlen
= wxWcslen(psz
);
1545 size_t inbuf
= inlen
* SIZEOF_WCHAR_T
;
1549 wchar_t *tmpbuf
= 0;
1553 // need to copy to temp buffer to switch endianness
1554 // (doing WC_BSWAP twice on the original buffer won't help, as it
1555 // could be in read-only memory, or be accessed in some other thread)
1556 tmpbuf
= (wchar_t *)malloc(inbuf
+ SIZEOF_WCHAR_T
);
1557 for ( size_t i
= 0; i
< inlen
; i
++ )
1558 tmpbuf
[n
] = WC_BSWAP(psz
[i
]);
1559 tmpbuf
[inlen
] = L
'\0';
1565 // have destination buffer, convert there
1566 cres
= iconv( w2m
, ICONV_CHAR_CAST(&psz
), &inbuf
, &buf
, &outbuf
);
1570 // NB: iconv was given only wcslen(psz) characters on input, and so
1571 // it couldn't convert the trailing zero. Let's do it ourselves
1572 // if there's some room left for it in the output buffer.
1578 // no destination buffer... convert using temp buffer
1579 // to calculate destination buffer requirement
1583 buf
= tbuf
; outbuf
= 16;
1585 cres
= iconv( w2m
, ICONV_CHAR_CAST(&psz
), &inbuf
, &buf
, &outbuf
);
1588 } while ((cres
==(size_t)-1) && (errno
==E2BIG
));
1596 if (ICONV_FAILED(cres
, inbuf
))
1598 wxLogTrace(TRACE_STRCONV
, wxT("iconv failed: %s"), wxSysErrorMsg(wxSysErrorCode()));
1605 #endif // HAVE_ICONV
1608 // ============================================================================
1609 // Win32 conversion classes
1610 // ============================================================================
1612 #ifdef wxHAVE_WIN32_MB2WC
1616 extern WXDLLIMPEXP_BASE
long wxCharsetToCodepage(const wxChar
*charset
);
1617 extern WXDLLIMPEXP_BASE
long wxEncodingToCodepage(wxFontEncoding encoding
);
1620 class wxMBConv_win32
: public wxMBConv
1625 m_CodePage
= CP_ACP
;
1629 wxMBConv_win32(const wxChar
* name
)
1631 m_CodePage
= wxCharsetToCodepage(name
);
1634 wxMBConv_win32(wxFontEncoding encoding
)
1636 m_CodePage
= wxEncodingToCodepage(encoding
);
1640 size_t MB2WC(wchar_t *buf
, const char *psz
, size_t n
) const
1642 // note that we have to use MB_ERR_INVALID_CHARS flag as it without it
1643 // the behaviour is not compatible with the Unix version (using iconv)
1644 // and break the library itself, e.g. wxTextInputStream::NextChar()
1645 // wouldn't work if reading an incomplete MB char didn't result in an
1648 // note however that using MB_ERR_INVALID_CHARS with CP_UTF7 results in
1649 // an error (tested under Windows Server 2003) and apparently it is
1650 // done on purpose, i.e. the function accepts any input in this case
1651 // and although I'd prefer to return error on ill-formed output, our
1652 // own wxMBConvUTF7 doesn't detect errors (e.g. lone "+" which is
1653 // explicitly ill-formed according to RFC 2152) neither so we don't
1654 // even have any fallback here...
1656 // Moreover, MB_ERR_INVALID_CHARS is only supported on Win 2K SP4 or
1657 // Win XP or newer and if it is specified on older versions, conversion
1658 // from CP_UTF8 (which can have flags only 0 or MB_ERR_INVALID_CHARS)
1659 // fails. So we can only use the flag on newer Windows versions.
1660 // Additionally, the flag is not supported by UTF7, symbol and CJK
1661 // encodings. See here:
1662 // http://blogs.msdn.com/michkap/archive/2005/04/19/409566.aspx
1663 // http://msdn.microsoft.com/library/en-us/intl/unicode_17si.asp
1665 if ( m_CodePage
!= CP_UTF7
&& m_CodePage
!= CP_SYMBOL
&&
1666 m_CodePage
< 50000 &&
1667 IsAtLeastWin2kSP4() )
1669 flags
= MB_ERR_INVALID_CHARS
;
1671 else if ( m_CodePage
== CP_UTF8
)
1673 // Avoid round-trip in the special case of UTF-8 by using our
1674 // own UTF-8 conversion code:
1675 return wxMBConvUTF8().MB2WC(buf
, psz
, n
);
1678 const size_t len
= ::MultiByteToWideChar
1680 m_CodePage
, // code page
1681 flags
, // flags: fall on error
1682 psz
, // input string
1683 -1, // its length (NUL-terminated)
1684 buf
, // output string
1685 buf
? n
: 0 // size of output buffer
1689 // function totally failed
1693 // if we were really converting and didn't use MB_ERR_INVALID_CHARS,
1694 // check if we succeeded, by doing a double trip:
1695 if ( !flags
&& buf
)
1697 wxCharBuffer
mbBuf(n
);
1698 if ( ::WideCharToMultiByte
1709 strcmp(mbBuf
, psz
) != 0 )
1711 // we didn't obtain the same thing we started from, hence
1712 // the conversion was lossy and we consider that it failed
1717 // note that it returns count of written chars for buf != NULL and size
1718 // of the needed buffer for buf == NULL so in either case the length of
1719 // the string (which never includes the terminating NUL) is one less
1723 size_t WC2MB(char *buf
, const wchar_t *pwz
, size_t n
) const
1726 we have a problem here: by default, WideCharToMultiByte() may
1727 replace characters unrepresentable in the target code page with bad
1728 quality approximations such as turning "1/2" symbol (U+00BD) into
1729 "1" for the code pages which don't have it and we, obviously, want
1730 to avoid this at any price
1732 the trouble is that this function does it _silently_, i.e. it won't
1733 even tell us whether it did or not... Win98/2000 and higher provide
1734 WC_NO_BEST_FIT_CHARS but it doesn't work for the older systems and
1735 we have to resort to a round trip, i.e. check that converting back
1736 results in the same string -- this is, of course, expensive but
1737 otherwise we simply can't be sure to not garble the data.
1740 // determine if we can rely on WC_NO_BEST_FIT_CHARS: according to MSDN
1741 // it doesn't work with CJK encodings (which we test for rather roughly
1742 // here...) nor with UTF-7/8 nor, of course, with Windows versions not
1744 BOOL usedDef
wxDUMMY_INITIALIZE(false);
1747 if ( CanUseNoBestFit() && m_CodePage
< 50000 )
1749 // it's our lucky day
1750 flags
= WC_NO_BEST_FIT_CHARS
;
1751 pUsedDef
= &usedDef
;
1753 else // old system or unsupported encoding
1759 const size_t len
= ::WideCharToMultiByte
1761 m_CodePage
, // code page
1762 flags
, // either none or no best fit
1763 pwz
, // input string
1764 -1, // it is (wide) NUL-terminated
1765 buf
, // output buffer
1766 buf
? n
: 0, // and its size
1767 NULL
, // default "replacement" char
1768 pUsedDef
// [out] was it used?
1773 // function totally failed
1777 // if we were really converting, check if we succeeded
1782 // check if the conversion failed, i.e. if any replacements
1787 else // we must resort to double tripping...
1789 wxWCharBuffer
wcBuf(n
);
1790 if ( MB2WC(wcBuf
.data(), buf
, n
) == (size_t)-1 ||
1791 wcscmp(wcBuf
, pwz
) != 0 )
1793 // we didn't obtain the same thing we started from, hence
1794 // the conversion was lossy and we consider that it failed
1800 // see the comment above for the reason of "len - 1"
1804 bool IsOk() const { return m_CodePage
!= -1; }
1807 static bool CanUseNoBestFit()
1809 static int s_isWin98Or2k
= -1;
1811 if ( s_isWin98Or2k
== -1 )
1814 switch ( wxGetOsVersion(&verMaj
, &verMin
) )
1817 s_isWin98Or2k
= verMaj
>= 4 && verMin
>= 10;
1821 s_isWin98Or2k
= verMaj
>= 5;
1825 // unknown, be conseravtive by default
1829 wxASSERT_MSG( s_isWin98Or2k
!= -1, _T("should be set above") );
1832 return s_isWin98Or2k
== 1;
1835 static bool IsAtLeastWin2kSP4()
1837 static int s_isAtLeastWin2kSP4
= -1;
1839 if ( s_isAtLeastWin2kSP4
== -1 )
1841 OSVERSIONINFOEX ver
;
1843 memset(&ver
, 0, sizeof(ver
));
1844 ver
.dwOSVersionInfoSize
= sizeof(ver
);
1845 GetVersionEx((OSVERSIONINFO
*)&ver
);
1847 s_isAtLeastWin2kSP4
=
1848 ((ver
.dwMajorVersion
> 5) || // Vista+
1849 (ver
.dwMajorVersion
== 5 && ver
.dwMinorVersion
> 0) || // XP/2003
1850 (ver
.dwMajorVersion
== 5 && ver
.dwMinorVersion
== 0 &&
1851 ver
.wServicePackMajor
>= 4)) // 2000 SP4+
1855 return s_isAtLeastWin2kSP4
== 1;
1861 #endif // wxHAVE_WIN32_MB2WC
1863 // ============================================================================
1864 // Cocoa conversion classes
1865 // ============================================================================
1867 #if defined(__WXCOCOA__)
1869 // RN: There is no UTF-32 support in either Core Foundation or
1870 // Cocoa. Strangely enough, internally Core Foundation uses
1871 // UTF 32 internally quite a bit - its just not public (yet).
1873 #include <CoreFoundation/CFString.h>
1874 #include <CoreFoundation/CFStringEncodingExt.h>
1876 CFStringEncoding
wxCFStringEncFromFontEnc(wxFontEncoding encoding
)
1878 CFStringEncoding enc
= kCFStringEncodingInvalidId
;
1879 if ( encoding
== wxFONTENCODING_DEFAULT
)
1881 enc
= CFStringGetSystemEncoding();
1883 else switch( encoding
)
1885 case wxFONTENCODING_ISO8859_1
:
1886 enc
= kCFStringEncodingISOLatin1
;
1888 case wxFONTENCODING_ISO8859_2
:
1889 enc
= kCFStringEncodingISOLatin2
;
1891 case wxFONTENCODING_ISO8859_3
:
1892 enc
= kCFStringEncodingISOLatin3
;
1894 case wxFONTENCODING_ISO8859_4
:
1895 enc
= kCFStringEncodingISOLatin4
;
1897 case wxFONTENCODING_ISO8859_5
:
1898 enc
= kCFStringEncodingISOLatinCyrillic
;
1900 case wxFONTENCODING_ISO8859_6
:
1901 enc
= kCFStringEncodingISOLatinArabic
;
1903 case wxFONTENCODING_ISO8859_7
:
1904 enc
= kCFStringEncodingISOLatinGreek
;
1906 case wxFONTENCODING_ISO8859_8
:
1907 enc
= kCFStringEncodingISOLatinHebrew
;
1909 case wxFONTENCODING_ISO8859_9
:
1910 enc
= kCFStringEncodingISOLatin5
;
1912 case wxFONTENCODING_ISO8859_10
:
1913 enc
= kCFStringEncodingISOLatin6
;
1915 case wxFONTENCODING_ISO8859_11
:
1916 enc
= kCFStringEncodingISOLatinThai
;
1918 case wxFONTENCODING_ISO8859_13
:
1919 enc
= kCFStringEncodingISOLatin7
;
1921 case wxFONTENCODING_ISO8859_14
:
1922 enc
= kCFStringEncodingISOLatin8
;
1924 case wxFONTENCODING_ISO8859_15
:
1925 enc
= kCFStringEncodingISOLatin9
;
1928 case wxFONTENCODING_KOI8
:
1929 enc
= kCFStringEncodingKOI8_R
;
1931 case wxFONTENCODING_ALTERNATIVE
: // MS-DOS CP866
1932 enc
= kCFStringEncodingDOSRussian
;
1935 // case wxFONTENCODING_BULGARIAN :
1939 case wxFONTENCODING_CP437
:
1940 enc
=kCFStringEncodingDOSLatinUS
;
1942 case wxFONTENCODING_CP850
:
1943 enc
= kCFStringEncodingDOSLatin1
;
1945 case wxFONTENCODING_CP852
:
1946 enc
= kCFStringEncodingDOSLatin2
;
1948 case wxFONTENCODING_CP855
:
1949 enc
= kCFStringEncodingDOSCyrillic
;
1951 case wxFONTENCODING_CP866
:
1952 enc
=kCFStringEncodingDOSRussian
;
1954 case wxFONTENCODING_CP874
:
1955 enc
= kCFStringEncodingDOSThai
;
1957 case wxFONTENCODING_CP932
:
1958 enc
= kCFStringEncodingDOSJapanese
;
1960 case wxFONTENCODING_CP936
:
1961 enc
=kCFStringEncodingDOSChineseSimplif
;
1963 case wxFONTENCODING_CP949
:
1964 enc
= kCFStringEncodingDOSKorean
;
1966 case wxFONTENCODING_CP950
:
1967 enc
= kCFStringEncodingDOSChineseTrad
;
1969 case wxFONTENCODING_CP1250
:
1970 enc
= kCFStringEncodingWindowsLatin2
;
1972 case wxFONTENCODING_CP1251
:
1973 enc
=kCFStringEncodingWindowsCyrillic
;
1975 case wxFONTENCODING_CP1252
:
1976 enc
=kCFStringEncodingWindowsLatin1
;
1978 case wxFONTENCODING_CP1253
:
1979 enc
= kCFStringEncodingWindowsGreek
;
1981 case wxFONTENCODING_CP1254
:
1982 enc
= kCFStringEncodingWindowsLatin5
;
1984 case wxFONTENCODING_CP1255
:
1985 enc
=kCFStringEncodingWindowsHebrew
;
1987 case wxFONTENCODING_CP1256
:
1988 enc
=kCFStringEncodingWindowsArabic
;
1990 case wxFONTENCODING_CP1257
:
1991 enc
= kCFStringEncodingWindowsBalticRim
;
1993 // This only really encodes to UTF7 (if that) evidently
1994 // case wxFONTENCODING_UTF7 :
1995 // enc = kCFStringEncodingNonLossyASCII ;
1997 case wxFONTENCODING_UTF8
:
1998 enc
= kCFStringEncodingUTF8
;
2000 case wxFONTENCODING_EUC_JP
:
2001 enc
= kCFStringEncodingEUC_JP
;
2003 case wxFONTENCODING_UTF16
:
2004 enc
= kCFStringEncodingUnicode
;
2006 case wxFONTENCODING_MACROMAN
:
2007 enc
= kCFStringEncodingMacRoman
;
2009 case wxFONTENCODING_MACJAPANESE
:
2010 enc
= kCFStringEncodingMacJapanese
;
2012 case wxFONTENCODING_MACCHINESETRAD
:
2013 enc
= kCFStringEncodingMacChineseTrad
;
2015 case wxFONTENCODING_MACKOREAN
:
2016 enc
= kCFStringEncodingMacKorean
;
2018 case wxFONTENCODING_MACARABIC
:
2019 enc
= kCFStringEncodingMacArabic
;
2021 case wxFONTENCODING_MACHEBREW
:
2022 enc
= kCFStringEncodingMacHebrew
;
2024 case wxFONTENCODING_MACGREEK
:
2025 enc
= kCFStringEncodingMacGreek
;
2027 case wxFONTENCODING_MACCYRILLIC
:
2028 enc
= kCFStringEncodingMacCyrillic
;
2030 case wxFONTENCODING_MACDEVANAGARI
:
2031 enc
= kCFStringEncodingMacDevanagari
;
2033 case wxFONTENCODING_MACGURMUKHI
:
2034 enc
= kCFStringEncodingMacGurmukhi
;
2036 case wxFONTENCODING_MACGUJARATI
:
2037 enc
= kCFStringEncodingMacGujarati
;
2039 case wxFONTENCODING_MACORIYA
:
2040 enc
= kCFStringEncodingMacOriya
;
2042 case wxFONTENCODING_MACBENGALI
:
2043 enc
= kCFStringEncodingMacBengali
;
2045 case wxFONTENCODING_MACTAMIL
:
2046 enc
= kCFStringEncodingMacTamil
;
2048 case wxFONTENCODING_MACTELUGU
:
2049 enc
= kCFStringEncodingMacTelugu
;
2051 case wxFONTENCODING_MACKANNADA
:
2052 enc
= kCFStringEncodingMacKannada
;
2054 case wxFONTENCODING_MACMALAJALAM
:
2055 enc
= kCFStringEncodingMacMalayalam
;
2057 case wxFONTENCODING_MACSINHALESE
:
2058 enc
= kCFStringEncodingMacSinhalese
;
2060 case wxFONTENCODING_MACBURMESE
:
2061 enc
= kCFStringEncodingMacBurmese
;
2063 case wxFONTENCODING_MACKHMER
:
2064 enc
= kCFStringEncodingMacKhmer
;
2066 case wxFONTENCODING_MACTHAI
:
2067 enc
= kCFStringEncodingMacThai
;
2069 case wxFONTENCODING_MACLAOTIAN
:
2070 enc
= kCFStringEncodingMacLaotian
;
2072 case wxFONTENCODING_MACGEORGIAN
:
2073 enc
= kCFStringEncodingMacGeorgian
;
2075 case wxFONTENCODING_MACARMENIAN
:
2076 enc
= kCFStringEncodingMacArmenian
;
2078 case wxFONTENCODING_MACCHINESESIMP
:
2079 enc
= kCFStringEncodingMacChineseSimp
;
2081 case wxFONTENCODING_MACTIBETAN
:
2082 enc
= kCFStringEncodingMacTibetan
;
2084 case wxFONTENCODING_MACMONGOLIAN
:
2085 enc
= kCFStringEncodingMacMongolian
;
2087 case wxFONTENCODING_MACETHIOPIC
:
2088 enc
= kCFStringEncodingMacEthiopic
;
2090 case wxFONTENCODING_MACCENTRALEUR
:
2091 enc
= kCFStringEncodingMacCentralEurRoman
;
2093 case wxFONTENCODING_MACVIATNAMESE
:
2094 enc
= kCFStringEncodingMacVietnamese
;
2096 case wxFONTENCODING_MACARABICEXT
:
2097 enc
= kCFStringEncodingMacExtArabic
;
2099 case wxFONTENCODING_MACSYMBOL
:
2100 enc
= kCFStringEncodingMacSymbol
;
2102 case wxFONTENCODING_MACDINGBATS
:
2103 enc
= kCFStringEncodingMacDingbats
;
2105 case wxFONTENCODING_MACTURKISH
:
2106 enc
= kCFStringEncodingMacTurkish
;
2108 case wxFONTENCODING_MACCROATIAN
:
2109 enc
= kCFStringEncodingMacCroatian
;
2111 case wxFONTENCODING_MACICELANDIC
:
2112 enc
= kCFStringEncodingMacIcelandic
;
2114 case wxFONTENCODING_MACROMANIAN
:
2115 enc
= kCFStringEncodingMacRomanian
;
2117 case wxFONTENCODING_MACCELTIC
:
2118 enc
= kCFStringEncodingMacCeltic
;
2120 case wxFONTENCODING_MACGAELIC
:
2121 enc
= kCFStringEncodingMacGaelic
;
2123 // case wxFONTENCODING_MACKEYBOARD :
2124 // enc = kCFStringEncodingMacKeyboardGlyphs ;
2127 // because gcc is picky
2133 class wxMBConv_cocoa
: public wxMBConv
2138 Init(CFStringGetSystemEncoding()) ;
2142 wxMBConv_cocoa(const wxChar
* name
)
2144 Init( wxCFStringEncFromFontEnc(wxFontMapperBase::Get()->CharsetToEncoding(name
, false) ) ) ;
2148 wxMBConv_cocoa(wxFontEncoding encoding
)
2150 Init( wxCFStringEncFromFontEnc(encoding
) );
2157 void Init( CFStringEncoding encoding
)
2159 m_encoding
= encoding
;
2162 size_t MB2WC(wchar_t * szOut
, const char * szUnConv
, size_t nOutSize
) const
2166 CFStringRef theString
= CFStringCreateWithBytes (
2167 NULL
, //the allocator
2168 (const UInt8
*)szUnConv
,
2171 false //no BOM/external representation
2174 wxASSERT(theString
);
2176 size_t nOutLength
= CFStringGetLength(theString
);
2180 CFRelease(theString
);
2184 CFRange theRange
= { 0, nOutSize
};
2186 #if SIZEOF_WCHAR_T == 4
2187 UniChar
* szUniCharBuffer
= new UniChar
[nOutSize
];
2190 CFStringGetCharacters(theString
, theRange
, szUniCharBuffer
);
2192 CFRelease(theString
);
2194 szUniCharBuffer
[nOutLength
] = '\0' ;
2196 #if SIZEOF_WCHAR_T == 4
2197 wxMBConvUTF16 converter
;
2198 converter
.MB2WC(szOut
, (const char*)szUniCharBuffer
, nOutSize
) ;
2199 delete[] szUniCharBuffer
;
2205 size_t WC2MB(char *szOut
, const wchar_t *szUnConv
, size_t nOutSize
) const
2209 size_t nRealOutSize
;
2210 size_t nBufSize
= wxWcslen(szUnConv
);
2211 UniChar
* szUniBuffer
= (UniChar
*) szUnConv
;
2213 #if SIZEOF_WCHAR_T == 4
2214 wxMBConvUTF16 converter
;
2215 nBufSize
= converter
.WC2MB( NULL
, szUnConv
, 0 );
2216 szUniBuffer
= new UniChar
[ (nBufSize
/ sizeof(UniChar
)) + 1] ;
2217 converter
.WC2MB( (char*) szUniBuffer
, szUnConv
, nBufSize
+ sizeof(UniChar
)) ;
2218 nBufSize
/= sizeof(UniChar
);
2221 CFStringRef theString
= CFStringCreateWithCharactersNoCopy(
2225 kCFAllocatorNull
//deallocator - we want to deallocate it ourselves
2228 wxASSERT(theString
);
2230 //Note that CER puts a BOM when converting to unicode
2231 //so we check and use getchars instead in that case
2232 if (m_encoding
== kCFStringEncodingUnicode
)
2235 CFStringGetCharacters(theString
, CFRangeMake(0, nOutSize
- 1), (UniChar
*) szOut
);
2237 nRealOutSize
= CFStringGetLength(theString
) + 1;
2243 CFRangeMake(0, CFStringGetLength(theString
)),
2245 0, //what to put in characters that can't be converted -
2246 //0 tells CFString to return NULL if it meets such a character
2247 false, //not an external representation
2250 (CFIndex
*) &nRealOutSize
2254 CFRelease(theString
);
2256 #if SIZEOF_WCHAR_T == 4
2257 delete[] szUniBuffer
;
2260 return nRealOutSize
- 1;
2265 return m_encoding
!= kCFStringEncodingInvalidId
&&
2266 CFStringIsEncodingAvailable(m_encoding
);
2270 CFStringEncoding m_encoding
;
2273 #endif // defined(__WXCOCOA__)
2275 // ============================================================================
2276 // Mac conversion classes
2277 // ============================================================================
2279 #if defined(__WXMAC__) && defined(TARGET_CARBON)
2281 class wxMBConv_mac
: public wxMBConv
2286 Init(CFStringGetSystemEncoding()) ;
2290 wxMBConv_mac(const wxChar
* name
)
2292 Init( wxMacGetSystemEncFromFontEnc(wxFontMapperBase::Get()->CharsetToEncoding(name
, false) ) ) ;
2296 wxMBConv_mac(wxFontEncoding encoding
)
2298 Init( wxMacGetSystemEncFromFontEnc(encoding
) );
2303 OSStatus status
= noErr
;
2304 status
= TECDisposeConverter(m_MB2WC_converter
);
2305 status
= TECDisposeConverter(m_WC2MB_converter
);
2309 void Init( TextEncodingBase encoding
)
2311 OSStatus status
= noErr
;
2312 m_char_encoding
= encoding
;
2313 m_unicode_encoding
= CreateTextEncoding(kTextEncodingUnicodeDefault
,0,kUnicode16BitFormat
) ;
2315 status
= TECCreateConverter(&m_MB2WC_converter
,
2317 m_unicode_encoding
);
2318 status
= TECCreateConverter(&m_WC2MB_converter
,
2323 size_t MB2WC(wchar_t *buf
, const char *psz
, size_t n
) const
2325 OSStatus status
= noErr
;
2326 ByteCount byteOutLen
;
2327 ByteCount byteInLen
= strlen(psz
) ;
2328 wchar_t *tbuf
= NULL
;
2329 UniChar
* ubuf
= NULL
;
2334 //apple specs say at least 32
2335 n
= wxMax( 32 , byteInLen
) ;
2336 tbuf
= (wchar_t*) malloc( n
* SIZEOF_WCHAR_T
) ;
2338 ByteCount byteBufferLen
= n
* sizeof( UniChar
) ;
2339 #if SIZEOF_WCHAR_T == 4
2340 ubuf
= (UniChar
*) malloc( byteBufferLen
+ 2 ) ;
2342 ubuf
= (UniChar
*) (buf
? buf
: tbuf
) ;
2344 status
= TECConvertText(m_MB2WC_converter
, (ConstTextPtr
) psz
, byteInLen
, &byteInLen
,
2345 (TextPtr
) ubuf
, byteBufferLen
, &byteOutLen
);
2346 #if SIZEOF_WCHAR_T == 4
2347 // we have to terminate here, because n might be larger for the trailing zero, and if UniChar
2348 // is not properly terminated we get random characters at the end
2349 ubuf
[byteOutLen
/ sizeof( UniChar
) ] = 0 ;
2350 wxMBConvUTF16 converter
;
2351 res
= converter
.MB2WC( (buf
? buf
: tbuf
) , (const char*)ubuf
, n
) ;
2354 res
= byteOutLen
/ sizeof( UniChar
) ;
2359 if ( buf
&& res
< n
)
2365 size_t WC2MB(char *buf
, const wchar_t *psz
, size_t n
) const
2367 OSStatus status
= noErr
;
2368 ByteCount byteOutLen
;
2369 ByteCount byteInLen
= wxWcslen(psz
) * SIZEOF_WCHAR_T
;
2375 //apple specs say at least 32
2376 n
= wxMax( 32 , ((byteInLen
/ SIZEOF_WCHAR_T
) * 8) + SIZEOF_WCHAR_T
);
2377 tbuf
= (char*) malloc( n
) ;
2380 ByteCount byteBufferLen
= n
;
2381 UniChar
* ubuf
= NULL
;
2382 #if SIZEOF_WCHAR_T == 4
2383 wxMBConvUTF16 converter
;
2384 size_t unicharlen
= converter
.WC2MB( NULL
, psz
, 0 ) ;
2385 byteInLen
= unicharlen
;
2386 ubuf
= (UniChar
*) malloc( byteInLen
+ 2 ) ;
2387 converter
.WC2MB( (char*) ubuf
, psz
, unicharlen
+ 2 ) ;
2389 ubuf
= (UniChar
*) psz
;
2391 status
= TECConvertText(m_WC2MB_converter
, (ConstTextPtr
) ubuf
, byteInLen
, &byteInLen
,
2392 (TextPtr
) (buf
? buf
: tbuf
) , byteBufferLen
, &byteOutLen
);
2393 #if SIZEOF_WCHAR_T == 4
2399 size_t res
= byteOutLen
;
2400 if ( buf
&& res
< n
)
2404 //we need to double-trip to verify it didn't insert any ? in place
2405 //of bogus characters
2406 wxWCharBuffer
wcBuf(n
);
2407 size_t pszlen
= wxWcslen(psz
);
2408 if ( MB2WC(wcBuf
.data(), buf
, n
) == (size_t)-1 ||
2409 wxWcslen(wcBuf
) != pszlen
||
2410 memcmp(wcBuf
, psz
, pszlen
* sizeof(wchar_t)) != 0 )
2412 // we didn't obtain the same thing we started from, hence
2413 // the conversion was lossy and we consider that it failed
2422 { return m_MB2WC_converter
!= NULL
&& m_WC2MB_converter
!= NULL
; }
2425 TECObjectRef m_MB2WC_converter
;
2426 TECObjectRef m_WC2MB_converter
;
2428 TextEncodingBase m_char_encoding
;
2429 TextEncodingBase m_unicode_encoding
;
2432 #endif // defined(__WXMAC__) && defined(TARGET_CARBON)
2434 // ============================================================================
2435 // wxEncodingConverter based conversion classes
2436 // ============================================================================
2440 class wxMBConv_wxwin
: public wxMBConv
2445 m_ok
= m2w
.Init(m_enc
, wxFONTENCODING_UNICODE
) &&
2446 w2m
.Init(wxFONTENCODING_UNICODE
, m_enc
);
2450 // temporarily just use wxEncodingConverter stuff,
2451 // so that it works while a better implementation is built
2452 wxMBConv_wxwin(const wxChar
* name
)
2455 m_enc
= wxFontMapperBase::Get()->CharsetToEncoding(name
, false);
2457 m_enc
= wxFONTENCODING_SYSTEM
;
2462 wxMBConv_wxwin(wxFontEncoding enc
)
2469 size_t MB2WC(wchar_t *buf
, const char *psz
, size_t WXUNUSED(n
)) const
2471 size_t inbuf
= strlen(psz
);
2474 if (!m2w
.Convert(psz
,buf
))
2480 size_t WC2MB(char *buf
, const wchar_t *psz
, size_t WXUNUSED(n
)) const
2482 const size_t inbuf
= wxWcslen(psz
);
2485 if (!w2m
.Convert(psz
,buf
))
2492 bool IsOk() const { return m_ok
; }
2495 wxFontEncoding m_enc
;
2496 wxEncodingConverter m2w
, w2m
;
2498 // were we initialized successfully?
2501 DECLARE_NO_COPY_CLASS(wxMBConv_wxwin
)
2504 // make the constructors available for unit testing
2505 WXDLLIMPEXP_BASE wxMBConv
* new_wxMBConv_wxwin( const wxChar
* name
)
2507 wxMBConv_wxwin
* result
= new wxMBConv_wxwin( name
);
2508 if ( !result
->IsOk() )
2516 #endif // wxUSE_FONTMAP
2518 // ============================================================================
2519 // wxCSConv implementation
2520 // ============================================================================
2522 void wxCSConv::Init()
2529 wxCSConv::wxCSConv(const wxChar
*charset
)
2539 m_encoding
= wxFontMapperBase::GetEncodingFromName(charset
);
2541 m_encoding
= wxFONTENCODING_SYSTEM
;
2545 wxCSConv::wxCSConv(wxFontEncoding encoding
)
2547 if ( encoding
== wxFONTENCODING_MAX
|| encoding
== wxFONTENCODING_DEFAULT
)
2549 wxFAIL_MSG( _T("invalid encoding value in wxCSConv ctor") );
2551 encoding
= wxFONTENCODING_SYSTEM
;
2556 m_encoding
= encoding
;
2559 wxCSConv::~wxCSConv()
2564 wxCSConv::wxCSConv(const wxCSConv
& conv
)
2569 SetName(conv
.m_name
);
2570 m_encoding
= conv
.m_encoding
;
2573 wxCSConv
& wxCSConv::operator=(const wxCSConv
& conv
)
2577 SetName(conv
.m_name
);
2578 m_encoding
= conv
.m_encoding
;
2583 void wxCSConv::Clear()
2592 void wxCSConv::SetName(const wxChar
*charset
)
2596 m_name
= wxStrdup(charset
);
2602 #include "wx/hashmap.h"
2604 WX_DECLARE_HASH_MAP( wxFontEncoding
, wxString
, wxIntegerHash
, wxIntegerEqual
,
2605 wxEncodingNameCache
);
2607 static wxEncodingNameCache gs_nameCache
;
2610 wxMBConv
*wxCSConv::DoCreate() const
2613 wxLogTrace(TRACE_STRCONV
,
2614 wxT("creating conversion for %s"),
2616 : wxFontMapperBase::GetEncodingName(m_encoding
).c_str()));
2617 #endif // wxUSE_FONTMAP
2619 // check for the special case of ASCII or ISO8859-1 charset: as we have
2620 // special knowledge of it anyhow, we don't need to create a special
2621 // conversion object
2622 if ( m_encoding
== wxFONTENCODING_ISO8859_1
||
2623 m_encoding
== wxFONTENCODING_DEFAULT
)
2625 // don't convert at all
2629 // we trust OS to do conversion better than we can so try external
2630 // conversion methods first
2632 // the full order is:
2633 // 1. OS conversion (iconv() under Unix or Win32 API)
2634 // 2. hard coded conversions for UTF
2635 // 3. wxEncodingConverter as fall back
2641 #endif // !wxUSE_FONTMAP
2643 wxString
name(m_name
);
2644 wxFontEncoding
encoding(m_encoding
);
2646 if ( !name
.empty() )
2648 wxMBConv_iconv
*conv
= new wxMBConv_iconv(name
);
2656 wxFontMapperBase::Get()->CharsetToEncoding(name
, false);
2657 #endif // wxUSE_FONTMAP
2661 const wxEncodingNameCache::iterator it
= gs_nameCache
.find(encoding
);
2662 if ( it
!= gs_nameCache
.end() )
2664 if ( it
->second
.empty() )
2667 wxMBConv_iconv
*conv
= new wxMBConv_iconv(it
->second
);
2674 const wxChar
** names
= wxFontMapperBase::GetAllEncodingNames(encoding
);
2676 for ( ; *names
; ++names
)
2678 wxMBConv_iconv
*conv
= new wxMBConv_iconv(*names
);
2681 gs_nameCache
[encoding
] = *names
;
2688 gs_nameCache
[encoding
] = _T(""); // cache the failure
2690 #endif // wxUSE_FONTMAP
2692 #endif // HAVE_ICONV
2694 #ifdef wxHAVE_WIN32_MB2WC
2697 wxMBConv_win32
*conv
= m_name
? new wxMBConv_win32(m_name
)
2698 : new wxMBConv_win32(m_encoding
);
2707 #endif // wxHAVE_WIN32_MB2WC
2708 #if defined(__WXMAC__)
2710 // leave UTF16 and UTF32 to the built-ins of wx
2711 if ( m_name
|| ( m_encoding
< wxFONTENCODING_UTF16BE
||
2712 ( m_encoding
>= wxFONTENCODING_MACMIN
&& m_encoding
<= wxFONTENCODING_MACMAX
) ) )
2716 wxMBConv_mac
*conv
= m_name
? new wxMBConv_mac(m_name
)
2717 : new wxMBConv_mac(m_encoding
);
2719 wxMBConv_mac
*conv
= new wxMBConv_mac(m_encoding
);
2728 #if defined(__WXCOCOA__)
2730 if ( m_name
|| ( m_encoding
<= wxFONTENCODING_UTF16
) )
2734 wxMBConv_cocoa
*conv
= m_name
? new wxMBConv_cocoa(m_name
)
2735 : new wxMBConv_cocoa(m_encoding
);
2737 wxMBConv_cocoa
*conv
= new wxMBConv_cocoa(m_encoding
);
2747 wxFontEncoding enc
= m_encoding
;
2749 if ( enc
== wxFONTENCODING_SYSTEM
&& m_name
)
2751 // use "false" to suppress interactive dialogs -- we can be called from
2752 // anywhere and popping up a dialog from here is the last thing we want to
2754 enc
= wxFontMapperBase::Get()->CharsetToEncoding(m_name
, false);
2756 #endif // wxUSE_FONTMAP
2760 case wxFONTENCODING_UTF7
:
2761 return new wxMBConvUTF7
;
2763 case wxFONTENCODING_UTF8
:
2764 return new wxMBConvUTF8
;
2766 case wxFONTENCODING_UTF16BE
:
2767 return new wxMBConvUTF16BE
;
2769 case wxFONTENCODING_UTF16LE
:
2770 return new wxMBConvUTF16LE
;
2772 case wxFONTENCODING_UTF32BE
:
2773 return new wxMBConvUTF32BE
;
2775 case wxFONTENCODING_UTF32LE
:
2776 return new wxMBConvUTF32LE
;
2779 // nothing to do but put here to suppress gcc warnings
2786 wxMBConv_wxwin
*conv
= m_name
? new wxMBConv_wxwin(m_name
)
2787 : new wxMBConv_wxwin(m_encoding
);
2793 #endif // wxUSE_FONTMAP
2795 // NB: This is a hack to prevent deadlock. What could otherwise happen
2796 // in Unicode build: wxConvLocal creation ends up being here
2797 // because of some failure and logs the error. But wxLog will try to
2798 // attach timestamp, for which it will need wxConvLocal (to convert
2799 // time to char* and then wchar_t*), but that fails, tries to log
2800 // error, but wxLog has a (already locked) critical section that
2801 // guards static buffer.
2802 static bool alreadyLoggingError
= false;
2803 if (!alreadyLoggingError
)
2805 alreadyLoggingError
= true;
2806 wxLogError(_("Cannot convert from the charset '%s'!"),
2810 wxFontMapperBase::GetEncodingDescription(m_encoding
).c_str()
2811 #else // !wxUSE_FONTMAP
2812 wxString::Format(_("encoding %s"), m_encoding
).c_str()
2813 #endif // wxUSE_FONTMAP/!wxUSE_FONTMAP
2815 alreadyLoggingError
= false;
2821 void wxCSConv::CreateConvIfNeeded() const
2825 wxCSConv
*self
= (wxCSConv
*)this; // const_cast
2828 // if we don't have neither the name nor the encoding, use the default
2829 // encoding for this system
2830 if ( !m_name
&& m_encoding
== wxFONTENCODING_SYSTEM
)
2832 self
->m_name
= wxStrdup(wxLocale::GetSystemEncodingName());
2834 #endif // wxUSE_INTL
2836 self
->m_convReal
= DoCreate();
2837 self
->m_deferred
= false;
2841 size_t wxCSConv::MB2WC(wchar_t *buf
, const char *psz
, size_t n
) const
2843 CreateConvIfNeeded();
2846 return m_convReal
->MB2WC(buf
, psz
, n
);
2849 size_t len
= strlen(psz
);
2853 for (size_t c
= 0; c
<= len
; c
++)
2854 buf
[c
] = (unsigned char)(psz
[c
]);
2860 size_t wxCSConv::WC2MB(char *buf
, const wchar_t *psz
, size_t n
) const
2862 CreateConvIfNeeded();
2865 return m_convReal
->WC2MB(buf
, psz
, n
);
2868 const size_t len
= wxWcslen(psz
);
2871 for (size_t c
= 0; c
<= len
; c
++)
2875 buf
[c
] = (char)psz
[c
];
2880 for (size_t c
= 0; c
<= len
; c
++)
2890 // ----------------------------------------------------------------------------
2892 // ----------------------------------------------------------------------------
2895 static wxMBConv_win32 wxConvLibcObj
;
2896 #elif defined(__WXMAC__) && !defined(__MACH__)
2897 static wxMBConv_mac wxConvLibcObj
;
2899 static wxMBConvLibc wxConvLibcObj
;
2902 static wxCSConv
wxConvLocalObj(wxFONTENCODING_SYSTEM
);
2903 static wxCSConv
wxConvISO8859_1Obj(wxFONTENCODING_ISO8859_1
);
2904 static wxMBConvUTF7 wxConvUTF7Obj
;
2905 static wxMBConvUTF8 wxConvUTF8Obj
;
2907 WXDLLIMPEXP_DATA_BASE(wxMBConv
&) wxConvLibc
= wxConvLibcObj
;
2908 WXDLLIMPEXP_DATA_BASE(wxCSConv
&) wxConvLocal
= wxConvLocalObj
;
2909 WXDLLIMPEXP_DATA_BASE(wxCSConv
&) wxConvISO8859_1
= wxConvISO8859_1Obj
;
2910 WXDLLIMPEXP_DATA_BASE(wxMBConvUTF7
&) wxConvUTF7
= wxConvUTF7Obj
;
2911 WXDLLIMPEXP_DATA_BASE(wxMBConvUTF8
&) wxConvUTF8
= wxConvUTF8Obj
;
2912 WXDLLIMPEXP_DATA_BASE(wxMBConv
*) wxConvCurrent
= &wxConvLibcObj
;
2913 WXDLLIMPEXP_DATA_BASE(wxMBConv
*) wxConvFileName
= &
2921 #else // !wxUSE_WCHAR_T
2923 // stand-ins in absence of wchar_t
2924 WXDLLIMPEXP_DATA_BASE(wxMBConv
) wxConvLibc
,
2929 #endif // wxUSE_WCHAR_T/!wxUSE_WCHAR_T