]> git.saurik.com Git - wxWidgets.git/blame_incremental - src/common/strconv.cpp
projects / wxWidgets.git / blame_incremental
? search:
summary | shortlog | log | commit | commitdiff | tree
blob | blame (non-incremental) | history | HEAD
Applied patch [ 1428990 ] wxUniv: patch for toolbar button remain in pressed status
[wxWidgets.git] / src / common / strconv.cpp
... / ...
CommitLineData
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)
6// Modified by:
7// Created: 29/01/98
8// RCS-ID: $Id$
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/////////////////////////////////////////////////////////////////////////////
14
15// ============================================================================
16// declarations
17// ============================================================================
18
19// ----------------------------------------------------------------------------
20// headers
21// ----------------------------------------------------------------------------
22
23// For compilers that support precompilation, includes "wx.h".
24#include "wx/wxprec.h"
25
26#ifdef __BORLANDC__
27 #pragma hdrstop
28#endif
29
30#ifndef WX_PRECOMP
31 #include "wx/intl.h"
32 #include "wx/log.h"
33#endif // WX_PRECOMP
34
35#include "wx/strconv.h"
36
37#if wxUSE_WCHAR_T
38
39#ifdef __WINDOWS__
40 #include "wx/msw/private.h"
41 #include "wx/msw/missing.h"
42#endif
43
44#ifndef __WXWINCE__
45#include <errno.h>
46#endif
47
48#include <ctype.h>
49#include <string.h>
50#include <stdlib.h>
51
52#if defined(__WIN32__) && !defined(__WXMICROWIN__)
53 #define wxHAVE_WIN32_MB2WC
54#endif // __WIN32__ but !__WXMICROWIN__
55
56#ifdef __SALFORDC__
57 #include <clib.h>
58#endif
59
60#ifdef HAVE_ICONV
61 #include <iconv.h>
62 #include "wx/thread.h"
63#endif
64
65#include "wx/encconv.h"
66#include "wx/fontmap.h"
67#include "wx/utils.h"
68
69#ifdef __WXMAC__
70#ifndef __DARWIN__
71#include <ATSUnicode.h>
72#include <TextCommon.h>
73#include <TextEncodingConverter.h>
74#endif
75
76#include "wx/mac/private.h" // includes mac headers
77#endif
78
79#define TRACE_STRCONV _T("strconv")
80
81#if SIZEOF_WCHAR_T == 2
82 #define WC_UTF16
83#endif
84
85// ============================================================================
86// implementation
87// ============================================================================
88
89// ----------------------------------------------------------------------------
90// UTF-16 en/decoding to/from UCS-4
91// ----------------------------------------------------------------------------
92
93
94static size_t encode_utf16(wxUint32 input, wxUint16 *output)
95{
96 if (input<=0xffff)
97 {
98 if (output)
99 *output = (wxUint16) input;
100 return 1;
101 }
102 else if (input>=0x110000)
103 {
104 return (size_t)-1;
105 }
106 else
107 {
108 if (output)
109 {
110 *output++ = (wxUint16) ((input >> 10)+0xd7c0);
111 *output = (wxUint16) ((input&0x3ff)+0xdc00);
112 }
113 return 2;
114 }
115}
116
117static size_t decode_utf16(const wxUint16* input, wxUint32& output)
118{
119 if ((*input<0xd800) || (*input>0xdfff))
120 {
121 output = *input;
122 return 1;
123 }
124 else if ((input[1]<0xdc00) || (input[1]>0xdfff))
125 {
126 output = *input;
127 return (size_t)-1;
128 }
129 else
130 {
131 output = ((input[0] - 0xd7c0) << 10) + (input[1] - 0xdc00);
132 return 2;
133 }
134}
135
136
137// ----------------------------------------------------------------------------
138// wxMBConv
139// ----------------------------------------------------------------------------
140
141wxMBConv::~wxMBConv()
142{
143 // nothing to do here (necessary for Darwin linking probably)
144}
145
146const wxWCharBuffer wxMBConv::cMB2WC(const char *psz) const
147{
148 if ( psz )
149 {
150 // calculate the length of the buffer needed first
151 size_t nLen = MB2WC(NULL, psz, 0);
152 if ( nLen != (size_t)-1 )
153 {
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 )
158 {
159 return buf;
160 }
161 }
162 }
163
164 wxWCharBuffer buf((wchar_t *)NULL);
165
166 return buf;
167}
168
169const wxCharBuffer wxMBConv::cWC2MB(const wchar_t *pwz) const
170{
171 if ( pwz )
172 {
173 size_t nLen = WC2MB(NULL, pwz, 0);
174 if ( nLen != (size_t)-1 )
175 {
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 )
179 {
180 return buf;
181 }
182 }
183 }
184
185 wxCharBuffer buf((char *)NULL);
186
187 return buf;
188}
189
190const wxWCharBuffer wxMBConv::cMB2WC(const char *szString, size_t nStringLen, size_t* pOutSize) const
191{
192 wxASSERT(pOutSize != NULL);
193
194 const char* szEnd = szString + nStringLen + 1;
195 const char* szPos = szString;
196 const char* szStart = szPos;
197
198 size_t nActualLength = 0;
199 size_t nCurrentSize = nStringLen; //try normal size first (should never resize?)
200
201 wxWCharBuffer theBuffer(nCurrentSize);
202
203 //Convert the string until the length() is reached, continuing the
204 //loop every time a null character is reached
205 while(szPos != szEnd)
206 {
207 wxASSERT(szPos < szEnd); //something is _really_ screwed up if this rings true
208
209 //Get the length of the current (sub)string
210 size_t nLen = MB2WC(NULL, szPos, 0);
211
212 //Invalid conversion?
213 if( nLen == (size_t)-1 )
214 {
215 *pOutSize = 0;
216 theBuffer.data()[0u] = wxT('\0');
217 return theBuffer;
218 }
219
220
221 //Increase the actual length (+1 for current null character)
222 nActualLength += nLen + 1;
223
224 //if buffer too big, realloc the buffer
225 if (nActualLength > (nCurrentSize+1))
226 {
227 wxWCharBuffer theNewBuffer(nCurrentSize << 1);
228 memcpy(theNewBuffer.data(), theBuffer.data(), nCurrentSize * sizeof(wchar_t));
229 theBuffer = theNewBuffer;
230 nCurrentSize <<= 1;
231 }
232
233 //Convert the current (sub)string
234 if ( MB2WC(&theBuffer.data()[szPos - szStart], szPos, nLen + 1) == (size_t)-1 )
235 {
236 *pOutSize = 0;
237 theBuffer.data()[0u] = wxT('\0');
238 return theBuffer;
239 }
240
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;
246 }
247
248 //success - return actual length and the buffer
249 *pOutSize = nActualLength;
250 return theBuffer;
251}
252
253const wxCharBuffer wxMBConv::cWC2MB(const wchar_t *szString, size_t nStringLen, size_t* pOutSize) const
254{
255 wxASSERT(pOutSize != NULL);
256
257 const wchar_t* szEnd = szString + nStringLen + 1;
258 const wchar_t* szPos = szString;
259 const wchar_t* szStart = szPos;
260
261 size_t nActualLength = 0;
262 size_t nCurrentSize = nStringLen << 2; //try * 4 first
263
264 wxCharBuffer theBuffer(nCurrentSize);
265
266 //Convert the string until the length() is reached, continuing the
267 //loop every time a null character is reached
268 while(szPos != szEnd)
269 {
270 wxASSERT(szPos < szEnd); //something is _really_ screwed up if this rings true
271
272 //Get the length of the current (sub)string
273 size_t nLen = WC2MB(NULL, szPos, 0);
274
275 //Invalid conversion?
276 if( nLen == (size_t)-1 )
277 {
278 *pOutSize = 0;
279 theBuffer.data()[0u] = wxT('\0');
280 return theBuffer;
281 }
282
283 //Increase the actual length (+1 for current null character)
284 nActualLength += nLen + 1;
285
286 //if buffer too big, realloc the buffer
287 if (nActualLength > (nCurrentSize+1))
288 {
289 wxCharBuffer theNewBuffer(nCurrentSize << 1);
290 memcpy(theNewBuffer.data(), theBuffer.data(), nCurrentSize);
291 theBuffer = theNewBuffer;
292 nCurrentSize <<= 1;
293 }
294
295 //Convert the current (sub)string
296 if(WC2MB(&theBuffer.data()[szPos - szStart], szPos, nLen + 1) == (size_t)-1 )
297 {
298 *pOutSize = 0;
299 theBuffer.data()[0u] = wxT('\0');
300 return theBuffer;
301 }
302
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;
308 }
309
310 //success - return actual length and the buffer
311 *pOutSize = nActualLength;
312 return theBuffer;
313}
314
315// ----------------------------------------------------------------------------
316// wxMBConvLibc
317// ----------------------------------------------------------------------------
318
319size_t wxMBConvLibc::MB2WC(wchar_t *buf, const char *psz, size_t n) const
320{
321 return wxMB2WC(buf, psz, n);
322}
323
324size_t wxMBConvLibc::WC2MB(char *buf, const wchar_t *psz, size_t n) const
325{
326 return wxWC2MB(buf, psz, n);
327}
328
329#ifdef __UNIX__
330
331// ----------------------------------------------------------------------------
332// wxConvBrokenFileNames
333// ----------------------------------------------------------------------------
334
335wxConvBrokenFileNames::wxConvBrokenFileNames(const wxChar *charset)
336{
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);
340 else
341 m_conv = new wxCSConv(charset);
342}
343
344size_t
345wxConvBrokenFileNames::MB2WC(wchar_t *outputBuf,
346 const char *psz,
347 size_t outputSize) const
348{
349 return m_conv->MB2WC( outputBuf, psz, outputSize );
350}
351
352size_t
353wxConvBrokenFileNames::WC2MB(char *outputBuf,
354 const wchar_t *psz,
355 size_t outputSize) const
356{
357 return m_conv->WC2MB( outputBuf, psz, outputSize );
358}
359
360#endif
361
362// ----------------------------------------------------------------------------
363// UTF-7
364// ----------------------------------------------------------------------------
365
366// Implementation (C) 2004 Fredrik Roubert
367
368//
369// BASE64 decoding table
370//
371static const unsigned char utf7unb64[] =
372{
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
405};
406
407size_t wxMBConvUTF7::MB2WC(wchar_t *buf, const char *psz, size_t n) const
408{
409 size_t len = 0;
410
411 while (*psz && ((!buf) || (len < n)))
412 {
413 unsigned char cc = *psz++;
414 if (cc != '+')
415 {
416 // plain ASCII char
417 if (buf)
418 *buf++ = cc;
419 len++;
420 }
421 else if (*psz == '-')
422 {
423 // encoded plus sign
424 if (buf)
425 *buf++ = cc;
426 len++;
427 psz++;
428 }
429 else
430 {
431 // BASE64 encoded string
432 bool lsb;
433 unsigned char c;
434 unsigned int d, l;
435 for (lsb = false, d = 0, l = 0;
436 (cc = utf7unb64[(unsigned char)*psz]) != 0xff; psz++)
437 {
438 d <<= 6;
439 d += cc;
440 for (l += 6; l >= 8; lsb = !lsb)
441 {
442 c = (unsigned char)((d >> (l -= 8)) % 256);
443 if (lsb)
444 {
445 if (buf)
446 *buf++ |= c;
447 len ++;
448 }
449 else
450 if (buf)
451 *buf = (wchar_t)(c << 8);
452 }
453 }
454 if (*psz == '-')
455 psz++;
456 }
457 }
458 if (buf && (len < n))
459 *buf = 0;
460 return len;
461}
462
463//
464// BASE64 encoding table
465//
466static const unsigned char utf7enb64[] =
467{
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', '+', '/'
476};
477
478//
479// UTF-7 encoding table
480//
481// 0 - Set D (directly encoded characters)
482// 1 - Set O (optional direct characters)
483// 2 - whitespace characters (optional)
484// 3 - special characters
485//
486static const unsigned char utf7encode[128] =
487{
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
496};
497
498size_t wxMBConvUTF7::WC2MB(char *buf, const wchar_t *psz, size_t n) const
499{
500
501
502 size_t len = 0;
503
504 while (*psz && ((!buf) || (len < n)))
505 {
506 wchar_t cc = *psz++;
507 if (cc < 0x80 && utf7encode[cc] < 1)
508 {
509 // plain ASCII char
510 if (buf)
511 *buf++ = (char)cc;
512 len++;
513 }
514#ifndef WC_UTF16
515 else if (((wxUint32)cc) > 0xffff)
516 {
517 // no surrogate pair generation (yet?)
518 return (size_t)-1;
519 }
520#endif
521 else
522 {
523 if (buf)
524 *buf++ = '+';
525 len++;
526 if (cc != '+')
527 {
528 // BASE64 encode string
529 unsigned int lsb, d, l;
530 for (d = 0, l = 0; /*nothing*/; psz++)
531 {
532 for (lsb = 0; lsb < 2; lsb ++)
533 {
534 d <<= 8;
535 d += lsb ? cc & 0xff : (cc & 0xff00) >> 8;
536
537 for (l += 8; l >= 6; )
538 {
539 l -= 6;
540 if (buf)
541 *buf++ = utf7enb64[(d >> l) % 64];
542 len++;
543 }
544 }
545 cc = *psz;
546 if (!(cc) || (cc < 0x80 && utf7encode[cc] < 1))
547 break;
548 }
549 if (l != 0)
550 {
551 if (buf)
552 *buf++ = utf7enb64[((d % 16) << (6 - l)) % 64];
553 len++;
554 }
555 }
556 if (buf)
557 *buf++ = '-';
558 len++;
559 }
560 }
561 if (buf && (len < n))
562 *buf = 0;
563 return len;
564}
565
566// ----------------------------------------------------------------------------
567// UTF-8
568// ----------------------------------------------------------------------------
569
570static wxUint32 utf8_max[]=
571 { 0x7f, 0x7ff, 0xffff, 0x1fffff, 0x3ffffff, 0x7fffffff, 0xffffffff };
572
573// boundaries of the private use area we use to (temporarily) remap invalid
574// characters invalid in a UTF-8 encoded string
575const wxUint32 wxUnicodePUA = 0x100000;
576const wxUint32 wxUnicodePUAEnd = wxUnicodePUA + 256;
577
578size_t wxMBConvUTF8::MB2WC(wchar_t *buf, const char *psz, size_t n) const
579{
580 size_t len = 0;
581
582 while (*psz && ((!buf) || (len < n)))
583 {
584 const char *opsz = psz;
585 bool invalid = false;
586 unsigned char cc = *psz++, fc = cc;
587 unsigned cnt;
588 for (cnt = 0; fc & 0x80; cnt++)
589 fc <<= 1;
590 if (!cnt)
591 {
592 // plain ASCII char
593 if (buf)
594 *buf++ = cc;
595 len++;
596
597 // escape the escape character for octal escapes
598 if ((m_options & MAP_INVALID_UTF8_TO_OCTAL)
599 && cc == '\\' && (!buf || len < n))
600 {
601 if (buf)
602 *buf++ = cc;
603 len++;
604 }
605 }
606 else
607 {
608 cnt--;
609 if (!cnt)
610 {
611 // invalid UTF-8 sequence
612 invalid = true;
613 }
614 else
615 {
616 unsigned ocnt = cnt - 1;
617 wxUint32 res = cc & (0x3f >> cnt);
618 while (cnt--)
619 {
620 cc = *psz;
621 if ((cc & 0xC0) != 0x80)
622 {
623 // invalid UTF-8 sequence
624 invalid = true;
625 break;
626 }
627 psz++;
628 res = (res << 6) | (cc & 0x3f);
629 }
630 if (invalid || res <= utf8_max[ocnt])
631 {
632 // illegal UTF-8 encoding
633 invalid = true;
634 }
635 else if ((m_options & MAP_INVALID_UTF8_TO_PUA) &&
636 res >= wxUnicodePUA && res < wxUnicodePUAEnd)
637 {
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)
641 invalid = true;
642 }
643 else
644 {
645#ifdef WC_UTF16
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)
649 {
650 invalid = true;
651 }
652 else
653 {
654 if (buf)
655 buf += pa;
656 len += pa;
657 }
658#else // !WC_UTF16
659 if (buf)
660 *buf++ = (wchar_t)res;
661 len++;
662#endif // WC_UTF16/!WC_UTF16
663 }
664 }
665 if (invalid)
666 {
667 if (m_options & MAP_INVALID_UTF8_TO_PUA)
668 {
669 while (opsz < psz && (!buf || len < n))
670 {
671#ifdef WC_UTF16
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);
675 if (buf)
676 buf += pa;
677 opsz++;
678 len += pa;
679#else
680 if (buf)
681 *buf++ = (wchar_t)(wxUnicodePUA + (unsigned char)*opsz);
682 opsz++;
683 len++;
684#endif
685 }
686 }
687 else if (m_options & MAP_INVALID_UTF8_TO_OCTAL)
688 {
689 while (opsz < psz && (!buf || len < n))
690 {
691 if ( buf && len + 3 < n )
692 {
693 unsigned char on = *opsz;
694 *buf++ = L'\\';
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 );
698 }
699 opsz++;
700 len += 4;
701 }
702 }
703 else // MAP_INVALID_UTF8_NOT
704 {
705 return (size_t)-1;
706 }
707 }
708 }
709 }
710 if (buf && (len < n))
711 *buf = 0;
712 return len;
713}
714
715static inline bool isoctal(wchar_t wch)
716{
717 return L'0' <= wch && wch <= L'7';
718}
719
720size_t wxMBConvUTF8::WC2MB(char *buf, const wchar_t *psz, size_t n) const
721{
722 size_t len = 0;
723
724 while (*psz && ((!buf) || (len < n)))
725 {
726 wxUint32 cc;
727#ifdef WC_UTF16
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;
731#else
732 cc=(*psz++) & 0x7fffffff;
733#endif
734
735 if ( (m_options & MAP_INVALID_UTF8_TO_PUA)
736 && cc >= wxUnicodePUA && cc < wxUnicodePUAEnd )
737 {
738 if (buf)
739 *buf++ = (char)(cc - wxUnicodePUA);
740 len++;
741 }
742 else if ( (m_options & MAP_INVALID_UTF8_TO_OCTAL)
743 && cc == L'\\' && psz[0] == L'\\' )
744 {
745 if (buf)
746 *buf++ = (char)cc;
747 psz++;
748 len++;
749 }
750 else if ( (m_options & MAP_INVALID_UTF8_TO_OCTAL) &&
751 cc == L'\\' &&
752 isoctal(psz[0]) && isoctal(psz[1]) && isoctal(psz[2]) )
753 {
754 if (buf)
755 {
756 *buf++ = (char) ((psz[0] - L'0')*0100 +
757 (psz[1] - L'0')*010 +
758 (psz[2] - L'0'));
759 }
760
761 psz += 3;
762 len++;
763 }
764 else
765 {
766 unsigned cnt;
767 for (cnt = 0; cc > utf8_max[cnt]; cnt++) {}
768 if (!cnt)
769 {
770 // plain ASCII char
771 if (buf)
772 *buf++ = (char) cc;
773 len++;
774 }
775
776 else
777 {
778 len += cnt + 1;
779 if (buf)
780 {
781 *buf++ = (char) ((-128 >> cnt) | ((cc >> (cnt * 6)) & (0x3f >> cnt)));
782 while (cnt--)
783 *buf++ = (char) (0x80 | ((cc >> (cnt * 6)) & 0x3f));
784 }
785 }
786 }
787 }
788
789 if (buf && (len<n))
790 *buf = 0;
791
792 return len;
793}
794
795// ----------------------------------------------------------------------------
796// UTF-16
797// ----------------------------------------------------------------------------
798
799#ifdef WORDS_BIGENDIAN
800 #define wxMBConvUTF16straight wxMBConvUTF16BE
801 #define wxMBConvUTF16swap wxMBConvUTF16LE
802#else
803 #define wxMBConvUTF16swap wxMBConvUTF16BE
804 #define wxMBConvUTF16straight wxMBConvUTF16LE
805#endif
806
807
808#ifdef WC_UTF16
809
810// copy 16bit MB to 16bit String
811size_t wxMBConvUTF16straight::MB2WC(wchar_t *buf, const char *psz, size_t n) const
812{
813 size_t len=0;
814
815 while (*(wxUint16*)psz && (!buf || len < n))
816 {
817 if (buf)
818 *buf++ = *(wxUint16*)psz;
819 len++;
820
821 psz += sizeof(wxUint16);
822 }
823 if (buf && len<n) *buf=0;
824
825 return len;
826}
827
828
829// copy 16bit String to 16bit MB
830size_t wxMBConvUTF16straight::WC2MB(char *buf, const wchar_t *psz, size_t n) const
831{
832 size_t len=0;
833
834 while (*psz && (!buf || len < n))
835 {
836 if (buf)
837 {
838 *(wxUint16*)buf = *psz;
839 buf += sizeof(wxUint16);
840 }
841 len += sizeof(wxUint16);
842 psz++;
843 }
844 if (buf && len<=n-sizeof(wxUint16)) *(wxUint16*)buf=0;
845
846 return len;
847}
848
849
850// swap 16bit MB to 16bit String
851size_t wxMBConvUTF16swap::MB2WC(wchar_t *buf, const char *psz, size_t n) const
852{
853 size_t len=0;
854
855 while (*(wxUint16*)psz && (!buf || len < n))
856 {
857 if (buf)
858 {
859 ((char *)buf)[0] = psz[1];
860 ((char *)buf)[1] = psz[0];
861 buf++;
862 }
863 len++;
864 psz += sizeof(wxUint16);
865 }
866 if (buf && len<n) *buf=0;
867
868 return len;
869}
870
871
872// swap 16bit MB to 16bit String
873size_t wxMBConvUTF16swap::WC2MB(char *buf, const wchar_t *psz, size_t n) const
874{
875 size_t len=0;
876
877 while (*psz && (!buf || len < n))
878 {
879 if (buf)
880 {
881 *buf++ = ((char*)psz)[1];
882 *buf++ = ((char*)psz)[0];
883 }
884 len += sizeof(wxUint16);
885 psz++;
886 }
887 if (buf && len<=n-sizeof(wxUint16)) *(wxUint16*)buf=0;
888
889 return len;
890}
891
892
893#else // WC_UTF16
894
895
896// copy 16bit MB to 32bit String
897size_t wxMBConvUTF16straight::MB2WC(wchar_t *buf, const char *psz, size_t n) const
898{
899 size_t len=0;
900
901 while (*(wxUint16*)psz && (!buf || len < n))
902 {
903 wxUint32 cc;
904 size_t pa=decode_utf16((wxUint16*)psz, cc);
905 if (pa == (size_t)-1)
906 return pa;
907
908 if (buf)
909 *buf++ = (wchar_t)cc;
910 len++;
911 psz += pa * sizeof(wxUint16);
912 }
913 if (buf && len<n) *buf=0;
914
915 return len;
916}
917
918
919// copy 32bit String to 16bit MB
920size_t wxMBConvUTF16straight::WC2MB(char *buf, const wchar_t *psz, size_t n) const
921{
922 size_t len=0;
923
924 while (*psz && (!buf || len < n))
925 {
926 wxUint16 cc[2];
927 size_t pa=encode_utf16(*psz, cc);
928
929 if (pa == (size_t)-1)
930 return pa;
931
932 if (buf)
933 {
934 *(wxUint16*)buf = cc[0];
935 buf += sizeof(wxUint16);
936 if (pa > 1)
937 {
938 *(wxUint16*)buf = cc[1];
939 buf += sizeof(wxUint16);
940 }
941 }
942
943 len += pa*sizeof(wxUint16);
944 psz++;
945 }
946 if (buf && len<=n-sizeof(wxUint16)) *(wxUint16*)buf=0;
947
948 return len;
949}
950
951
952// swap 16bit MB to 32bit String
953size_t wxMBConvUTF16swap::MB2WC(wchar_t *buf, const char *psz, size_t n) const
954{
955 size_t len=0;
956
957 while (*(wxUint16*)psz && (!buf || len < n))
958 {
959 wxUint32 cc;
960 char tmp[4];
961 tmp[0]=psz[1]; tmp[1]=psz[0];
962 tmp[2]=psz[3]; tmp[3]=psz[2];
963
964 size_t pa=decode_utf16((wxUint16*)tmp, cc);
965 if (pa == (size_t)-1)
966 return pa;
967
968 if (buf)
969 *buf++ = (wchar_t)cc;
970
971 len++;
972 psz += pa * sizeof(wxUint16);
973 }
974 if (buf && len<n) *buf=0;
975
976 return len;
977}
978
979
980// swap 32bit String to 16bit MB
981size_t wxMBConvUTF16swap::WC2MB(char *buf, const wchar_t *psz, size_t n) const
982{
983 size_t len=0;
984
985 while (*psz && (!buf || len < n))
986 {
987 wxUint16 cc[2];
988 size_t pa=encode_utf16(*psz, cc);
989
990 if (pa == (size_t)-1)
991 return pa;
992
993 if (buf)
994 {
995 *buf++ = ((char*)cc)[1];
996 *buf++ = ((char*)cc)[0];
997 if (pa > 1)
998 {
999 *buf++ = ((char*)cc)[3];
1000 *buf++ = ((char*)cc)[2];
1001 }
1002 }
1003
1004 len += pa*sizeof(wxUint16);
1005 psz++;
1006 }
1007 if (buf && len<=n-sizeof(wxUint16)) *(wxUint16*)buf=0;
1008
1009 return len;
1010}
1011
1012#endif // WC_UTF16
1013
1014
1015// ----------------------------------------------------------------------------
1016// UTF-32
1017// ----------------------------------------------------------------------------
1018
1019#ifdef WORDS_BIGENDIAN
1020#define wxMBConvUTF32straight wxMBConvUTF32BE
1021#define wxMBConvUTF32swap wxMBConvUTF32LE
1022#else
1023#define wxMBConvUTF32swap wxMBConvUTF32BE
1024#define wxMBConvUTF32straight wxMBConvUTF32LE
1025#endif
1026
1027
1028WXDLLIMPEXP_DATA_BASE(wxMBConvUTF32LE) wxConvUTF32LE;
1029WXDLLIMPEXP_DATA_BASE(wxMBConvUTF32BE) wxConvUTF32BE;
1030
1031
1032#ifdef WC_UTF16
1033
1034// copy 32bit MB to 16bit String
1035size_t wxMBConvUTF32straight::MB2WC(wchar_t *buf, const char *psz, size_t n) const
1036{
1037 size_t len=0;
1038
1039 while (*(wxUint32*)psz && (!buf || len < n))
1040 {
1041 wxUint16 cc[2];
1042
1043 size_t pa=encode_utf16(*(wxUint32*)psz, cc);
1044 if (pa == (size_t)-1)
1045 return pa;
1046
1047 if (buf)
1048 {
1049 *buf++ = cc[0];
1050 if (pa > 1)
1051 *buf++ = cc[1];
1052 }
1053 len += pa;
1054 psz += sizeof(wxUint32);
1055 }
1056 if (buf && len<n) *buf=0;
1057
1058 return len;
1059}
1060
1061
1062// copy 16bit String to 32bit MB
1063size_t wxMBConvUTF32straight::WC2MB(char *buf, const wchar_t *psz, size_t n) const
1064{
1065 size_t len=0;
1066
1067 while (*psz && (!buf || len < n))
1068 {
1069 wxUint32 cc;
1070
1071 // cast is ok for WC_UTF16
1072 size_t pa = decode_utf16((const wxUint16 *)psz, cc);
1073 if (pa == (size_t)-1)
1074 return pa;
1075
1076 if (buf)
1077 {
1078 *(wxUint32*)buf = cc;
1079 buf += sizeof(wxUint32);
1080 }
1081 len += sizeof(wxUint32);
1082 psz += pa;
1083 }
1084
1085 if (buf && len<=n-sizeof(wxUint32))
1086 *(wxUint32*)buf=0;
1087
1088 return len;
1089}
1090
1091
1092
1093// swap 32bit MB to 16bit String
1094size_t wxMBConvUTF32swap::MB2WC(wchar_t *buf, const char *psz, size_t n) const
1095{
1096 size_t len=0;
1097
1098 while (*(wxUint32*)psz && (!buf || len < n))
1099 {
1100 char tmp[4];
1101 tmp[0] = psz[3]; tmp[1] = psz[2];
1102 tmp[2] = psz[1]; tmp[3] = psz[0];
1103
1104
1105 wxUint16 cc[2];
1106
1107 size_t pa=encode_utf16(*(wxUint32*)tmp, cc);
1108 if (pa == (size_t)-1)
1109 return pa;
1110
1111 if (buf)
1112 {
1113 *buf++ = cc[0];
1114 if (pa > 1)
1115 *buf++ = cc[1];
1116 }
1117 len += pa;
1118 psz += sizeof(wxUint32);
1119 }
1120
1121 if (buf && len<n)
1122 *buf=0;
1123
1124 return len;
1125}
1126
1127
1128// swap 16bit String to 32bit MB
1129size_t wxMBConvUTF32swap::WC2MB(char *buf, const wchar_t *psz, size_t n) const
1130{
1131 size_t len=0;
1132
1133 while (*psz && (!buf || len < n))
1134 {
1135 char cc[4];
1136
1137 // cast is ok for WC_UTF16
1138 size_t pa=decode_utf16((const wxUint16 *)psz, *(wxUint32*)cc);
1139 if (pa == (size_t)-1)
1140 return pa;
1141
1142 if (buf)
1143 {
1144 *buf++ = cc[3];
1145 *buf++ = cc[2];
1146 *buf++ = cc[1];
1147 *buf++ = cc[0];
1148 }
1149 len += sizeof(wxUint32);
1150 psz += pa;
1151 }
1152
1153 if (buf && len<=n-sizeof(wxUint32))
1154 *(wxUint32*)buf=0;
1155
1156 return len;
1157}
1158
1159#else // WC_UTF16
1160
1161
1162// copy 32bit MB to 32bit String
1163size_t wxMBConvUTF32straight::MB2WC(wchar_t *buf, const char *psz, size_t n) const
1164{
1165 size_t len=0;
1166
1167 while (*(wxUint32*)psz && (!buf || len < n))
1168 {
1169 if (buf)
1170 *buf++ = (wchar_t)(*(wxUint32*)psz);
1171 len++;
1172 psz += sizeof(wxUint32);
1173 }
1174
1175 if (buf && len<n)
1176 *buf=0;
1177
1178 return len;
1179}
1180
1181
1182// copy 32bit String to 32bit MB
1183size_t wxMBConvUTF32straight::WC2MB(char *buf, const wchar_t *psz, size_t n) const
1184{
1185 size_t len=0;
1186
1187 while (*psz && (!buf || len < n))
1188 {
1189 if (buf)
1190 {
1191 *(wxUint32*)buf = *psz;
1192 buf += sizeof(wxUint32);
1193 }
1194
1195 len += sizeof(wxUint32);
1196 psz++;
1197 }
1198
1199 if (buf && len<=n-sizeof(wxUint32))
1200 *(wxUint32*)buf=0;
1201
1202 return len;
1203}
1204
1205
1206// swap 32bit MB to 32bit String
1207size_t wxMBConvUTF32swap::MB2WC(wchar_t *buf, const char *psz, size_t n) const
1208{
1209 size_t len=0;
1210
1211 while (*(wxUint32*)psz && (!buf || len < n))
1212 {
1213 if (buf)
1214 {
1215 ((char *)buf)[0] = psz[3];
1216 ((char *)buf)[1] = psz[2];
1217 ((char *)buf)[2] = psz[1];
1218 ((char *)buf)[3] = psz[0];
1219 buf++;
1220 }
1221 len++;
1222 psz += sizeof(wxUint32);
1223 }
1224
1225 if (buf && len<n)
1226 *buf=0;
1227
1228 return len;
1229}
1230
1231
1232// swap 32bit String to 32bit MB
1233size_t wxMBConvUTF32swap::WC2MB(char *buf, const wchar_t *psz, size_t n) const
1234{
1235 size_t len=0;
1236
1237 while (*psz && (!buf || len < n))
1238 {
1239 if (buf)
1240 {
1241 *buf++ = ((char *)psz)[3];
1242 *buf++ = ((char *)psz)[2];
1243 *buf++ = ((char *)psz)[1];
1244 *buf++ = ((char *)psz)[0];
1245 }
1246 len += sizeof(wxUint32);
1247 psz++;
1248 }
1249
1250 if (buf && len<=n-sizeof(wxUint32))
1251 *(wxUint32*)buf=0;
1252
1253 return len;
1254}
1255
1256
1257#endif // WC_UTF16
1258
1259
1260// ============================================================================
1261// The classes doing conversion using the iconv_xxx() functions
1262// ============================================================================
1263
1264#ifdef HAVE_ICONV
1265
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
1272// iconv() failure.
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))
1277#else
1278#define ICONV_FAILED(cres, bufLeft) (cres == (size_t)-1)
1279#endif
1280
1281#define ICONV_CHAR_CAST(x) ((ICONV_CONST char **)(x))
1282
1283#define ICONV_T_INVALID ((iconv_t)-1)
1284
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"
1294#endif
1295
1296// ----------------------------------------------------------------------------
1297// wxMBConv_iconv: encapsulates an iconv character set
1298// ----------------------------------------------------------------------------
1299
1300class wxMBConv_iconv : public wxMBConv
1301{
1302public:
1303 wxMBConv_iconv(const wxChar *name);
1304 virtual ~wxMBConv_iconv();
1305
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;
1308
1309 bool IsOk() const
1310 { return (m2w != ICONV_T_INVALID) && (w2m != ICONV_T_INVALID); }
1311
1312protected:
1313 // the iconv handlers used to translate from multibyte to wide char and in
1314 // the other direction
1315 iconv_t m2w,
1316 w2m;
1317#if wxUSE_THREADS
1318 // guards access to m2w and w2m objects
1319 wxMutex m_iconvMutex;
1320#endif
1321
1322private:
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;
1326
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;
1330};
1331
1332// make the constructor available for unit testing
1333WXDLLIMPEXP_BASE wxMBConv* new_wxMBConv_iconv( const wxChar* name )
1334{
1335 wxMBConv_iconv* result = new wxMBConv_iconv( name );
1336 if ( !result->IsOk() )
1337 {
1338 delete result;
1339 return 0;
1340 }
1341 return result;
1342}
1343
1344wxString wxMBConv_iconv::ms_wcCharsetName;
1345bool wxMBConv_iconv::ms_wcNeedsSwap = false;
1346
1347wxMBConv_iconv::wxMBConv_iconv(const wxChar *name)
1348{
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());
1352
1353 // check for charset that represents wchar_t:
1354 if ( ms_wcCharsetName.empty() )
1355 {
1356 wxLogTrace(TRACE_STRCONV, _T("Looking for wide char codeset:"));
1357
1358#if wxUSE_FONTMAP
1359 const wxChar **names = wxFontMapperBase::GetAllEncodingNames(WC_ENC);
1360#else // !wxUSE_FONTMAP
1361 static const wxChar *names[] =
1362 {
1363#if SIZEOF_WCHAR_T == 4
1364 _T("UCS-4"),
1365#elif SIZEOF_WCHAR_T = 2
1366 _T("UCS-2"),
1367#endif
1368 NULL
1369 };
1370#endif // wxUSE_FONTMAP/!wxUSE_FONTMAP
1371
1372 for ( ; *names && ms_wcCharsetName.empty(); ++names )
1373 {
1374 const wxString nameCS(*names);
1375
1376 // first try charset with explicit bytesex info (e.g. "UCS-4LE"):
1377 wxString nameXE(nameCS);
1378 #ifdef WORDS_BIGENDIAN
1379 nameXE += _T("BE");
1380 #else // little endian
1381 nameXE += _T("LE");
1382 #endif
1383
1384 wxLogTrace(TRACE_STRCONV, _T(" trying charset \"%s\""),
1385 nameXE.c_str());
1386
1387 m2w = iconv_open(nameXE.ToAscii(), cname);
1388 if ( m2w == ICONV_T_INVALID )
1389 {
1390 // try charset w/o bytesex info (e.g. "UCS4")
1391 wxLogTrace(TRACE_STRCONV, _T(" trying charset \"%s\""),
1392 nameCS.c_str());
1393 m2w = iconv_open(nameCS.ToAscii(), cname);
1394
1395 // and check for bytesex ourselves:
1396 if ( m2w != ICONV_T_INVALID )
1397 {
1398 char buf[2], *bufPtr;
1399 wchar_t wbuf[2], *wbufPtr;
1400 size_t insz, outsz;
1401 size_t res;
1402
1403 buf[0] = 'A';
1404 buf[1] = 0;
1405 wbuf[0] = 0;
1406 insz = 2;
1407 outsz = SIZEOF_WCHAR_T * 2;
1408 wbufPtr = wbuf;
1409 bufPtr = buf;
1410
1411 res = iconv(m2w, ICONV_CHAR_CAST(&bufPtr), &insz,
1412 (char**)&wbufPtr, &outsz);
1413
1414 if (ICONV_FAILED(res, insz))
1415 {
1416 wxLogLastError(wxT("iconv"));
1417 wxLogError(_("Conversion to charset '%s' doesn't work."),
1418 nameCS.c_str());
1419 }
1420 else // ok, can convert to this encoding, remember it
1421 {
1422 ms_wcCharsetName = nameCS;
1423 ms_wcNeedsSwap = wbuf[0] != (wchar_t)buf[0];
1424 }
1425 }
1426 }
1427 else // use charset not requiring byte swapping
1428 {
1429 ms_wcCharsetName = nameXE;
1430 }
1431 }
1432
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)")
1438 : _T(""));
1439 }
1440 else // we already have ms_wcCharsetName
1441 {
1442 m2w = iconv_open(ms_wcCharsetName.ToAscii(), cname);
1443 }
1444
1445 if ( ms_wcCharsetName.empty() )
1446 {
1447 w2m = ICONV_T_INVALID;
1448 }
1449 else
1450 {
1451 w2m = iconv_open(cname, ms_wcCharsetName.ToAscii());
1452 if ( w2m == ICONV_T_INVALID )
1453 {
1454 wxLogTrace(TRACE_STRCONV,
1455 wxT("\"%s\" -> \"%s\" works but not the converse!?"),
1456 ms_wcCharsetName.c_str(), cname.data());
1457 }
1458 }
1459}
1460
1461wxMBConv_iconv::~wxMBConv_iconv()
1462{
1463 if ( m2w != ICONV_T_INVALID )
1464 iconv_close(m2w);
1465 if ( w2m != ICONV_T_INVALID )
1466 iconv_close(w2m);
1467}
1468
1469size_t wxMBConv_iconv::MB2WC(wchar_t *buf, const char *psz, size_t n) const
1470{
1471#if wxUSE_THREADS
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);
1479#endif
1480
1481 size_t inbuf = strlen(psz);
1482 size_t outbuf = n * SIZEOF_WCHAR_T;
1483 size_t res, cres;
1484 // VS: Use these instead of psz, buf because iconv() modifies its arguments:
1485 wchar_t *bufPtr = buf;
1486 const char *pszPtr = psz;
1487
1488 if (buf)
1489 {
1490 // have destination buffer, convert there
1491 cres = iconv(m2w,
1492 ICONV_CHAR_CAST(&pszPtr), &inbuf,
1493 (char**)&bufPtr, &outbuf);
1494 res = n - (outbuf / SIZEOF_WCHAR_T);
1495
1496 if (ms_wcNeedsSwap)
1497 {
1498 // convert to native endianness
1499 for ( unsigned i = 0; i < res; i++ )
1500 buf[n] = WC_BSWAP(buf[i]);
1501 }
1502
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.
1506 if (res < n)
1507 buf[res] = 0;
1508 }
1509 else
1510 {
1511 // no destination buffer... convert using temp buffer
1512 // to calculate destination buffer requirement
1513 wchar_t tbuf[8];
1514 res = 0;
1515 do {
1516 bufPtr = tbuf;
1517 outbuf = 8*SIZEOF_WCHAR_T;
1518
1519 cres = iconv(m2w,
1520 ICONV_CHAR_CAST(&pszPtr), &inbuf,
1521 (char**)&bufPtr, &outbuf );
1522
1523 res += 8-(outbuf/SIZEOF_WCHAR_T);
1524 } while ((cres==(size_t)-1) && (errno==E2BIG));
1525 }
1526
1527 if (ICONV_FAILED(cres, inbuf))
1528 {
1529 //VS: it is ok if iconv fails, hence trace only
1530 wxLogTrace(TRACE_STRCONV, wxT("iconv failed: %s"), wxSysErrorMsg(wxSysErrorCode()));
1531 return (size_t)-1;
1532 }
1533
1534 return res;
1535}
1536
1537size_t wxMBConv_iconv::WC2MB(char *buf, const wchar_t *psz, size_t n) const
1538{
1539#if wxUSE_THREADS
1540 // NB: explained in MB2WC
1541 wxMutexLocker lock(wxConstCast(this, wxMBConv_iconv)->m_iconvMutex);
1542#endif
1543
1544 size_t inlen = wxWcslen(psz);
1545 size_t inbuf = inlen * SIZEOF_WCHAR_T;
1546 size_t outbuf = n;
1547 size_t res, cres;
1548
1549 wchar_t *tmpbuf = 0;
1550
1551 if (ms_wcNeedsSwap)
1552 {
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';
1560 psz = tmpbuf;
1561 }
1562
1563 if (buf)
1564 {
1565 // have destination buffer, convert there
1566 cres = iconv( w2m, ICONV_CHAR_CAST(&psz), &inbuf, &buf, &outbuf );
1567
1568 res = n-outbuf;
1569
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.
1573 if (res < n)
1574 buf[0] = 0;
1575 }
1576 else
1577 {
1578 // no destination buffer... convert using temp buffer
1579 // to calculate destination buffer requirement
1580 char tbuf[16];
1581 res = 0;
1582 do {
1583 buf = tbuf; outbuf = 16;
1584
1585 cres = iconv( w2m, ICONV_CHAR_CAST(&psz), &inbuf, &buf, &outbuf );
1586
1587 res += 16 - outbuf;
1588 } while ((cres==(size_t)-1) && (errno==E2BIG));
1589 }
1590
1591 if (ms_wcNeedsSwap)
1592 {
1593 free(tmpbuf);
1594 }
1595
1596 if (ICONV_FAILED(cres, inbuf))
1597 {
1598 wxLogTrace(TRACE_STRCONV, wxT("iconv failed: %s"), wxSysErrorMsg(wxSysErrorCode()));
1599 return (size_t)-1;
1600 }
1601
1602 return res;
1603}
1604
1605#endif // HAVE_ICONV
1606
1607
1608// ============================================================================
1609// Win32 conversion classes
1610// ============================================================================
1611
1612#ifdef wxHAVE_WIN32_MB2WC
1613
1614// from utils.cpp
1615#if wxUSE_FONTMAP
1616extern WXDLLIMPEXP_BASE long wxCharsetToCodepage(const wxChar *charset);
1617extern WXDLLIMPEXP_BASE long wxEncodingToCodepage(wxFontEncoding encoding);
1618#endif
1619
1620class wxMBConv_win32 : public wxMBConv
1621{
1622public:
1623 wxMBConv_win32()
1624 {
1625 m_CodePage = CP_ACP;
1626 }
1627
1628#if wxUSE_FONTMAP
1629 wxMBConv_win32(const wxChar* name)
1630 {
1631 m_CodePage = wxCharsetToCodepage(name);
1632 }
1633
1634 wxMBConv_win32(wxFontEncoding encoding)
1635 {
1636 m_CodePage = wxEncodingToCodepage(encoding);
1637 }
1638#endif
1639
1640 size_t MB2WC(wchar_t *buf, const char *psz, size_t n) const
1641 {
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
1646 // error
1647 //
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...
1655 //
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
1664 int flags = 0;
1665 if ( m_CodePage != CP_UTF7 && m_CodePage != CP_SYMBOL &&
1666 m_CodePage < 50000 &&
1667 IsAtLeastWin2kSP4() )
1668 {
1669 flags = MB_ERR_INVALID_CHARS;
1670 }
1671 else if ( m_CodePage == CP_UTF8 )
1672 {
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);
1676 }
1677
1678 const size_t len = ::MultiByteToWideChar
1679 (
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
1686 );
1687 if ( !len )
1688 {
1689 // function totally failed
1690 return (size_t)-1;
1691 }
1692
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 )
1696 {
1697 wxCharBuffer mbBuf(n);
1698 if ( ::WideCharToMultiByte
1699 (
1700 m_CodePage,
1701 0,
1702 buf,
1703 -1,
1704 mbBuf.data(),
1705 n,
1706 NULL,
1707 NULL
1708 ) == 0 ||
1709 strcmp(mbBuf, psz) != 0 )
1710 {
1711 // we didn't obtain the same thing we started from, hence
1712 // the conversion was lossy and we consider that it failed
1713 return (size_t)-1;
1714 }
1715 }
1716
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
1720 return len - 1;
1721 }
1722
1723 size_t WC2MB(char *buf, const wchar_t *pwz, size_t n) const
1724 {
1725 /*
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
1731
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.
1738 */
1739
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
1743 // supporting it
1744 BOOL usedDef wxDUMMY_INITIALIZE(false);
1745 BOOL *pUsedDef;
1746 int flags;
1747 if ( CanUseNoBestFit() && m_CodePage < 50000 )
1748 {
1749 // it's our lucky day
1750 flags = WC_NO_BEST_FIT_CHARS;
1751 pUsedDef = &usedDef;
1752 }
1753 else // old system or unsupported encoding
1754 {
1755 flags = 0;
1756 pUsedDef = NULL;
1757 }
1758
1759 const size_t len = ::WideCharToMultiByte
1760 (
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?
1769 );
1770
1771 if ( !len )
1772 {
1773 // function totally failed
1774 return (size_t)-1;
1775 }
1776
1777 // if we were really converting, check if we succeeded
1778 if ( buf )
1779 {
1780 if ( flags )
1781 {
1782 // check if the conversion failed, i.e. if any replacements
1783 // were done
1784 if ( usedDef )
1785 return (size_t)-1;
1786 }
1787 else // we must resort to double tripping...
1788 {
1789 wxWCharBuffer wcBuf(n);
1790 if ( MB2WC(wcBuf.data(), buf, n) == (size_t)-1 ||
1791 wcscmp(wcBuf, pwz) != 0 )
1792 {
1793 // we didn't obtain the same thing we started from, hence
1794 // the conversion was lossy and we consider that it failed
1795 return (size_t)-1;
1796 }
1797 }
1798 }
1799
1800 // see the comment above for the reason of "len - 1"
1801 return len - 1;
1802 }
1803
1804 bool IsOk() const { return m_CodePage != -1; }
1805
1806private:
1807 static bool CanUseNoBestFit()
1808 {
1809 static int s_isWin98Or2k = -1;
1810
1811 if ( s_isWin98Or2k == -1 )
1812 {
1813 int verMaj, verMin;
1814 switch ( wxGetOsVersion(&verMaj, &verMin) )
1815 {
1816 case wxWIN95:
1817 s_isWin98Or2k = verMaj >= 4 && verMin >= 10;
1818 break;
1819
1820 case wxWINDOWS_NT:
1821 s_isWin98Or2k = verMaj >= 5;
1822 break;
1823
1824 default:
1825 // unknown, be conseravtive by default
1826 s_isWin98Or2k = 0;
1827 }
1828
1829 wxASSERT_MSG( s_isWin98Or2k != -1, _T("should be set above") );
1830 }
1831
1832 return s_isWin98Or2k == 1;
1833 }
1834
1835 static bool IsAtLeastWin2kSP4()
1836 {
1837#ifdef __WXWINCE__
1838 return false;
1839#else
1840 static int s_isAtLeastWin2kSP4 = -1;
1841
1842 if ( s_isAtLeastWin2kSP4 == -1 )
1843 {
1844 OSVERSIONINFOEX ver;
1845
1846 memset(&ver, 0, sizeof(ver));
1847 ver.dwOSVersionInfoSize = sizeof(ver);
1848 GetVersionEx((OSVERSIONINFO*)&ver);
1849
1850 s_isAtLeastWin2kSP4 =
1851 ((ver.dwMajorVersion > 5) || // Vista+
1852 (ver.dwMajorVersion == 5 && ver.dwMinorVersion > 0) || // XP/2003
1853 (ver.dwMajorVersion == 5 && ver.dwMinorVersion == 0 &&
1854 ver.wServicePackMajor >= 4)) // 2000 SP4+
1855 ? 1 : 0;
1856 }
1857
1858 return s_isAtLeastWin2kSP4 == 1;
1859#endif
1860 }
1861
1862 long m_CodePage;
1863};
1864
1865#endif // wxHAVE_WIN32_MB2WC
1866
1867// ============================================================================
1868// Cocoa conversion classes
1869// ============================================================================
1870
1871#if defined(__WXCOCOA__)
1872
1873// RN: There is no UTF-32 support in either Core Foundation or
1874// Cocoa. Strangely enough, internally Core Foundation uses
1875// UTF 32 internally quite a bit - its just not public (yet).
1876
1877#include <CoreFoundation/CFString.h>
1878#include <CoreFoundation/CFStringEncodingExt.h>
1879
1880CFStringEncoding wxCFStringEncFromFontEnc(wxFontEncoding encoding)
1881{
1882 CFStringEncoding enc = kCFStringEncodingInvalidId ;
1883 if ( encoding == wxFONTENCODING_DEFAULT )
1884 {
1885 enc = CFStringGetSystemEncoding();
1886 }
1887 else switch( encoding)
1888 {
1889 case wxFONTENCODING_ISO8859_1 :
1890 enc = kCFStringEncodingISOLatin1 ;
1891 break ;
1892 case wxFONTENCODING_ISO8859_2 :
1893 enc = kCFStringEncodingISOLatin2;
1894 break ;
1895 case wxFONTENCODING_ISO8859_3 :
1896 enc = kCFStringEncodingISOLatin3 ;
1897 break ;
1898 case wxFONTENCODING_ISO8859_4 :
1899 enc = kCFStringEncodingISOLatin4;
1900 break ;
1901 case wxFONTENCODING_ISO8859_5 :
1902 enc = kCFStringEncodingISOLatinCyrillic;
1903 break ;
1904 case wxFONTENCODING_ISO8859_6 :
1905 enc = kCFStringEncodingISOLatinArabic;
1906 break ;
1907 case wxFONTENCODING_ISO8859_7 :
1908 enc = kCFStringEncodingISOLatinGreek;
1909 break ;
1910 case wxFONTENCODING_ISO8859_8 :
1911 enc = kCFStringEncodingISOLatinHebrew;
1912 break ;
1913 case wxFONTENCODING_ISO8859_9 :
1914 enc = kCFStringEncodingISOLatin5;
1915 break ;
1916 case wxFONTENCODING_ISO8859_10 :
1917 enc = kCFStringEncodingISOLatin6;
1918 break ;
1919 case wxFONTENCODING_ISO8859_11 :
1920 enc = kCFStringEncodingISOLatinThai;
1921 break ;
1922 case wxFONTENCODING_ISO8859_13 :
1923 enc = kCFStringEncodingISOLatin7;
1924 break ;
1925 case wxFONTENCODING_ISO8859_14 :
1926 enc = kCFStringEncodingISOLatin8;
1927 break ;
1928 case wxFONTENCODING_ISO8859_15 :
1929 enc = kCFStringEncodingISOLatin9;
1930 break ;
1931
1932 case wxFONTENCODING_KOI8 :
1933 enc = kCFStringEncodingKOI8_R;
1934 break ;
1935 case wxFONTENCODING_ALTERNATIVE : // MS-DOS CP866
1936 enc = kCFStringEncodingDOSRussian;
1937 break ;
1938
1939// case wxFONTENCODING_BULGARIAN :
1940// enc = ;
1941// break ;
1942
1943 case wxFONTENCODING_CP437 :
1944 enc =kCFStringEncodingDOSLatinUS ;
1945 break ;
1946 case wxFONTENCODING_CP850 :
1947 enc = kCFStringEncodingDOSLatin1;
1948 break ;
1949 case wxFONTENCODING_CP852 :
1950 enc = kCFStringEncodingDOSLatin2;
1951 break ;
1952 case wxFONTENCODING_CP855 :
1953 enc = kCFStringEncodingDOSCyrillic;
1954 break ;
1955 case wxFONTENCODING_CP866 :
1956 enc =kCFStringEncodingDOSRussian ;
1957 break ;
1958 case wxFONTENCODING_CP874 :
1959 enc = kCFStringEncodingDOSThai;
1960 break ;
1961 case wxFONTENCODING_CP932 :
1962 enc = kCFStringEncodingDOSJapanese;
1963 break ;
1964 case wxFONTENCODING_CP936 :
1965 enc =kCFStringEncodingDOSChineseSimplif ;
1966 break ;
1967 case wxFONTENCODING_CP949 :
1968 enc = kCFStringEncodingDOSKorean;
1969 break ;
1970 case wxFONTENCODING_CP950 :
1971 enc = kCFStringEncodingDOSChineseTrad;
1972 break ;
1973 case wxFONTENCODING_CP1250 :
1974 enc = kCFStringEncodingWindowsLatin2;
1975 break ;
1976 case wxFONTENCODING_CP1251 :
1977 enc =kCFStringEncodingWindowsCyrillic ;
1978 break ;
1979 case wxFONTENCODING_CP1252 :
1980 enc =kCFStringEncodingWindowsLatin1 ;
1981 break ;
1982 case wxFONTENCODING_CP1253 :
1983 enc = kCFStringEncodingWindowsGreek;
1984 break ;
1985 case wxFONTENCODING_CP1254 :
1986 enc = kCFStringEncodingWindowsLatin5;
1987 break ;
1988 case wxFONTENCODING_CP1255 :
1989 enc =kCFStringEncodingWindowsHebrew ;
1990 break ;
1991 case wxFONTENCODING_CP1256 :
1992 enc =kCFStringEncodingWindowsArabic ;
1993 break ;
1994 case wxFONTENCODING_CP1257 :
1995 enc = kCFStringEncodingWindowsBalticRim;
1996 break ;
1997// This only really encodes to UTF7 (if that) evidently
1998// case wxFONTENCODING_UTF7 :
1999// enc = kCFStringEncodingNonLossyASCII ;
2000// break ;
2001 case wxFONTENCODING_UTF8 :
2002 enc = kCFStringEncodingUTF8 ;
2003 break ;
2004 case wxFONTENCODING_EUC_JP :
2005 enc = kCFStringEncodingEUC_JP;
2006 break ;
2007 case wxFONTENCODING_UTF16 :
2008 enc = kCFStringEncodingUnicode ;
2009 break ;
2010 case wxFONTENCODING_MACROMAN :
2011 enc = kCFStringEncodingMacRoman ;
2012 break ;
2013 case wxFONTENCODING_MACJAPANESE :
2014 enc = kCFStringEncodingMacJapanese ;
2015 break ;
2016 case wxFONTENCODING_MACCHINESETRAD :
2017 enc = kCFStringEncodingMacChineseTrad ;
2018 break ;
2019 case wxFONTENCODING_MACKOREAN :
2020 enc = kCFStringEncodingMacKorean ;
2021 break ;
2022 case wxFONTENCODING_MACARABIC :
2023 enc = kCFStringEncodingMacArabic ;
2024 break ;
2025 case wxFONTENCODING_MACHEBREW :
2026 enc = kCFStringEncodingMacHebrew ;
2027 break ;
2028 case wxFONTENCODING_MACGREEK :
2029 enc = kCFStringEncodingMacGreek ;
2030 break ;
2031 case wxFONTENCODING_MACCYRILLIC :
2032 enc = kCFStringEncodingMacCyrillic ;
2033 break ;
2034 case wxFONTENCODING_MACDEVANAGARI :
2035 enc = kCFStringEncodingMacDevanagari ;
2036 break ;
2037 case wxFONTENCODING_MACGURMUKHI :
2038 enc = kCFStringEncodingMacGurmukhi ;
2039 break ;
2040 case wxFONTENCODING_MACGUJARATI :
2041 enc = kCFStringEncodingMacGujarati ;
2042 break ;
2043 case wxFONTENCODING_MACORIYA :
2044 enc = kCFStringEncodingMacOriya ;
2045 break ;
2046 case wxFONTENCODING_MACBENGALI :
2047 enc = kCFStringEncodingMacBengali ;
2048 break ;
2049 case wxFONTENCODING_MACTAMIL :
2050 enc = kCFStringEncodingMacTamil ;
2051 break ;
2052 case wxFONTENCODING_MACTELUGU :
2053 enc = kCFStringEncodingMacTelugu ;
2054 break ;
2055 case wxFONTENCODING_MACKANNADA :
2056 enc = kCFStringEncodingMacKannada ;
2057 break ;
2058 case wxFONTENCODING_MACMALAJALAM :
2059 enc = kCFStringEncodingMacMalayalam ;
2060 break ;
2061 case wxFONTENCODING_MACSINHALESE :
2062 enc = kCFStringEncodingMacSinhalese ;
2063 break ;
2064 case wxFONTENCODING_MACBURMESE :
2065 enc = kCFStringEncodingMacBurmese ;
2066 break ;
2067 case wxFONTENCODING_MACKHMER :
2068 enc = kCFStringEncodingMacKhmer ;
2069 break ;
2070 case wxFONTENCODING_MACTHAI :
2071 enc = kCFStringEncodingMacThai ;
2072 break ;
2073 case wxFONTENCODING_MACLAOTIAN :
2074 enc = kCFStringEncodingMacLaotian ;
2075 break ;
2076 case wxFONTENCODING_MACGEORGIAN :
2077 enc = kCFStringEncodingMacGeorgian ;
2078 break ;
2079 case wxFONTENCODING_MACARMENIAN :
2080 enc = kCFStringEncodingMacArmenian ;
2081 break ;
2082 case wxFONTENCODING_MACCHINESESIMP :
2083 enc = kCFStringEncodingMacChineseSimp ;
2084 break ;
2085 case wxFONTENCODING_MACTIBETAN :
2086 enc = kCFStringEncodingMacTibetan ;
2087 break ;
2088 case wxFONTENCODING_MACMONGOLIAN :
2089 enc = kCFStringEncodingMacMongolian ;
2090 break ;
2091 case wxFONTENCODING_MACETHIOPIC :
2092 enc = kCFStringEncodingMacEthiopic ;
2093 break ;
2094 case wxFONTENCODING_MACCENTRALEUR :
2095 enc = kCFStringEncodingMacCentralEurRoman ;
2096 break ;
2097 case wxFONTENCODING_MACVIATNAMESE :
2098 enc = kCFStringEncodingMacVietnamese ;
2099 break ;
2100 case wxFONTENCODING_MACARABICEXT :
2101 enc = kCFStringEncodingMacExtArabic ;
2102 break ;
2103 case wxFONTENCODING_MACSYMBOL :
2104 enc = kCFStringEncodingMacSymbol ;
2105 break ;
2106 case wxFONTENCODING_MACDINGBATS :
2107 enc = kCFStringEncodingMacDingbats ;
2108 break ;
2109 case wxFONTENCODING_MACTURKISH :
2110 enc = kCFStringEncodingMacTurkish ;
2111 break ;
2112 case wxFONTENCODING_MACCROATIAN :
2113 enc = kCFStringEncodingMacCroatian ;
2114 break ;
2115 case wxFONTENCODING_MACICELANDIC :
2116 enc = kCFStringEncodingMacIcelandic ;
2117 break ;
2118 case wxFONTENCODING_MACROMANIAN :
2119 enc = kCFStringEncodingMacRomanian ;
2120 break ;
2121 case wxFONTENCODING_MACCELTIC :
2122 enc = kCFStringEncodingMacCeltic ;
2123 break ;
2124 case wxFONTENCODING_MACGAELIC :
2125 enc = kCFStringEncodingMacGaelic ;
2126 break ;
2127// case wxFONTENCODING_MACKEYBOARD :
2128// enc = kCFStringEncodingMacKeyboardGlyphs ;
2129// break ;
2130 default :
2131 // because gcc is picky
2132 break ;
2133 } ;
2134 return enc ;
2135}
2136
2137class wxMBConv_cocoa : public wxMBConv
2138{
2139public:
2140 wxMBConv_cocoa()
2141 {
2142 Init(CFStringGetSystemEncoding()) ;
2143 }
2144
2145#if wxUSE_FONTMAP
2146 wxMBConv_cocoa(const wxChar* name)
2147 {
2148 Init( wxCFStringEncFromFontEnc(wxFontMapperBase::Get()->CharsetToEncoding(name, false) ) ) ;
2149 }
2150#endif
2151
2152 wxMBConv_cocoa(wxFontEncoding encoding)
2153 {
2154 Init( wxCFStringEncFromFontEnc(encoding) );
2155 }
2156
2157 ~wxMBConv_cocoa()
2158 {
2159 }
2160
2161 void Init( CFStringEncoding encoding)
2162 {
2163 m_encoding = encoding ;
2164 }
2165
2166 size_t MB2WC(wchar_t * szOut, const char * szUnConv, size_t nOutSize) const
2167 {
2168 wxASSERT(szUnConv);
2169
2170 CFStringRef theString = CFStringCreateWithBytes (
2171 NULL, //the allocator
2172 (const UInt8*)szUnConv,
2173 strlen(szUnConv),
2174 m_encoding,
2175 false //no BOM/external representation
2176 );
2177
2178 wxASSERT(theString);
2179
2180 size_t nOutLength = CFStringGetLength(theString);
2181
2182 if (szOut == NULL)
2183 {
2184 CFRelease(theString);
2185 return nOutLength;
2186 }
2187
2188 CFRange theRange = { 0, nOutSize };
2189
2190#if SIZEOF_WCHAR_T == 4
2191 UniChar* szUniCharBuffer = new UniChar[nOutSize];
2192#endif
2193
2194 CFStringGetCharacters(theString, theRange, szUniCharBuffer);
2195
2196 CFRelease(theString);
2197
2198 szUniCharBuffer[nOutLength] = '\0' ;
2199
2200#if SIZEOF_WCHAR_T == 4
2201 wxMBConvUTF16 converter ;
2202 converter.MB2WC(szOut, (const char*)szUniCharBuffer , nOutSize ) ;
2203 delete[] szUniCharBuffer;
2204#endif
2205
2206 return nOutLength;
2207 }
2208
2209 size_t WC2MB(char *szOut, const wchar_t *szUnConv, size_t nOutSize) const
2210 {
2211 wxASSERT(szUnConv);
2212
2213 size_t nRealOutSize;
2214 size_t nBufSize = wxWcslen(szUnConv);
2215 UniChar* szUniBuffer = (UniChar*) szUnConv;
2216
2217#if SIZEOF_WCHAR_T == 4
2218 wxMBConvUTF16 converter ;
2219 nBufSize = converter.WC2MB( NULL , szUnConv , 0 );
2220 szUniBuffer = new UniChar[ (nBufSize / sizeof(UniChar)) + 1] ;
2221 converter.WC2MB( (char*) szUniBuffer , szUnConv, nBufSize + sizeof(UniChar)) ;
2222 nBufSize /= sizeof(UniChar);
2223#endif
2224
2225 CFStringRef theString = CFStringCreateWithCharactersNoCopy(
2226 NULL, //allocator
2227 szUniBuffer,
2228 nBufSize,
2229 kCFAllocatorNull //deallocator - we want to deallocate it ourselves
2230 );
2231
2232 wxASSERT(theString);
2233
2234 //Note that CER puts a BOM when converting to unicode
2235 //so we check and use getchars instead in that case
2236 if (m_encoding == kCFStringEncodingUnicode)
2237 {
2238 if (szOut != NULL)
2239 CFStringGetCharacters(theString, CFRangeMake(0, nOutSize - 1), (UniChar*) szOut);
2240
2241 nRealOutSize = CFStringGetLength(theString) + 1;
2242 }
2243 else
2244 {
2245 CFStringGetBytes(
2246 theString,
2247 CFRangeMake(0, CFStringGetLength(theString)),
2248 m_encoding,
2249 0, //what to put in characters that can't be converted -
2250 //0 tells CFString to return NULL if it meets such a character
2251 false, //not an external representation
2252 (UInt8*) szOut,
2253 nOutSize,
2254 (CFIndex*) &nRealOutSize
2255 );
2256 }
2257
2258 CFRelease(theString);
2259
2260#if SIZEOF_WCHAR_T == 4
2261 delete[] szUniBuffer;
2262#endif
2263
2264 return nRealOutSize - 1;
2265 }
2266
2267 bool IsOk() const
2268 {
2269 return m_encoding != kCFStringEncodingInvalidId &&
2270 CFStringIsEncodingAvailable(m_encoding);
2271 }
2272
2273private:
2274 CFStringEncoding m_encoding ;
2275};
2276
2277#endif // defined(__WXCOCOA__)
2278
2279// ============================================================================
2280// Mac conversion classes
2281// ============================================================================
2282
2283#if defined(__WXMAC__) && defined(TARGET_CARBON)
2284
2285class wxMBConv_mac : public wxMBConv
2286{
2287public:
2288 wxMBConv_mac()
2289 {
2290 Init(CFStringGetSystemEncoding()) ;
2291 }
2292
2293#if wxUSE_FONTMAP
2294 wxMBConv_mac(const wxChar* name)
2295 {
2296 Init( wxMacGetSystemEncFromFontEnc(wxFontMapperBase::Get()->CharsetToEncoding(name, false) ) ) ;
2297 }
2298#endif
2299
2300 wxMBConv_mac(wxFontEncoding encoding)
2301 {
2302 Init( wxMacGetSystemEncFromFontEnc(encoding) );
2303 }
2304
2305 ~wxMBConv_mac()
2306 {
2307 OSStatus status = noErr ;
2308 status = TECDisposeConverter(m_MB2WC_converter);
2309 status = TECDisposeConverter(m_WC2MB_converter);
2310 }
2311
2312
2313 void Init( TextEncodingBase encoding)
2314 {
2315 OSStatus status = noErr ;
2316 m_char_encoding = encoding ;
2317 m_unicode_encoding = CreateTextEncoding(kTextEncodingUnicodeDefault,0,kUnicode16BitFormat) ;
2318
2319 status = TECCreateConverter(&m_MB2WC_converter,
2320 m_char_encoding,
2321 m_unicode_encoding);
2322 status = TECCreateConverter(&m_WC2MB_converter,
2323 m_unicode_encoding,
2324 m_char_encoding);
2325 }
2326
2327 size_t MB2WC(wchar_t *buf, const char *psz, size_t n) const
2328 {
2329 OSStatus status = noErr ;
2330 ByteCount byteOutLen ;
2331 ByteCount byteInLen = strlen(psz) ;
2332 wchar_t *tbuf = NULL ;
2333 UniChar* ubuf = NULL ;
2334 size_t res = 0 ;
2335
2336 if (buf == NULL)
2337 {
2338 //apple specs say at least 32
2339 n = wxMax( 32 , byteInLen ) ;
2340 tbuf = (wchar_t*) malloc( n * SIZEOF_WCHAR_T) ;
2341 }
2342 ByteCount byteBufferLen = n * sizeof( UniChar ) ;
2343#if SIZEOF_WCHAR_T == 4
2344 ubuf = (UniChar*) malloc( byteBufferLen + 2 ) ;
2345#else
2346 ubuf = (UniChar*) (buf ? buf : tbuf) ;
2347#endif
2348 status = TECConvertText(m_MB2WC_converter, (ConstTextPtr) psz , byteInLen, &byteInLen,
2349 (TextPtr) ubuf , byteBufferLen, &byteOutLen);
2350#if SIZEOF_WCHAR_T == 4
2351 // we have to terminate here, because n might be larger for the trailing zero, and if UniChar
2352 // is not properly terminated we get random characters at the end
2353 ubuf[byteOutLen / sizeof( UniChar ) ] = 0 ;
2354 wxMBConvUTF16 converter ;
2355 res = converter.MB2WC( (buf ? buf : tbuf) , (const char*)ubuf , n ) ;
2356 free( ubuf ) ;
2357#else
2358 res = byteOutLen / sizeof( UniChar ) ;
2359#endif
2360 if ( buf == NULL )
2361 free(tbuf) ;
2362
2363 if ( buf && res < n)
2364 buf[res] = 0;
2365
2366 return res ;
2367 }
2368
2369 size_t WC2MB(char *buf, const wchar_t *psz, size_t n) const
2370 {
2371 OSStatus status = noErr ;
2372 ByteCount byteOutLen ;
2373 ByteCount byteInLen = wxWcslen(psz) * SIZEOF_WCHAR_T ;
2374
2375 char *tbuf = NULL ;
2376
2377 if (buf == NULL)
2378 {
2379 //apple specs say at least 32
2380 n = wxMax( 32 , ((byteInLen / SIZEOF_WCHAR_T) * 8) + SIZEOF_WCHAR_T );
2381 tbuf = (char*) malloc( n ) ;
2382 }
2383
2384 ByteCount byteBufferLen = n ;
2385 UniChar* ubuf = NULL ;
2386#if SIZEOF_WCHAR_T == 4
2387 wxMBConvUTF16 converter ;
2388 size_t unicharlen = converter.WC2MB( NULL , psz , 0 ) ;
2389 byteInLen = unicharlen ;
2390 ubuf = (UniChar*) malloc( byteInLen + 2 ) ;
2391 converter.WC2MB( (char*) ubuf , psz, unicharlen + 2 ) ;
2392#else
2393 ubuf = (UniChar*) psz ;
2394#endif
2395 status = TECConvertText(m_WC2MB_converter, (ConstTextPtr) ubuf , byteInLen, &byteInLen,
2396 (TextPtr) (buf ? buf : tbuf) , byteBufferLen, &byteOutLen);
2397#if SIZEOF_WCHAR_T == 4
2398 free( ubuf ) ;
2399#endif
2400 if ( buf == NULL )
2401 free(tbuf) ;
2402
2403 size_t res = byteOutLen ;
2404 if ( buf && res < n)
2405 {
2406 buf[res] = 0;
2407
2408 //we need to double-trip to verify it didn't insert any ? in place
2409 //of bogus characters
2410 wxWCharBuffer wcBuf(n);
2411 size_t pszlen = wxWcslen(psz);
2412 if ( MB2WC(wcBuf.data(), buf, n) == (size_t)-1 ||
2413 wxWcslen(wcBuf) != pszlen ||
2414 memcmp(wcBuf, psz, pszlen * sizeof(wchar_t)) != 0 )
2415 {
2416 // we didn't obtain the same thing we started from, hence
2417 // the conversion was lossy and we consider that it failed
2418 return (size_t)-1;
2419 }
2420 }
2421
2422 return res ;
2423 }
2424
2425 bool IsOk() const
2426 { return m_MB2WC_converter != NULL && m_WC2MB_converter != NULL ; }
2427
2428private:
2429 TECObjectRef m_MB2WC_converter ;
2430 TECObjectRef m_WC2MB_converter ;
2431
2432 TextEncodingBase m_char_encoding ;
2433 TextEncodingBase m_unicode_encoding ;
2434};
2435
2436#endif // defined(__WXMAC__) && defined(TARGET_CARBON)
2437
2438// ============================================================================
2439// wxEncodingConverter based conversion classes
2440// ============================================================================
2441
2442#if wxUSE_FONTMAP
2443
2444class wxMBConv_wxwin : public wxMBConv
2445{
2446private:
2447 void Init()
2448 {
2449 m_ok = m2w.Init(m_enc, wxFONTENCODING_UNICODE) &&
2450 w2m.Init(wxFONTENCODING_UNICODE, m_enc);
2451 }
2452
2453public:
2454 // temporarily just use wxEncodingConverter stuff,
2455 // so that it works while a better implementation is built
2456 wxMBConv_wxwin(const wxChar* name)
2457 {
2458 if (name)
2459 m_enc = wxFontMapperBase::Get()->CharsetToEncoding(name, false);
2460 else
2461 m_enc = wxFONTENCODING_SYSTEM;
2462
2463 Init();
2464 }
2465
2466 wxMBConv_wxwin(wxFontEncoding enc)
2467 {
2468 m_enc = enc;
2469
2470 Init();
2471 }
2472
2473 size_t MB2WC(wchar_t *buf, const char *psz, size_t WXUNUSED(n)) const
2474 {
2475 size_t inbuf = strlen(psz);
2476 if (buf)
2477 {
2478 if (!m2w.Convert(psz,buf))
2479 return (size_t)-1;
2480 }
2481 return inbuf;
2482 }
2483
2484 size_t WC2MB(char *buf, const wchar_t *psz, size_t WXUNUSED(n)) const
2485 {
2486 const size_t inbuf = wxWcslen(psz);
2487 if (buf)
2488 {
2489 if (!w2m.Convert(psz,buf))
2490 return (size_t)-1;
2491 }
2492
2493 return inbuf;
2494 }
2495
2496 bool IsOk() const { return m_ok; }
2497
2498public:
2499 wxFontEncoding m_enc;
2500 wxEncodingConverter m2w, w2m;
2501
2502 // were we initialized successfully?
2503 bool m_ok;
2504
2505 DECLARE_NO_COPY_CLASS(wxMBConv_wxwin)
2506};
2507
2508// make the constructors available for unit testing
2509WXDLLIMPEXP_BASE wxMBConv* new_wxMBConv_wxwin( const wxChar* name )
2510{
2511 wxMBConv_wxwin* result = new wxMBConv_wxwin( name );
2512 if ( !result->IsOk() )
2513 {
2514 delete result;
2515 return 0;
2516 }
2517 return result;
2518}
2519
2520#endif // wxUSE_FONTMAP
2521
2522// ============================================================================
2523// wxCSConv implementation
2524// ============================================================================
2525
2526void wxCSConv::Init()
2527{
2528 m_name = NULL;
2529 m_convReal = NULL;
2530 m_deferred = true;
2531}
2532
2533wxCSConv::wxCSConv(const wxChar *charset)
2534{
2535 Init();
2536
2537 if ( charset )
2538 {
2539 SetName(charset);
2540 }
2541
2542#if wxUSE_FONTMAP
2543 m_encoding = wxFontMapperBase::GetEncodingFromName(charset);
2544#else
2545 m_encoding = wxFONTENCODING_SYSTEM;
2546#endif
2547}
2548
2549wxCSConv::wxCSConv(wxFontEncoding encoding)
2550{
2551 if ( encoding == wxFONTENCODING_MAX || encoding == wxFONTENCODING_DEFAULT )
2552 {
2553 wxFAIL_MSG( _T("invalid encoding value in wxCSConv ctor") );
2554
2555 encoding = wxFONTENCODING_SYSTEM;
2556 }
2557
2558 Init();
2559
2560 m_encoding = encoding;
2561}
2562
2563wxCSConv::~wxCSConv()
2564{
2565 Clear();
2566}
2567
2568wxCSConv::wxCSConv(const wxCSConv& conv)
2569 : wxMBConv()
2570{
2571 Init();
2572
2573 SetName(conv.m_name);
2574 m_encoding = conv.m_encoding;
2575}
2576
2577wxCSConv& wxCSConv::operator=(const wxCSConv& conv)
2578{
2579 Clear();
2580
2581 SetName(conv.m_name);
2582 m_encoding = conv.m_encoding;
2583
2584 return *this;
2585}
2586
2587void wxCSConv::Clear()
2588{
2589 free(m_name);
2590 delete m_convReal;
2591
2592 m_name = NULL;
2593 m_convReal = NULL;
2594}
2595
2596void wxCSConv::SetName(const wxChar *charset)
2597{
2598 if (charset)
2599 {
2600 m_name = wxStrdup(charset);
2601 m_deferred = true;
2602 }
2603}
2604
2605#if wxUSE_FONTMAP
2606#include "wx/hashmap.h"
2607
2608WX_DECLARE_HASH_MAP( wxFontEncoding, wxString, wxIntegerHash, wxIntegerEqual,
2609 wxEncodingNameCache );
2610
2611static wxEncodingNameCache gs_nameCache;
2612#endif
2613
2614wxMBConv *wxCSConv::DoCreate() const
2615{
2616#if wxUSE_FONTMAP
2617 wxLogTrace(TRACE_STRCONV,
2618 wxT("creating conversion for %s"),
2619 (m_name ? m_name
2620 : wxFontMapperBase::GetEncodingName(m_encoding).c_str()));
2621#endif // wxUSE_FONTMAP
2622
2623 // check for the special case of ASCII or ISO8859-1 charset: as we have
2624 // special knowledge of it anyhow, we don't need to create a special
2625 // conversion object
2626 if ( m_encoding == wxFONTENCODING_ISO8859_1 ||
2627 m_encoding == wxFONTENCODING_DEFAULT )
2628 {
2629 // don't convert at all
2630 return NULL;
2631 }
2632
2633 // we trust OS to do conversion better than we can so try external
2634 // conversion methods first
2635 //
2636 // the full order is:
2637 // 1. OS conversion (iconv() under Unix or Win32 API)
2638 // 2. hard coded conversions for UTF
2639 // 3. wxEncodingConverter as fall back
2640
2641 // step (1)
2642#ifdef HAVE_ICONV
2643#if !wxUSE_FONTMAP
2644 if ( m_name )
2645#endif // !wxUSE_FONTMAP
2646 {
2647 wxString name(m_name);
2648 wxFontEncoding encoding(m_encoding);
2649
2650 if ( !name.empty() )
2651 {
2652 wxMBConv_iconv *conv = new wxMBConv_iconv(name);
2653 if ( conv->IsOk() )
2654 return conv;
2655
2656 delete conv;
2657
2658#if wxUSE_FONTMAP
2659 encoding =
2660 wxFontMapperBase::Get()->CharsetToEncoding(name, false);
2661#endif // wxUSE_FONTMAP
2662 }
2663#if wxUSE_FONTMAP
2664 {
2665 const wxEncodingNameCache::iterator it = gs_nameCache.find(encoding);
2666 if ( it != gs_nameCache.end() )
2667 {
2668 if ( it->second.empty() )
2669 return NULL;
2670
2671 wxMBConv_iconv *conv = new wxMBConv_iconv(it->second);
2672 if ( conv->IsOk() )
2673 return conv;
2674
2675 delete conv;
2676 }
2677
2678 const wxChar** names = wxFontMapperBase::GetAllEncodingNames(encoding);
2679
2680 for ( ; *names; ++names )
2681 {
2682 wxMBConv_iconv *conv = new wxMBConv_iconv(*names);
2683 if ( conv->IsOk() )
2684 {
2685 gs_nameCache[encoding] = *names;
2686 return conv;
2687 }
2688
2689 delete conv;
2690 }
2691
2692 gs_nameCache[encoding] = _T(""); // cache the failure
2693 }
2694#endif // wxUSE_FONTMAP
2695 }
2696#endif // HAVE_ICONV
2697
2698#ifdef wxHAVE_WIN32_MB2WC
2699 {
2700#if wxUSE_FONTMAP
2701 wxMBConv_win32 *conv = m_name ? new wxMBConv_win32(m_name)
2702 : new wxMBConv_win32(m_encoding);
2703 if ( conv->IsOk() )
2704 return conv;
2705
2706 delete conv;
2707#else
2708 return NULL;
2709#endif
2710 }
2711#endif // wxHAVE_WIN32_MB2WC
2712#if defined(__WXMAC__)
2713 {
2714 // leave UTF16 and UTF32 to the built-ins of wx
2715 if ( m_name || ( m_encoding < wxFONTENCODING_UTF16BE ||
2716 ( m_encoding >= wxFONTENCODING_MACMIN && m_encoding <= wxFONTENCODING_MACMAX ) ) )
2717 {
2718
2719#if wxUSE_FONTMAP
2720 wxMBConv_mac *conv = m_name ? new wxMBConv_mac(m_name)
2721 : new wxMBConv_mac(m_encoding);
2722#else
2723 wxMBConv_mac *conv = new wxMBConv_mac(m_encoding);
2724#endif
2725 if ( conv->IsOk() )
2726 return conv;
2727
2728 delete conv;
2729 }
2730 }
2731#endif
2732#if defined(__WXCOCOA__)
2733 {
2734 if ( m_name || ( m_encoding <= wxFONTENCODING_UTF16 ) )
2735 {
2736
2737#if wxUSE_FONTMAP
2738 wxMBConv_cocoa *conv = m_name ? new wxMBConv_cocoa(m_name)
2739 : new wxMBConv_cocoa(m_encoding);
2740#else
2741 wxMBConv_cocoa *conv = new wxMBConv_cocoa(m_encoding);
2742#endif
2743 if ( conv->IsOk() )
2744 return conv;
2745
2746 delete conv;
2747 }
2748 }
2749#endif
2750 // step (2)
2751 wxFontEncoding enc = m_encoding;
2752#if wxUSE_FONTMAP
2753 if ( enc == wxFONTENCODING_SYSTEM && m_name )
2754 {
2755 // use "false" to suppress interactive dialogs -- we can be called from
2756 // anywhere and popping up a dialog from here is the last thing we want to
2757 // do
2758 enc = wxFontMapperBase::Get()->CharsetToEncoding(m_name, false);
2759 }
2760#endif // wxUSE_FONTMAP
2761
2762 switch ( enc )
2763 {
2764 case wxFONTENCODING_UTF7:
2765 return new wxMBConvUTF7;
2766
2767 case wxFONTENCODING_UTF8:
2768 return new wxMBConvUTF8;
2769
2770 case wxFONTENCODING_UTF16BE:
2771 return new wxMBConvUTF16BE;
2772
2773 case wxFONTENCODING_UTF16LE:
2774 return new wxMBConvUTF16LE;
2775
2776 case wxFONTENCODING_UTF32BE:
2777 return new wxMBConvUTF32BE;
2778
2779 case wxFONTENCODING_UTF32LE:
2780 return new wxMBConvUTF32LE;
2781
2782 default:
2783 // nothing to do but put here to suppress gcc warnings
2784 ;
2785 }
2786
2787 // step (3)
2788#if wxUSE_FONTMAP
2789 {
2790 wxMBConv_wxwin *conv = m_name ? new wxMBConv_wxwin(m_name)
2791 : new wxMBConv_wxwin(m_encoding);
2792 if ( conv->IsOk() )
2793 return conv;
2794
2795 delete conv;
2796 }
2797#endif // wxUSE_FONTMAP
2798
2799 // NB: This is a hack to prevent deadlock. What could otherwise happen
2800 // in Unicode build: wxConvLocal creation ends up being here
2801 // because of some failure and logs the error. But wxLog will try to
2802 // attach timestamp, for which it will need wxConvLocal (to convert
2803 // time to char* and then wchar_t*), but that fails, tries to log
2804 // error, but wxLog has a (already locked) critical section that
2805 // guards static buffer.
2806 static bool alreadyLoggingError = false;
2807 if (!alreadyLoggingError)
2808 {
2809 alreadyLoggingError = true;
2810 wxLogError(_("Cannot convert from the charset '%s'!"),
2811 m_name ? m_name
2812 :
2813#if wxUSE_FONTMAP
2814 wxFontMapperBase::GetEncodingDescription(m_encoding).c_str()
2815#else // !wxUSE_FONTMAP
2816 wxString::Format(_("encoding %s"), m_encoding).c_str()
2817#endif // wxUSE_FONTMAP/!wxUSE_FONTMAP
2818 );
2819 alreadyLoggingError = false;
2820 }
2821
2822 return NULL;
2823}
2824
2825void wxCSConv::CreateConvIfNeeded() const
2826{
2827 if ( m_deferred )
2828 {
2829 wxCSConv *self = (wxCSConv *)this; // const_cast
2830
2831#if wxUSE_INTL
2832 // if we don't have neither the name nor the encoding, use the default
2833 // encoding for this system
2834 if ( !m_name && m_encoding == wxFONTENCODING_SYSTEM )
2835 {
2836 self->m_name = wxStrdup(wxLocale::GetSystemEncodingName());
2837 }
2838#endif // wxUSE_INTL
2839
2840 self->m_convReal = DoCreate();
2841 self->m_deferred = false;
2842 }
2843}
2844
2845size_t wxCSConv::MB2WC(wchar_t *buf, const char *psz, size_t n) const
2846{
2847 CreateConvIfNeeded();
2848
2849 if (m_convReal)
2850 return m_convReal->MB2WC(buf, psz, n);
2851
2852 // latin-1 (direct)
2853 size_t len = strlen(psz);
2854
2855 if (buf)
2856 {
2857 for (size_t c = 0; c <= len; c++)
2858 buf[c] = (unsigned char)(psz[c]);
2859 }
2860
2861 return len;
2862}
2863
2864size_t wxCSConv::WC2MB(char *buf, const wchar_t *psz, size_t n) const
2865{
2866 CreateConvIfNeeded();
2867
2868 if (m_convReal)
2869 return m_convReal->WC2MB(buf, psz, n);
2870
2871 // latin-1 (direct)
2872 const size_t len = wxWcslen(psz);
2873 if (buf)
2874 {
2875 for (size_t c = 0; c <= len; c++)
2876 {
2877 if (psz[c] > 0xFF)
2878 return (size_t)-1;
2879 buf[c] = (char)psz[c];
2880 }
2881 }
2882 else
2883 {
2884 for (size_t c = 0; c <= len; c++)
2885 {
2886 if (psz[c] > 0xFF)
2887 return (size_t)-1;
2888 }
2889 }
2890
2891 return len;
2892}
2893
2894// ----------------------------------------------------------------------------
2895// globals
2896// ----------------------------------------------------------------------------
2897
2898#ifdef __WINDOWS__
2899 static wxMBConv_win32 wxConvLibcObj;
2900#elif defined(__WXMAC__) && !defined(__MACH__)
2901 static wxMBConv_mac wxConvLibcObj ;
2902#else
2903 static wxMBConvLibc wxConvLibcObj;
2904#endif
2905
2906static wxCSConv wxConvLocalObj(wxFONTENCODING_SYSTEM);
2907static wxCSConv wxConvISO8859_1Obj(wxFONTENCODING_ISO8859_1);
2908static wxMBConvUTF7 wxConvUTF7Obj;
2909static wxMBConvUTF8 wxConvUTF8Obj;
2910
2911WXDLLIMPEXP_DATA_BASE(wxMBConv&) wxConvLibc = wxConvLibcObj;
2912WXDLLIMPEXP_DATA_BASE(wxCSConv&) wxConvLocal = wxConvLocalObj;
2913WXDLLIMPEXP_DATA_BASE(wxCSConv&) wxConvISO8859_1 = wxConvISO8859_1Obj;
2914WXDLLIMPEXP_DATA_BASE(wxMBConvUTF7&) wxConvUTF7 = wxConvUTF7Obj;
2915WXDLLIMPEXP_DATA_BASE(wxMBConvUTF8&) wxConvUTF8 = wxConvUTF8Obj;
2916WXDLLIMPEXP_DATA_BASE(wxMBConv *) wxConvCurrent = &wxConvLibcObj;
2917WXDLLIMPEXP_DATA_BASE(wxMBConv *) wxConvFileName = &
2918#ifdef __WXOSX__
2919 wxConvUTF8Obj;
2920#else
2921 wxConvLibcObj;
2922#endif
2923
2924
2925#else // !wxUSE_WCHAR_T
2926
2927// stand-ins in absence of wchar_t
2928WXDLLIMPEXP_DATA_BASE(wxMBConv) wxConvLibc,
2929 wxConvISO8859_1,
2930 wxConvLocal,
2931 wxConvUTF8;
2932
2933#endif // wxUSE_WCHAR_T/!wxUSE_WCHAR_T
wxWidgets (Impactor)