1 /////////////////////////////////////////////////////////////////////////////
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 #if defined(__GNUG__) && !defined(NO_GCC_PRAGMA)
24 #pragma implementation "strconv.h"
27 // For compilers that support precompilation, includes "wx.h".
28 #include "wx/wxprec.h"
39 #include "wx/strconv.h"
44 #include "wx/msw/private.h"
45 #include "wx/msw/missing.h"
56 #if defined(__WIN32__) && !defined(__WXMICROWIN__)
57 #define wxHAVE_WIN32_MB2WC
58 #endif // __WIN32__ but !__WXMICROWIN__
66 #include "wx/thread.h"
69 #include "wx/encconv.h"
70 #include "wx/fontmap.h"
75 #include <ATSUnicode.h>
76 #include <TextCommon.h>
77 #include <TextEncodingConverter.h>
80 #include "wx/mac/private.h" // includes mac headers
83 #define TRACE_STRCONV _T("strconv")
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;; 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)
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
++ = 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 n
= *opsz
;
695 *buf
++ = (wchar_t)( L
'0' + n
/ 0100 );
696 *buf
++ = (wchar_t)( L
'0' + (n
% 0100) / 010 );
697 *buf
++ = (wchar_t)( L
'0' + n
% 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)
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)
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
++ = *(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() )
1357 const wxChar
**names
= wxFontMapperBase::GetAllEncodingNames(WC_ENC
);
1358 #else // !wxUSE_FONTMAP
1359 static const wxChar
*names
[] =
1361 #if SIZEOF_WCHAR_T == 4
1363 #elif SIZEOF_WCHAR_T = 2
1368 #endif // wxUSE_FONTMAP/!wxUSE_FONTMAP
1370 for ( ; *names
; ++names
)
1372 const wxString
name(*names
);
1374 // first try charset with explicit bytesex info (e.g. "UCS-4LE"):
1375 wxString
nameXE(name
);
1376 #ifdef WORDS_BIGENDIAN
1378 #else // little endian
1382 m2w
= iconv_open(nameXE
.ToAscii(), cname
);
1383 if ( m2w
== ICONV_T_INVALID
)
1385 // try charset w/o bytesex info (e.g. "UCS4")
1386 m2w
= iconv_open(name
.ToAscii(), cname
);
1388 // and check for bytesex ourselves:
1389 if ( m2w
!= ICONV_T_INVALID
)
1391 char buf
[2], *bufPtr
;
1392 wchar_t wbuf
[2], *wbufPtr
;
1400 outsz
= SIZEOF_WCHAR_T
* 2;
1404 res
= iconv(m2w
, ICONV_CHAR_CAST(&bufPtr
), &insz
,
1405 (char**)&wbufPtr
, &outsz
);
1407 if (ICONV_FAILED(res
, insz
))
1409 wxLogLastError(wxT("iconv"));
1410 wxLogError(_("Conversion to charset '%s' doesn't work."),
1413 else // ok, can convert to this encoding, remember it
1415 ms_wcCharsetName
= name
;
1416 ms_wcNeedsSwap
= wbuf
[0] != (wchar_t)buf
[0];
1420 else // use charset not requiring byte swapping
1422 ms_wcCharsetName
= nameXE
;
1426 wxLogTrace(TRACE_STRCONV
,
1427 wxT("iconv wchar_t charset is \"%s\"%s"),
1428 ms_wcCharsetName
.empty() ? "<none>"
1429 : ms_wcCharsetName
.c_str(),
1430 ms_wcNeedsSwap
? _T(" (needs swap)")
1433 else // we already have ms_wcCharsetName
1435 m2w
= iconv_open(ms_wcCharsetName
.ToAscii(), cname
);
1438 if ( ms_wcCharsetName
.empty() )
1440 w2m
= ICONV_T_INVALID
;
1444 w2m
= iconv_open(cname
, ms_wcCharsetName
.ToAscii());
1445 if ( w2m
== ICONV_T_INVALID
)
1447 wxLogTrace(TRACE_STRCONV
,
1448 wxT("\"%s\" -> \"%s\" works but not the converse!?"),
1449 ms_wcCharsetName
.c_str(), cname
.data());
1454 wxMBConv_iconv::~wxMBConv_iconv()
1456 if ( m2w
!= ICONV_T_INVALID
)
1458 if ( w2m
!= ICONV_T_INVALID
)
1462 size_t wxMBConv_iconv::MB2WC(wchar_t *buf
, const char *psz
, size_t n
) const
1465 // NB: iconv() is MT-safe, but each thread must use it's own iconv_t handle.
1466 // Unfortunately there is a couple of global wxCSConv objects such as
1467 // wxConvLocal that are used all over wx code, so we have to make sure
1468 // the handle is used by at most one thread at the time. Otherwise
1469 // only a few wx classes would be safe to use from non-main threads
1470 // as MB<->WC conversion would fail "randomly".
1471 wxMutexLocker
lock(wxConstCast(this, wxMBConv_iconv
)->m_iconvMutex
);
1474 size_t inbuf
= strlen(psz
);
1475 size_t outbuf
= n
* SIZEOF_WCHAR_T
;
1477 // VS: Use these instead of psz, buf because iconv() modifies its arguments:
1478 wchar_t *bufPtr
= buf
;
1479 const char *pszPtr
= psz
;
1483 // have destination buffer, convert there
1485 ICONV_CHAR_CAST(&pszPtr
), &inbuf
,
1486 (char**)&bufPtr
, &outbuf
);
1487 res
= n
- (outbuf
/ SIZEOF_WCHAR_T
);
1491 // convert to native endianness
1492 for ( unsigned n
= 0; n
< res
; n
++ )
1493 buf
[n
] = WC_BSWAP(buf
[n
]);
1496 // NB: iconv was given only strlen(psz) characters on input, and so
1497 // it couldn't convert the trailing zero. Let's do it ourselves
1498 // if there's some room left for it in the output buffer.
1504 // no destination buffer... convert using temp buffer
1505 // to calculate destination buffer requirement
1510 outbuf
= 8*SIZEOF_WCHAR_T
;
1513 ICONV_CHAR_CAST(&pszPtr
), &inbuf
,
1514 (char**)&bufPtr
, &outbuf
);
1516 res
+= 8-(outbuf
/SIZEOF_WCHAR_T
);
1517 } while ((cres
==(size_t)-1) && (errno
==E2BIG
));
1520 if (ICONV_FAILED(cres
, inbuf
))
1522 //VS: it is ok if iconv fails, hence trace only
1523 wxLogTrace(TRACE_STRCONV
, wxT("iconv failed: %s"), wxSysErrorMsg(wxSysErrorCode()));
1530 size_t wxMBConv_iconv::WC2MB(char *buf
, const wchar_t *psz
, size_t n
) const
1533 // NB: explained in MB2WC
1534 wxMutexLocker
lock(wxConstCast(this, wxMBConv_iconv
)->m_iconvMutex
);
1537 size_t inbuf
= wxWcslen(psz
) * SIZEOF_WCHAR_T
;
1541 wchar_t *tmpbuf
= 0;
1545 // need to copy to temp buffer to switch endianness
1546 // (doing WC_BSWAP twice on the original buffer won't help, as it
1547 // could be in read-only memory, or be accessed in some other thread)
1548 tmpbuf
= (wchar_t *)malloc(inbuf
+ SIZEOF_WCHAR_T
);
1549 for ( size_t n
= 0; n
< inbuf
; n
++ )
1550 tmpbuf
[n
] = WC_BSWAP(psz
[n
]);
1551 tmpbuf
[inbuf
] = L
'\0';
1557 // have destination buffer, convert there
1558 cres
= iconv( w2m
, ICONV_CHAR_CAST(&psz
), &inbuf
, &buf
, &outbuf
);
1562 // NB: iconv was given only wcslen(psz) characters on input, and so
1563 // it couldn't convert the trailing zero. Let's do it ourselves
1564 // if there's some room left for it in the output buffer.
1570 // no destination buffer... convert using temp buffer
1571 // to calculate destination buffer requirement
1575 buf
= tbuf
; outbuf
= 16;
1577 cres
= iconv( w2m
, ICONV_CHAR_CAST(&psz
), &inbuf
, &buf
, &outbuf
);
1580 } while ((cres
==(size_t)-1) && (errno
==E2BIG
));
1588 if (ICONV_FAILED(cres
, inbuf
))
1590 //VS: it is ok if iconv fails, hence trace only
1591 wxLogTrace(TRACE_STRCONV
, wxT("iconv failed: %s"), wxSysErrorMsg(wxSysErrorCode()));
1598 #endif // HAVE_ICONV
1601 // ============================================================================
1602 // Win32 conversion classes
1603 // ============================================================================
1605 #ifdef wxHAVE_WIN32_MB2WC
1609 extern WXDLLIMPEXP_BASE
long wxCharsetToCodepage(const wxChar
*charset
);
1610 extern WXDLLIMPEXP_BASE
long wxEncodingToCodepage(wxFontEncoding encoding
);
1613 class wxMBConv_win32
: public wxMBConv
1618 m_CodePage
= CP_ACP
;
1622 wxMBConv_win32(const wxChar
* name
)
1624 m_CodePage
= wxCharsetToCodepage(name
);
1627 wxMBConv_win32(wxFontEncoding encoding
)
1629 m_CodePage
= wxEncodingToCodepage(encoding
);
1633 size_t MB2WC(wchar_t *buf
, const char *psz
, size_t n
) const
1635 // note that we have to use MB_ERR_INVALID_CHARS flag as it without it
1636 // the behaviour is not compatible with the Unix version (using iconv)
1637 // and break the library itself, e.g. wxTextInputStream::NextChar()
1638 // wouldn't work if reading an incomplete MB char didn't result in an
1641 // note however that using MB_ERR_INVALID_CHARS with CP_UTF7 results in
1642 // an error (tested under Windows Server 2003) and apparently it is
1643 // done on purpose, i.e. the function accepts any input in this case
1644 // and although I'd prefer to return error on ill-formed output, our
1645 // own wxMBConvUTF7 doesn't detect errors (e.g. lone "+" which is
1646 // explicitly ill-formed according to RFC 2152) neither so we don't
1647 // even have any fallback here...
1648 int flags
= m_CodePage
== CP_UTF7
? 0 : MB_ERR_INVALID_CHARS
;
1650 const size_t len
= ::MultiByteToWideChar
1652 m_CodePage
, // code page
1653 flags
, // flags: fall on error
1654 psz
, // input string
1655 -1, // its length (NUL-terminated)
1656 buf
, // output string
1657 buf
? n
: 0 // size of output buffer
1660 // note that it returns count of written chars for buf != NULL and size
1661 // of the needed buffer for buf == NULL so in either case the length of
1662 // the string (which never includes the terminating NUL) is one less
1663 return len
? len
- 1 : (size_t)-1;
1666 size_t WC2MB(char *buf
, const wchar_t *pwz
, size_t n
) const
1669 we have a problem here: by default, WideCharToMultiByte() may
1670 replace characters unrepresentable in the target code page with bad
1671 quality approximations such as turning "1/2" symbol (U+00BD) into
1672 "1" for the code pages which don't have it and we, obviously, want
1673 to avoid this at any price
1675 the trouble is that this function does it _silently_, i.e. it won't
1676 even tell us whether it did or not... Win98/2000 and higher provide
1677 WC_NO_BEST_FIT_CHARS but it doesn't work for the older systems and
1678 we have to resort to a round trip, i.e. check that converting back
1679 results in the same string -- this is, of course, expensive but
1680 otherwise we simply can't be sure to not garble the data.
1683 // determine if we can rely on WC_NO_BEST_FIT_CHARS: according to MSDN
1684 // it doesn't work with CJK encodings (which we test for rather roughly
1685 // here...) nor with UTF-7/8 nor, of course, with Windows versions not
1687 BOOL usedDef
wxDUMMY_INITIALIZE(false);
1690 if ( CanUseNoBestFit() && m_CodePage
< 50000 )
1692 // it's our lucky day
1693 flags
= WC_NO_BEST_FIT_CHARS
;
1694 pUsedDef
= &usedDef
;
1696 else // old system or unsupported encoding
1702 const size_t len
= ::WideCharToMultiByte
1704 m_CodePage
, // code page
1705 flags
, // either none or no best fit
1706 pwz
, // input string
1707 -1, // it is (wide) NUL-terminated
1708 buf
, // output buffer
1709 buf
? n
: 0, // and its size
1710 NULL
, // default "replacement" char
1711 pUsedDef
// [out] was it used?
1716 // function totally failed
1720 // if we were really converting, check if we succeeded
1725 // check if the conversion failed, i.e. if any replacements
1730 else // we must resort to double tripping...
1732 wxWCharBuffer
wcBuf(n
);
1733 if ( MB2WC(wcBuf
.data(), buf
, n
) == (size_t)-1 ||
1734 wcscmp(wcBuf
, pwz
) != 0 )
1736 // we didn't obtain the same thing we started from, hence
1737 // the conversion was lossy and we consider that it failed
1743 // see the comment above for the reason of "len - 1"
1747 bool IsOk() const { return m_CodePage
!= -1; }
1750 static bool CanUseNoBestFit()
1752 static int s_isWin98Or2k
= -1;
1754 if ( s_isWin98Or2k
== -1 )
1757 switch ( wxGetOsVersion(&verMaj
, &verMin
) )
1760 s_isWin98Or2k
= verMaj
>= 4 && verMin
>= 10;
1764 s_isWin98Or2k
= verMaj
>= 5;
1768 // unknown, be conseravtive by default
1772 wxASSERT_MSG( s_isWin98Or2k
!= -1, _T("should be set above") );
1775 return s_isWin98Or2k
== 1;
1781 #endif // wxHAVE_WIN32_MB2WC
1783 // ============================================================================
1784 // Cocoa conversion classes
1785 // ============================================================================
1787 #if defined(__WXCOCOA__)
1789 // RN: There is no UTF-32 support in either Core Foundation or
1790 // Cocoa. Strangely enough, internally Core Foundation uses
1791 // UTF 32 internally quite a bit - its just not public (yet).
1793 #include <CoreFoundation/CFString.h>
1794 #include <CoreFoundation/CFStringEncodingExt.h>
1796 CFStringEncoding
wxCFStringEncFromFontEnc(wxFontEncoding encoding
)
1798 CFStringEncoding enc
= kCFStringEncodingInvalidId
;
1799 if ( encoding
== wxFONTENCODING_DEFAULT
)
1801 enc
= CFStringGetSystemEncoding();
1803 else switch( encoding
)
1805 case wxFONTENCODING_ISO8859_1
:
1806 enc
= kCFStringEncodingISOLatin1
;
1808 case wxFONTENCODING_ISO8859_2
:
1809 enc
= kCFStringEncodingISOLatin2
;
1811 case wxFONTENCODING_ISO8859_3
:
1812 enc
= kCFStringEncodingISOLatin3
;
1814 case wxFONTENCODING_ISO8859_4
:
1815 enc
= kCFStringEncodingISOLatin4
;
1817 case wxFONTENCODING_ISO8859_5
:
1818 enc
= kCFStringEncodingISOLatinCyrillic
;
1820 case wxFONTENCODING_ISO8859_6
:
1821 enc
= kCFStringEncodingISOLatinArabic
;
1823 case wxFONTENCODING_ISO8859_7
:
1824 enc
= kCFStringEncodingISOLatinGreek
;
1826 case wxFONTENCODING_ISO8859_8
:
1827 enc
= kCFStringEncodingISOLatinHebrew
;
1829 case wxFONTENCODING_ISO8859_9
:
1830 enc
= kCFStringEncodingISOLatin5
;
1832 case wxFONTENCODING_ISO8859_10
:
1833 enc
= kCFStringEncodingISOLatin6
;
1835 case wxFONTENCODING_ISO8859_11
:
1836 enc
= kCFStringEncodingISOLatinThai
;
1838 case wxFONTENCODING_ISO8859_13
:
1839 enc
= kCFStringEncodingISOLatin7
;
1841 case wxFONTENCODING_ISO8859_14
:
1842 enc
= kCFStringEncodingISOLatin8
;
1844 case wxFONTENCODING_ISO8859_15
:
1845 enc
= kCFStringEncodingISOLatin9
;
1848 case wxFONTENCODING_KOI8
:
1849 enc
= kCFStringEncodingKOI8_R
;
1851 case wxFONTENCODING_ALTERNATIVE
: // MS-DOS CP866
1852 enc
= kCFStringEncodingDOSRussian
;
1855 // case wxFONTENCODING_BULGARIAN :
1859 case wxFONTENCODING_CP437
:
1860 enc
=kCFStringEncodingDOSLatinUS
;
1862 case wxFONTENCODING_CP850
:
1863 enc
= kCFStringEncodingDOSLatin1
;
1865 case wxFONTENCODING_CP852
:
1866 enc
= kCFStringEncodingDOSLatin2
;
1868 case wxFONTENCODING_CP855
:
1869 enc
= kCFStringEncodingDOSCyrillic
;
1871 case wxFONTENCODING_CP866
:
1872 enc
=kCFStringEncodingDOSRussian
;
1874 case wxFONTENCODING_CP874
:
1875 enc
= kCFStringEncodingDOSThai
;
1877 case wxFONTENCODING_CP932
:
1878 enc
= kCFStringEncodingDOSJapanese
;
1880 case wxFONTENCODING_CP936
:
1881 enc
=kCFStringEncodingDOSChineseSimplif
;
1883 case wxFONTENCODING_CP949
:
1884 enc
= kCFStringEncodingDOSKorean
;
1886 case wxFONTENCODING_CP950
:
1887 enc
= kCFStringEncodingDOSChineseTrad
;
1889 case wxFONTENCODING_CP1250
:
1890 enc
= kCFStringEncodingWindowsLatin2
;
1892 case wxFONTENCODING_CP1251
:
1893 enc
=kCFStringEncodingWindowsCyrillic
;
1895 case wxFONTENCODING_CP1252
:
1896 enc
=kCFStringEncodingWindowsLatin1
;
1898 case wxFONTENCODING_CP1253
:
1899 enc
= kCFStringEncodingWindowsGreek
;
1901 case wxFONTENCODING_CP1254
:
1902 enc
= kCFStringEncodingWindowsLatin5
;
1904 case wxFONTENCODING_CP1255
:
1905 enc
=kCFStringEncodingWindowsHebrew
;
1907 case wxFONTENCODING_CP1256
:
1908 enc
=kCFStringEncodingWindowsArabic
;
1910 case wxFONTENCODING_CP1257
:
1911 enc
= kCFStringEncodingWindowsBalticRim
;
1913 // This only really encodes to UTF7 (if that) evidently
1914 // case wxFONTENCODING_UTF7 :
1915 // enc = kCFStringEncodingNonLossyASCII ;
1917 case wxFONTENCODING_UTF8
:
1918 enc
= kCFStringEncodingUTF8
;
1920 case wxFONTENCODING_EUC_JP
:
1921 enc
= kCFStringEncodingEUC_JP
;
1923 case wxFONTENCODING_UTF16
:
1924 enc
= kCFStringEncodingUnicode
;
1926 case wxFONTENCODING_MACROMAN
:
1927 enc
= kCFStringEncodingMacRoman
;
1929 case wxFONTENCODING_MACJAPANESE
:
1930 enc
= kCFStringEncodingMacJapanese
;
1932 case wxFONTENCODING_MACCHINESETRAD
:
1933 enc
= kCFStringEncodingMacChineseTrad
;
1935 case wxFONTENCODING_MACKOREAN
:
1936 enc
= kCFStringEncodingMacKorean
;
1938 case wxFONTENCODING_MACARABIC
:
1939 enc
= kCFStringEncodingMacArabic
;
1941 case wxFONTENCODING_MACHEBREW
:
1942 enc
= kCFStringEncodingMacHebrew
;
1944 case wxFONTENCODING_MACGREEK
:
1945 enc
= kCFStringEncodingMacGreek
;
1947 case wxFONTENCODING_MACCYRILLIC
:
1948 enc
= kCFStringEncodingMacCyrillic
;
1950 case wxFONTENCODING_MACDEVANAGARI
:
1951 enc
= kCFStringEncodingMacDevanagari
;
1953 case wxFONTENCODING_MACGURMUKHI
:
1954 enc
= kCFStringEncodingMacGurmukhi
;
1956 case wxFONTENCODING_MACGUJARATI
:
1957 enc
= kCFStringEncodingMacGujarati
;
1959 case wxFONTENCODING_MACORIYA
:
1960 enc
= kCFStringEncodingMacOriya
;
1962 case wxFONTENCODING_MACBENGALI
:
1963 enc
= kCFStringEncodingMacBengali
;
1965 case wxFONTENCODING_MACTAMIL
:
1966 enc
= kCFStringEncodingMacTamil
;
1968 case wxFONTENCODING_MACTELUGU
:
1969 enc
= kCFStringEncodingMacTelugu
;
1971 case wxFONTENCODING_MACKANNADA
:
1972 enc
= kCFStringEncodingMacKannada
;
1974 case wxFONTENCODING_MACMALAJALAM
:
1975 enc
= kCFStringEncodingMacMalayalam
;
1977 case wxFONTENCODING_MACSINHALESE
:
1978 enc
= kCFStringEncodingMacSinhalese
;
1980 case wxFONTENCODING_MACBURMESE
:
1981 enc
= kCFStringEncodingMacBurmese
;
1983 case wxFONTENCODING_MACKHMER
:
1984 enc
= kCFStringEncodingMacKhmer
;
1986 case wxFONTENCODING_MACTHAI
:
1987 enc
= kCFStringEncodingMacThai
;
1989 case wxFONTENCODING_MACLAOTIAN
:
1990 enc
= kCFStringEncodingMacLaotian
;
1992 case wxFONTENCODING_MACGEORGIAN
:
1993 enc
= kCFStringEncodingMacGeorgian
;
1995 case wxFONTENCODING_MACARMENIAN
:
1996 enc
= kCFStringEncodingMacArmenian
;
1998 case wxFONTENCODING_MACCHINESESIMP
:
1999 enc
= kCFStringEncodingMacChineseSimp
;
2001 case wxFONTENCODING_MACTIBETAN
:
2002 enc
= kCFStringEncodingMacTibetan
;
2004 case wxFONTENCODING_MACMONGOLIAN
:
2005 enc
= kCFStringEncodingMacMongolian
;
2007 case wxFONTENCODING_MACETHIOPIC
:
2008 enc
= kCFStringEncodingMacEthiopic
;
2010 case wxFONTENCODING_MACCENTRALEUR
:
2011 enc
= kCFStringEncodingMacCentralEurRoman
;
2013 case wxFONTENCODING_MACVIATNAMESE
:
2014 enc
= kCFStringEncodingMacVietnamese
;
2016 case wxFONTENCODING_MACARABICEXT
:
2017 enc
= kCFStringEncodingMacExtArabic
;
2019 case wxFONTENCODING_MACSYMBOL
:
2020 enc
= kCFStringEncodingMacSymbol
;
2022 case wxFONTENCODING_MACDINGBATS
:
2023 enc
= kCFStringEncodingMacDingbats
;
2025 case wxFONTENCODING_MACTURKISH
:
2026 enc
= kCFStringEncodingMacTurkish
;
2028 case wxFONTENCODING_MACCROATIAN
:
2029 enc
= kCFStringEncodingMacCroatian
;
2031 case wxFONTENCODING_MACICELANDIC
:
2032 enc
= kCFStringEncodingMacIcelandic
;
2034 case wxFONTENCODING_MACROMANIAN
:
2035 enc
= kCFStringEncodingMacRomanian
;
2037 case wxFONTENCODING_MACCELTIC
:
2038 enc
= kCFStringEncodingMacCeltic
;
2040 case wxFONTENCODING_MACGAELIC
:
2041 enc
= kCFStringEncodingMacGaelic
;
2043 // case wxFONTENCODING_MACKEYBOARD :
2044 // enc = kCFStringEncodingMacKeyboardGlyphs ;
2047 // because gcc is picky
2053 class wxMBConv_cocoa
: public wxMBConv
2058 Init(CFStringGetSystemEncoding()) ;
2062 wxMBConv_cocoa(const wxChar
* name
)
2064 Init( wxCFStringEncFromFontEnc(wxFontMapperBase::Get()->CharsetToEncoding(name
, false) ) ) ;
2068 wxMBConv_cocoa(wxFontEncoding encoding
)
2070 Init( wxCFStringEncFromFontEnc(encoding
) );
2077 void Init( CFStringEncoding encoding
)
2079 m_encoding
= encoding
;
2082 size_t MB2WC(wchar_t * szOut
, const char * szUnConv
, size_t nOutSize
) const
2086 CFStringRef theString
= CFStringCreateWithBytes (
2087 NULL
, //the allocator
2088 (const UInt8
*)szUnConv
,
2091 false //no BOM/external representation
2094 wxASSERT(theString
);
2096 size_t nOutLength
= CFStringGetLength(theString
);
2100 CFRelease(theString
);
2104 CFRange theRange
= { 0, nOutSize
};
2106 #if SIZEOF_WCHAR_T == 4
2107 UniChar
* szUniCharBuffer
= new UniChar
[nOutSize
];
2110 CFStringGetCharacters(theString
, theRange
, szUniCharBuffer
);
2112 CFRelease(theString
);
2114 szUniCharBuffer
[nOutLength
] = '\0' ;
2116 #if SIZEOF_WCHAR_T == 4
2117 wxMBConvUTF16 converter
;
2118 converter
.MB2WC(szOut
, (const char*)szUniCharBuffer
, nOutSize
) ;
2119 delete[] szUniCharBuffer
;
2125 size_t WC2MB(char *szOut
, const wchar_t *szUnConv
, size_t nOutSize
) const
2129 size_t nRealOutSize
;
2130 size_t nBufSize
= wxWcslen(szUnConv
);
2131 UniChar
* szUniBuffer
= (UniChar
*) szUnConv
;
2133 #if SIZEOF_WCHAR_T == 4
2134 wxMBConvUTF16 converter
;
2135 nBufSize
= converter
.WC2MB( NULL
, szUnConv
, 0 );
2136 szUniBuffer
= new UniChar
[ (nBufSize
/ sizeof(UniChar
)) + 1] ;
2137 converter
.WC2MB( (char*) szUniBuffer
, szUnConv
, nBufSize
+ sizeof(UniChar
)) ;
2138 nBufSize
/= sizeof(UniChar
);
2141 CFStringRef theString
= CFStringCreateWithCharactersNoCopy(
2145 kCFAllocatorNull
//deallocator - we want to deallocate it ourselves
2148 wxASSERT(theString
);
2150 //Note that CER puts a BOM when converting to unicode
2151 //so we check and use getchars instead in that case
2152 if (m_encoding
== kCFStringEncodingUnicode
)
2155 CFStringGetCharacters(theString
, CFRangeMake(0, nOutSize
- 1), (UniChar
*) szOut
);
2157 nRealOutSize
= CFStringGetLength(theString
) + 1;
2163 CFRangeMake(0, CFStringGetLength(theString
)),
2165 0, //what to put in characters that can't be converted -
2166 //0 tells CFString to return NULL if it meets such a character
2167 false, //not an external representation
2170 (CFIndex
*) &nRealOutSize
2174 CFRelease(theString
);
2176 #if SIZEOF_WCHAR_T == 4
2177 delete[] szUniBuffer
;
2180 return nRealOutSize
- 1;
2185 return m_encoding
!= kCFStringEncodingInvalidId
&&
2186 CFStringIsEncodingAvailable(m_encoding
);
2190 CFStringEncoding m_encoding
;
2193 #endif // defined(__WXCOCOA__)
2195 // ============================================================================
2196 // Mac conversion classes
2197 // ============================================================================
2199 #if defined(__WXMAC__) && defined(TARGET_CARBON)
2201 class wxMBConv_mac
: public wxMBConv
2206 Init(CFStringGetSystemEncoding()) ;
2210 wxMBConv_mac(const wxChar
* name
)
2212 Init( wxMacGetSystemEncFromFontEnc(wxFontMapperBase::Get()->CharsetToEncoding(name
, false) ) ) ;
2216 wxMBConv_mac(wxFontEncoding encoding
)
2218 Init( wxMacGetSystemEncFromFontEnc(encoding
) );
2223 OSStatus status
= noErr
;
2224 status
= TECDisposeConverter(m_MB2WC_converter
);
2225 status
= TECDisposeConverter(m_WC2MB_converter
);
2229 void Init( TextEncodingBase encoding
)
2231 OSStatus status
= noErr
;
2232 m_char_encoding
= encoding
;
2233 m_unicode_encoding
= CreateTextEncoding(kTextEncodingUnicodeDefault
,0,kUnicode16BitFormat
) ;
2235 status
= TECCreateConverter(&m_MB2WC_converter
,
2237 m_unicode_encoding
);
2238 status
= TECCreateConverter(&m_WC2MB_converter
,
2243 size_t MB2WC(wchar_t *buf
, const char *psz
, size_t n
) const
2245 OSStatus status
= noErr
;
2246 ByteCount byteOutLen
;
2247 ByteCount byteInLen
= strlen(psz
) ;
2248 wchar_t *tbuf
= NULL
;
2249 UniChar
* ubuf
= NULL
;
2254 //apple specs say at least 32
2255 n
= wxMax( 32 , byteInLen
) ;
2256 tbuf
= (wchar_t*) malloc( n
* SIZEOF_WCHAR_T
) ;
2258 ByteCount byteBufferLen
= n
* sizeof( UniChar
) ;
2259 #if SIZEOF_WCHAR_T == 4
2260 ubuf
= (UniChar
*) malloc( byteBufferLen
+ 2 ) ;
2262 ubuf
= (UniChar
*) (buf
? buf
: tbuf
) ;
2264 status
= TECConvertText(m_MB2WC_converter
, (ConstTextPtr
) psz
, byteInLen
, &byteInLen
,
2265 (TextPtr
) ubuf
, byteBufferLen
, &byteOutLen
);
2266 #if SIZEOF_WCHAR_T == 4
2267 // we have to terminate here, because n might be larger for the trailing zero, and if UniChar
2268 // is not properly terminated we get random characters at the end
2269 ubuf
[byteOutLen
/ sizeof( UniChar
) ] = 0 ;
2270 wxMBConvUTF16 converter
;
2271 res
= converter
.MB2WC( (buf
? buf
: tbuf
) , (const char*)ubuf
, n
) ;
2274 res
= byteOutLen
/ sizeof( UniChar
) ;
2279 if ( buf
&& res
< n
)
2285 size_t WC2MB(char *buf
, const wchar_t *psz
, size_t n
) const
2287 OSStatus status
= noErr
;
2288 ByteCount byteOutLen
;
2289 ByteCount byteInLen
= wxWcslen(psz
) * SIZEOF_WCHAR_T
;
2295 //apple specs say at least 32
2296 n
= wxMax( 32 , ((byteInLen
/ SIZEOF_WCHAR_T
) * 8) + SIZEOF_WCHAR_T
);
2297 tbuf
= (char*) malloc( n
) ;
2300 ByteCount byteBufferLen
= n
;
2301 UniChar
* ubuf
= NULL
;
2302 #if SIZEOF_WCHAR_T == 4
2303 wxMBConvUTF16 converter
;
2304 size_t unicharlen
= converter
.WC2MB( NULL
, psz
, 0 ) ;
2305 byteInLen
= unicharlen
;
2306 ubuf
= (UniChar
*) malloc( byteInLen
+ 2 ) ;
2307 converter
.WC2MB( (char*) ubuf
, psz
, unicharlen
+ 2 ) ;
2309 ubuf
= (UniChar
*) psz
;
2311 status
= TECConvertText(m_WC2MB_converter
, (ConstTextPtr
) ubuf
, byteInLen
, &byteInLen
,
2312 (TextPtr
) (buf
? buf
: tbuf
) , byteBufferLen
, &byteOutLen
);
2313 #if SIZEOF_WCHAR_T == 4
2319 size_t res
= byteOutLen
;
2320 if ( buf
&& res
< n
)
2324 //we need to double-trip to verify it didn't insert any ? in place
2325 //of bogus characters
2326 wxWCharBuffer
wcBuf(n
);
2327 size_t pszlen
= wxWcslen(psz
);
2328 if ( MB2WC(wcBuf
.data(), buf
, n
) == (size_t)-1 ||
2329 wxWcslen(wcBuf
) != pszlen
||
2330 memcmp(wcBuf
, psz
, pszlen
* sizeof(wchar_t)) != 0 )
2332 // we didn't obtain the same thing we started from, hence
2333 // the conversion was lossy and we consider that it failed
2342 { return m_MB2WC_converter
!= NULL
&& m_WC2MB_converter
!= NULL
; }
2345 TECObjectRef m_MB2WC_converter
;
2346 TECObjectRef m_WC2MB_converter
;
2348 TextEncodingBase m_char_encoding
;
2349 TextEncodingBase m_unicode_encoding
;
2352 #endif // defined(__WXMAC__) && defined(TARGET_CARBON)
2354 // ============================================================================
2355 // wxEncodingConverter based conversion classes
2356 // ============================================================================
2360 class wxMBConv_wxwin
: public wxMBConv
2365 m_ok
= m2w
.Init(m_enc
, wxFONTENCODING_UNICODE
) &&
2366 w2m
.Init(wxFONTENCODING_UNICODE
, m_enc
);
2370 // temporarily just use wxEncodingConverter stuff,
2371 // so that it works while a better implementation is built
2372 wxMBConv_wxwin(const wxChar
* name
)
2375 m_enc
= wxFontMapperBase::Get()->CharsetToEncoding(name
, false);
2377 m_enc
= wxFONTENCODING_SYSTEM
;
2382 wxMBConv_wxwin(wxFontEncoding enc
)
2389 size_t MB2WC(wchar_t *buf
, const char *psz
, size_t WXUNUSED(n
)) const
2391 size_t inbuf
= strlen(psz
);
2394 if (!m2w
.Convert(psz
,buf
))
2400 size_t WC2MB(char *buf
, const wchar_t *psz
, size_t WXUNUSED(n
)) const
2402 const size_t inbuf
= wxWcslen(psz
);
2405 if (!w2m
.Convert(psz
,buf
))
2412 bool IsOk() const { return m_ok
; }
2415 wxFontEncoding m_enc
;
2416 wxEncodingConverter m2w
, w2m
;
2418 // were we initialized successfully?
2421 DECLARE_NO_COPY_CLASS(wxMBConv_wxwin
)
2424 // make the constructors available for unit testing
2425 WXDLLIMPEXP_BASE wxMBConv
* new_wxMBConv_wxwin( const wxChar
* name
)
2427 wxMBConv_wxwin
* result
= new wxMBConv_wxwin( name
);
2428 if ( !result
->IsOk() )
2436 #endif // wxUSE_FONTMAP
2438 // ============================================================================
2439 // wxCSConv implementation
2440 // ============================================================================
2442 void wxCSConv::Init()
2449 wxCSConv::wxCSConv(const wxChar
*charset
)
2458 m_encoding
= wxFONTENCODING_SYSTEM
;
2461 wxCSConv::wxCSConv(wxFontEncoding encoding
)
2463 if ( encoding
== wxFONTENCODING_MAX
|| encoding
== wxFONTENCODING_DEFAULT
)
2465 wxFAIL_MSG( _T("invalid encoding value in wxCSConv ctor") );
2467 encoding
= wxFONTENCODING_SYSTEM
;
2472 m_encoding
= encoding
;
2475 wxCSConv::~wxCSConv()
2480 wxCSConv::wxCSConv(const wxCSConv
& conv
)
2485 SetName(conv
.m_name
);
2486 m_encoding
= conv
.m_encoding
;
2489 wxCSConv
& wxCSConv::operator=(const wxCSConv
& conv
)
2493 SetName(conv
.m_name
);
2494 m_encoding
= conv
.m_encoding
;
2499 void wxCSConv::Clear()
2508 void wxCSConv::SetName(const wxChar
*charset
)
2512 m_name
= wxStrdup(charset
);
2518 #include "wx/hashmap.h"
2520 WX_DECLARE_HASH_MAP( wxFontEncoding
, wxString
, wxIntegerHash
, wxIntegerEqual
,
2521 wxEncodingNameCache
);
2523 static wxEncodingNameCache gs_nameCache
;
2526 wxMBConv
*wxCSConv::DoCreate() const
2529 wxLogTrace(TRACE_STRCONV
,
2530 wxT("creating conversion for %s"),
2532 : wxFontMapperBase::GetEncodingName(m_encoding
).c_str()));
2533 #endif // wxUSE_FONTMAP
2535 // check for the special case of ASCII or ISO8859-1 charset: as we have
2536 // special knowledge of it anyhow, we don't need to create a special
2537 // conversion object
2538 if ( m_encoding
== wxFONTENCODING_ISO8859_1
)
2540 // don't convert at all
2544 // we trust OS to do conversion better than we can so try external
2545 // conversion methods first
2547 // the full order is:
2548 // 1. OS conversion (iconv() under Unix or Win32 API)
2549 // 2. hard coded conversions for UTF
2550 // 3. wxEncodingConverter as fall back
2556 #endif // !wxUSE_FONTMAP
2558 wxString
name(m_name
);
2559 wxFontEncoding
encoding(m_encoding
);
2561 if ( !name
.empty() )
2563 wxMBConv_iconv
*conv
= new wxMBConv_iconv(name
);
2571 wxFontMapperBase::Get()->CharsetToEncoding(name
, false);
2572 #endif // wxUSE_FONTMAP
2576 const wxEncodingNameCache::iterator it
= gs_nameCache
.find(encoding
);
2577 if ( it
!= gs_nameCache
.end() )
2579 if ( it
->second
.empty() )
2582 wxMBConv_iconv
*conv
= new wxMBConv_iconv(it
->second
);
2589 const wxChar
** names
= wxFontMapperBase::GetAllEncodingNames(encoding
);
2591 for ( ; *names
; ++names
)
2593 wxMBConv_iconv
*conv
= new wxMBConv_iconv(*names
);
2596 gs_nameCache
[encoding
] = *names
;
2603 gs_nameCache
[encoding
] = _T(""); // cache the failure
2605 #endif // wxUSE_FONTMAP
2607 #endif // HAVE_ICONV
2609 #ifdef wxHAVE_WIN32_MB2WC
2612 wxMBConv_win32
*conv
= m_name
? new wxMBConv_win32(m_name
)
2613 : new wxMBConv_win32(m_encoding
);
2622 #endif // wxHAVE_WIN32_MB2WC
2623 #if defined(__WXMAC__)
2625 // leave UTF16 and UTF32 to the built-ins of wx
2626 if ( m_name
|| ( m_encoding
< wxFONTENCODING_UTF16BE
||
2627 ( m_encoding
>= wxFONTENCODING_MACMIN
&& m_encoding
<= wxFONTENCODING_MACMAX
) ) )
2631 wxMBConv_mac
*conv
= m_name
? new wxMBConv_mac(m_name
)
2632 : new wxMBConv_mac(m_encoding
);
2634 wxMBConv_mac
*conv
= new wxMBConv_mac(m_encoding
);
2643 #if defined(__WXCOCOA__)
2645 if ( m_name
|| ( m_encoding
<= wxFONTENCODING_UTF16
) )
2649 wxMBConv_cocoa
*conv
= m_name
? new wxMBConv_cocoa(m_name
)
2650 : new wxMBConv_cocoa(m_encoding
);
2652 wxMBConv_cocoa
*conv
= new wxMBConv_cocoa(m_encoding
);
2662 wxFontEncoding enc
= m_encoding
;
2664 if ( enc
== wxFONTENCODING_SYSTEM
&& m_name
)
2666 // use "false" to suppress interactive dialogs -- we can be called from
2667 // anywhere and popping up a dialog from here is the last thing we want to
2669 enc
= wxFontMapperBase::Get()->CharsetToEncoding(m_name
, false);
2671 #endif // wxUSE_FONTMAP
2675 case wxFONTENCODING_UTF7
:
2676 return new wxMBConvUTF7
;
2678 case wxFONTENCODING_UTF8
:
2679 return new wxMBConvUTF8
;
2681 case wxFONTENCODING_UTF16BE
:
2682 return new wxMBConvUTF16BE
;
2684 case wxFONTENCODING_UTF16LE
:
2685 return new wxMBConvUTF16LE
;
2687 case wxFONTENCODING_UTF32BE
:
2688 return new wxMBConvUTF32BE
;
2690 case wxFONTENCODING_UTF32LE
:
2691 return new wxMBConvUTF32LE
;
2694 // nothing to do but put here to suppress gcc warnings
2701 wxMBConv_wxwin
*conv
= m_name
? new wxMBConv_wxwin(m_name
)
2702 : new wxMBConv_wxwin(m_encoding
);
2708 #endif // wxUSE_FONTMAP
2710 // NB: This is a hack to prevent deadlock. What could otherwise happen
2711 // in Unicode build: wxConvLocal creation ends up being here
2712 // because of some failure and logs the error. But wxLog will try to
2713 // attach timestamp, for which it will need wxConvLocal (to convert
2714 // time to char* and then wchar_t*), but that fails, tries to log
2715 // error, but wxLog has a (already locked) critical section that
2716 // guards static buffer.
2717 static bool alreadyLoggingError
= false;
2718 if (!alreadyLoggingError
)
2720 alreadyLoggingError
= true;
2721 wxLogError(_("Cannot convert from the charset '%s'!"),
2725 wxFontMapperBase::GetEncodingDescription(m_encoding
).c_str()
2726 #else // !wxUSE_FONTMAP
2727 wxString::Format(_("encoding %s"), m_encoding
).c_str()
2728 #endif // wxUSE_FONTMAP/!wxUSE_FONTMAP
2730 alreadyLoggingError
= false;
2736 void wxCSConv::CreateConvIfNeeded() const
2740 wxCSConv
*self
= (wxCSConv
*)this; // const_cast
2743 // if we don't have neither the name nor the encoding, use the default
2744 // encoding for this system
2745 if ( !m_name
&& m_encoding
== wxFONTENCODING_SYSTEM
)
2747 self
->m_name
= wxStrdup(wxLocale::GetSystemEncodingName());
2749 #endif // wxUSE_INTL
2751 self
->m_convReal
= DoCreate();
2752 self
->m_deferred
= false;
2756 size_t wxCSConv::MB2WC(wchar_t *buf
, const char *psz
, size_t n
) const
2758 CreateConvIfNeeded();
2761 return m_convReal
->MB2WC(buf
, psz
, n
);
2764 size_t len
= strlen(psz
);
2768 for (size_t c
= 0; c
<= len
; c
++)
2769 buf
[c
] = (unsigned char)(psz
[c
]);
2775 size_t wxCSConv::WC2MB(char *buf
, const wchar_t *psz
, size_t n
) const
2777 CreateConvIfNeeded();
2780 return m_convReal
->WC2MB(buf
, psz
, n
);
2783 const size_t len
= wxWcslen(psz
);
2786 for (size_t c
= 0; c
<= len
; c
++)
2790 buf
[c
] = (char)psz
[c
];
2795 for (size_t c
= 0; c
<= len
; c
++)
2805 // ----------------------------------------------------------------------------
2807 // ----------------------------------------------------------------------------
2810 static wxMBConv_win32 wxConvLibcObj
;
2811 #elif defined(__WXMAC__) && !defined(__MACH__)
2812 static wxMBConv_mac wxConvLibcObj
;
2814 static wxMBConvLibc wxConvLibcObj
;
2817 static wxCSConv
wxConvLocalObj(wxFONTENCODING_SYSTEM
);
2818 static wxCSConv
wxConvISO8859_1Obj(wxFONTENCODING_ISO8859_1
);
2819 static wxMBConvUTF7 wxConvUTF7Obj
;
2820 static wxMBConvUTF8 wxConvUTF8Obj
;
2822 WXDLLIMPEXP_DATA_BASE(wxMBConv
&) wxConvLibc
= wxConvLibcObj
;
2823 WXDLLIMPEXP_DATA_BASE(wxCSConv
&) wxConvLocal
= wxConvLocalObj
;
2824 WXDLLIMPEXP_DATA_BASE(wxCSConv
&) wxConvISO8859_1
= wxConvISO8859_1Obj
;
2825 WXDLLIMPEXP_DATA_BASE(wxMBConvUTF7
&) wxConvUTF7
= wxConvUTF7Obj
;
2826 WXDLLIMPEXP_DATA_BASE(wxMBConvUTF8
&) wxConvUTF8
= wxConvUTF8Obj
;
2827 WXDLLIMPEXP_DATA_BASE(wxMBConv
*) wxConvCurrent
= &wxConvLibcObj
;
2828 WXDLLIMPEXP_DATA_BASE(wxMBConv
*) wxConvFileName
= &
2836 #else // !wxUSE_WCHAR_T
2838 // stand-ins in absence of wchar_t
2839 WXDLLIMPEXP_DATA_BASE(wxMBConv
) wxConvLibc
,
2844 #endif // wxUSE_WCHAR_T/!wxUSE_WCHAR_T