]> git.saurik.com Git - wxWidgets.git/blob - src/common/strconv.cpp
projects / wxWidgets.git / blob
? search:


415e05ab752810d3684f8539a1cec16f53aed324
[wxWidgets.git] / src / common / strconv.cpp
1 /////////////////////////////////////////////////////////////////////////////
2 // Name: strconv.cpp
3 // Purpose: Unicode conversion classes
4 // Author: Ove Kaaven, Robert Roebling, Vadim Zeitlin, Vaclav Slavik
5 // Modified by:
6 // Created: 29/01/98
7 // RCS-ID: $Id$
8 // Copyright: (c) 1999 Ove Kaaven, Robert Roebling, Vaclav Slavik
9 // (c) 2000-2003 Vadim Zeitlin
10 // Licence: wxWindows licence
11 /////////////////////////////////////////////////////////////////////////////
12
13 // ============================================================================
14 // declarations
15 // ============================================================================
16
17 // ----------------------------------------------------------------------------
18 // headers
19 // ----------------------------------------------------------------------------
20
21 #if defined(__GNUG__) && !defined(NO_GCC_PRAGMA)
22 #pragma implementation "strconv.h"
23 #endif
24
25 // For compilers that support precompilation, includes "wx.h".
26 #include "wx/wxprec.h"
27
28 #ifdef __BORLANDC__
29 #pragma hdrstop
30 #endif
31
32 #ifndef WX_PRECOMP
33 #include "wx/intl.h"
34 #include "wx/log.h"
35 #endif // WX_PRECOMP
36
37 #include "wx/strconv.h"
38
39 #if wxUSE_WCHAR_T
40
41 #ifdef __WXMSW__
42 #include "wx/msw/private.h"
43 #endif
44
45 #ifdef __WINDOWS__
46 #include "wx/msw/missing.h"
47 #endif
48
49 #ifndef __WXWINCE__
50 #include <errno.h>
51 #endif
52
53 #include <ctype.h>
54 #include <string.h>
55 #include <stdlib.h>
56
57 #if defined(__WIN32__) && !defined(__WXMICROWIN__)
58 #define wxHAVE_WIN32_MB2WC
59 #endif // __WIN32__ but !__WXMICROWIN__
60
61 // ----------------------------------------------------------------------------
62 // headers
63 // ----------------------------------------------------------------------------
64
65 #ifdef __SALFORDC__
66 #include <clib.h>
67 #endif
68
69 #ifdef HAVE_ICONV
70 #include <iconv.h>
71 #endif
72
73 #include "wx/encconv.h"
74 #include "wx/fontmap.h"
75 #include "wx/utils.h"
76
77 #ifdef __WXMAC__
78 #include <ATSUnicode.h>
79 #include <TextCommon.h>
80 #include <TextEncodingConverter.h>
81
82 #include "wx/mac/private.h" // includes mac headers
83 #endif
84 // ----------------------------------------------------------------------------
85 // macros
86 // ----------------------------------------------------------------------------
87
88 #define BSWAP_UCS4(str, len) { unsigned _c; for (_c=0; _c<len; _c++) str[_c]=wxUINT32_SWAP_ALWAYS(str[_c]); }
89 #define BSWAP_UTF16(str, len) { unsigned _c; for (_c=0; _c<len; _c++) str[_c]=wxUINT16_SWAP_ALWAYS(str[_c]); }
90
91 #if SIZEOF_WCHAR_T == 4
92 #define WC_NAME "UCS4"
93 #define WC_BSWAP BSWAP_UCS4
94 #ifdef WORDS_BIGENDIAN
95 #define WC_NAME_BEST "UCS-4BE"
96 #else
97 #define WC_NAME_BEST "UCS-4LE"
98 #endif
99 #elif SIZEOF_WCHAR_T == 2
100 #define WC_NAME "UTF16"
101 #define WC_BSWAP BSWAP_UTF16
102 #define WC_UTF16
103 #ifdef WORDS_BIGENDIAN
104 #define WC_NAME_BEST "UTF-16BE"
105 #else
106 #define WC_NAME_BEST "UTF-16LE"
107 #endif
108 #else // sizeof(wchar_t) != 2 nor 4
109 // does this ever happen?
110 #error "Unknown sizeof(wchar_t): please report this to wx-dev@lists.wxwindows.org"
111 #endif
112
113 // ============================================================================
114 // implementation
115 // ============================================================================
116
117 // ----------------------------------------------------------------------------
118 // UTF-16 en/decoding to/from UCS-4
119 // ----------------------------------------------------------------------------
120
121
122 static size_t encode_utf16(wxUint32 input, wxUint16 *output)
123 {
124 if (input<=0xffff)
125 {
126 if (output)
127 *output = (wxUint16) input;
128 return 1;
129 }
130 else if (input>=0x110000)
131 {
132 return (size_t)-1;
133 }
134 else
135 {
136 if (output)
137 {
138 *output++ = (wxUint16) ((input >> 10)+0xd7c0);
139 *output = (wxUint16) ((input&0x3ff)+0xdc00);
140 }
141 return 2;
142 }
143 }
144
145 static size_t decode_utf16(const wxUint16* input, wxUint32& output)
146 {
147 if ((*input<0xd800) || (*input>0xdfff))
148 {
149 output = *input;
150 return 1;
151 }
152 else if ((input[1]<0xdc00) || (input[1]>=0xdfff))
153 {
154 output = *input;
155 return (size_t)-1;
156 }
157 else
158 {
159 output = ((input[0] - 0xd7c0) << 10) + (input[1] - 0xdc00);
160 return 2;
161 }
162 }
163
164
165 // ----------------------------------------------------------------------------
166 // wxMBConv
167 // ----------------------------------------------------------------------------
168
169 wxMBConv::~wxMBConv()
170 {
171 // nothing to do here (necessary for Darwin linking probably)
172 }
173
174 const wxWCharBuffer wxMBConv::cMB2WC(const char *psz) const
175 {
176 if ( psz )
177 {
178 // calculate the length of the buffer needed first
179 size_t nLen = MB2WC(NULL, psz, 0);
180 if ( nLen != (size_t)-1 )
181 {
182 // now do the actual conversion
183 wxWCharBuffer buf(nLen);
184 nLen = MB2WC(buf.data(), psz, nLen + 1); // with the trailing NULL
185 if ( nLen != (size_t)-1 )
186 {
187 return buf;
188 }
189 }
190 }
191
192 wxWCharBuffer buf((wchar_t *)NULL);
193
194 return buf;
195 }
196
197 const wxCharBuffer wxMBConv::cWC2MB(const wchar_t *pwz) const
198 {
199 if ( pwz )
200 {
201 size_t nLen = WC2MB(NULL, pwz, 0);
202 if ( nLen != (size_t)-1 )
203 {
204 wxCharBuffer buf(nLen+3); // space for a wxUint32 trailing zero
205 nLen = WC2MB(buf.data(), pwz, nLen + 4);
206 if ( nLen != (size_t)-1 )
207 {
208 return buf;
209 }
210 }
211 }
212
213 wxCharBuffer buf((char *)NULL);
214
215 return buf;
216 }
217
218 // ----------------------------------------------------------------------------
219 // wxMBConvLibc
220 // ----------------------------------------------------------------------------
221
222 size_t wxMBConvLibc::MB2WC(wchar_t *buf, const char *psz, size_t n) const
223 {
224 return wxMB2WC(buf, psz, n);
225 }
226
227 size_t wxMBConvLibc::WC2MB(char *buf, const wchar_t *psz, size_t n) const
228 {
229 return wxWC2MB(buf, psz, n);
230 }
231
232 // ----------------------------------------------------------------------------
233 // UTF-7
234 // ----------------------------------------------------------------------------
235
236 #if 0
237 static char utf7_setD[]="ABCDEFGHIJKLMNOPQRSTUVWXYZ"
238 "abcdefghijklmnopqrstuvwxyz"
239 "0123456789'(),-./:?";
240 static char utf7_setO[]="!\"#$%&*;<=>@[]^_`{|}";
241 static char utf7_setB[]="ABCDEFGHIJKLMNOPQRSTUVWXYZ"
242 "abcdefghijklmnopqrstuvwxyz"
243 "0123456789+/";
244 #endif
245
246 // TODO: write actual implementations of UTF-7 here
247 size_t wxMBConvUTF7::MB2WC(wchar_t * WXUNUSED(buf),
248 const char * WXUNUSED(psz),
249 size_t WXUNUSED(n)) const
250 {
251 return (size_t)-1;
252 }
253
254 size_t wxMBConvUTF7::WC2MB(char * WXUNUSED(buf),
255 const wchar_t * WXUNUSED(psz),
256 size_t WXUNUSED(n)) const
257 {
258 return (size_t)-1;
259 }
260
261 // ----------------------------------------------------------------------------
262 // UTF-8
263 // ----------------------------------------------------------------------------
264
265 static wxUint32 utf8_max[]=
266 { 0x7f, 0x7ff, 0xffff, 0x1fffff, 0x3ffffff, 0x7fffffff, 0xffffffff };
267
268 size_t wxMBConvUTF8::MB2WC(wchar_t *buf, const char *psz, size_t n) const
269 {
270 size_t len = 0;
271
272 while (*psz && ((!buf) || (len < n)))
273 {
274 unsigned char cc = *psz++, fc = cc;
275 unsigned cnt;
276 for (cnt = 0; fc & 0x80; cnt++)
277 fc <<= 1;
278 if (!cnt)
279 {
280 // plain ASCII char
281 if (buf)
282 *buf++ = cc;
283 len++;
284 }
285 else
286 {
287 cnt--;
288 if (!cnt)
289 {
290 // invalid UTF-8 sequence
291 return (size_t)-1;
292 }
293 else
294 {
295 unsigned ocnt = cnt - 1;
296 wxUint32 res = cc & (0x3f >> cnt);
297 while (cnt--)
298 {
299 cc = *psz++;
300 if ((cc & 0xC0) != 0x80)
301 {
302 // invalid UTF-8 sequence
303 return (size_t)-1;
304 }
305 res = (res << 6) | (cc & 0x3f);
306 }
307 if (res <= utf8_max[ocnt])
308 {
309 // illegal UTF-8 encoding
310 return (size_t)-1;
311 }
312 #ifdef WC_UTF16
313 // cast is ok because wchar_t == wxUuint16 if WC_UTF16
314 size_t pa = encode_utf16(res, (wxUint16 *)buf);
315 if (pa == (size_t)-1)
316 return (size_t)-1;
317 if (buf)
318 buf += pa;
319 len += pa;
320 #else // !WC_UTF16
321 if (buf)
322 *buf++ = res;
323 len++;
324 #endif // WC_UTF16/!WC_UTF16
325 }
326 }
327 }
328 if (buf && (len < n))
329 *buf = 0;
330 return len;
331 }
332
333 size_t wxMBConvUTF8::WC2MB(char *buf, const wchar_t *psz, size_t n) const
334 {
335 size_t len = 0;
336
337 while (*psz && ((!buf) || (len < n)))
338 {
339 wxUint32 cc;
340 #ifdef WC_UTF16
341 // cast is ok for WC_UTF16
342 size_t pa = decode_utf16((const wxUint16 *)psz, cc);
343 psz += (pa == (size_t)-1) ? 1 : pa;
344 #else
345 cc=(*psz++) & 0x7fffffff;
346 #endif
347 unsigned cnt;
348 for (cnt = 0; cc > utf8_max[cnt]; cnt++) {}
349 if (!cnt)
350 {
351 // plain ASCII char
352 if (buf)
353 *buf++ = (char) cc;
354 len++;
355 }
356
357 else
358 {
359 len += cnt + 1;
360 if (buf)
361 {
362 *buf++ = (char) ((-128 >> cnt) | ((cc >> (cnt * 6)) & (0x3f >> cnt)));
363 while (cnt--)
364 *buf++ = (char) (0x80 | ((cc >> (cnt * 6)) & 0x3f));
365 }
366 }
367 }
368
369 if (buf && (len<n)) *buf = 0;
370
371 return len;
372 }
373
374
375
376
377 // ----------------------------------------------------------------------------
378 // UTF-16
379 // ----------------------------------------------------------------------------
380
381 #ifdef WORDS_BIGENDIAN
382 #define wxMBConvUTF16straight wxMBConvUTF16BE
383 #define wxMBConvUTF16swap wxMBConvUTF16LE
384 #else
385 #define wxMBConvUTF16swap wxMBConvUTF16BE
386 #define wxMBConvUTF16straight wxMBConvUTF16LE
387 #endif
388
389
390 #ifdef WC_UTF16
391
392 // copy 16bit MB to 16bit String
393 size_t wxMBConvUTF16straight::MB2WC(wchar_t *buf, const char *psz, size_t n) const
394 {
395 size_t len=0;
396
397 while (*(wxUint16*)psz && (!buf || len < n))
398 {
399 if (buf)
400 *buf++ = *(wxUint16*)psz;
401 len++;
402
403 psz += sizeof(wxUint16);
404 }
405 if (buf && len<n) *buf=0;
406
407 return len;
408 }
409
410
411 // copy 16bit String to 16bit MB
412 size_t wxMBConvUTF16straight::WC2MB(char *buf, const wchar_t *psz, size_t n) const
413 {
414 size_t len=0;
415
416 while (*psz && (!buf || len < n))
417 {
418 if (buf)
419 {
420 *(wxUint16*)buf = *psz;
421 buf += sizeof(wxUint16);
422 }
423 len += sizeof(wxUint16);
424 psz++;
425 }
426 if (buf && len<=n-sizeof(wxUint16)) *(wxUint16*)buf=0;
427
428 return len;
429 }
430
431
432 // swap 16bit MB to 16bit String
433 size_t wxMBConvUTF16swap::MB2WC(wchar_t *buf, const char *psz, size_t n) const
434 {
435 size_t len=0;
436
437 while (*(wxUint16*)psz && (!buf || len < n))
438 {
439 if (buf)
440 {
441 ((char *)buf)[0] = psz[1];
442 ((char *)buf)[1] = psz[0];
443 buf++;
444 }
445 len++;
446 psz += sizeof(wxUint16);
447 }
448 if (buf && len<n) *buf=0;
449
450 return len;
451 }
452
453
454 // swap 16bit MB to 16bit String
455 size_t wxMBConvUTF16swap::WC2MB(char *buf, const wchar_t *psz, size_t n) const
456 {
457 size_t len=0;
458
459 while (*psz && (!buf || len < n))
460 {
461 if (buf)
462 {
463 *buf++ = ((char*)psz)[1];
464 *buf++ = ((char*)psz)[0];
465 }
466 len += sizeof(wxUint16);
467 psz++;
468 }
469 if (buf && len<=n-sizeof(wxUint16)) *(wxUint16*)buf=0;
470
471 return len;
472 }
473
474
475 #else // WC_UTF16
476
477
478 // copy 16bit MB to 32bit String
479 size_t wxMBConvUTF16straight::MB2WC(wchar_t *buf, const char *psz, size_t n) const
480 {
481 size_t len=0;
482
483 while (*(wxUint16*)psz && (!buf || len < n))
484 {
485 wxUint32 cc;
486 size_t pa=decode_utf16((wxUint16*)psz, cc);
487 if (pa == (size_t)-1)
488 return pa;
489
490 if (buf)
491 *buf++ = cc;
492 len++;
493 psz += pa * sizeof(wxUint16);
494 }
495 if (buf && len<n) *buf=0;
496
497 return len;
498 }
499
500
501 // copy 32bit String to 16bit MB
502 size_t wxMBConvUTF16straight::WC2MB(char *buf, const wchar_t *psz, size_t n) const
503 {
504 size_t len=0;
505
506 while (*psz && (!buf || len < n))
507 {
508 wxUint16 cc[2];
509 size_t pa=encode_utf16(*psz, cc);
510
511 if (pa == (size_t)-1)
512 return pa;
513
514 if (buf)
515 {
516 *(wxUint16*)buf = cc[0];
517 buf += sizeof(wxUint16);
518 if (pa > 1)
519 {
520 *(wxUint16*)buf = cc[1];
521 buf += sizeof(wxUint16);
522 }
523 }
524
525 len += pa*sizeof(wxUint16);
526 psz++;
527 }
528 if (buf && len<=n-sizeof(wxUint16)) *(wxUint16*)buf=0;
529
530 return len;
531 }
532
533
534 // swap 16bit MB to 32bit String
535 size_t wxMBConvUTF16swap::MB2WC(wchar_t *buf, const char *psz, size_t n) const
536 {
537 size_t len=0;
538
539 while (*(wxUint16*)psz && (!buf || len < n))
540 {
541 wxUint32 cc;
542 char tmp[4];
543 tmp[0]=psz[1]; tmp[1]=psz[0];
544 tmp[2]=psz[3]; tmp[3]=psz[2];
545
546 size_t pa=decode_utf16((wxUint16*)tmp, cc);
547 if (pa == (size_t)-1)
548 return pa;
549
550 if (buf)
551 *buf++ = cc;
552
553 len++;
554 psz += pa * sizeof(wxUint16);
555 }
556 if (buf && len<n) *buf=0;
557
558 return len;
559 }
560
561
562 // swap 32bit String to 16bit MB
563 size_t wxMBConvUTF16swap::WC2MB(char *buf, const wchar_t *psz, size_t n) const
564 {
565 size_t len=0;
566
567 while (*psz && (!buf || len < n))
568 {
569 wxUint16 cc[2];
570 size_t pa=encode_utf16(*psz, cc);
571
572 if (pa == (size_t)-1)
573 return pa;
574
575 if (buf)
576 {
577 *buf++ = ((char*)cc)[1];
578 *buf++ = ((char*)cc)[0];
579 if (pa > 1)
580 {
581 *buf++ = ((char*)cc)[3];
582 *buf++ = ((char*)cc)[2];
583 }
584 }
585
586 len += pa*sizeof(wxUint16);
587 psz++;
588 }
589 if (buf && len<=n-sizeof(wxUint16)) *(wxUint16*)buf=0;
590
591 return len;
592 }
593
594 #endif // WC_UTF16
595
596
597 // ----------------------------------------------------------------------------
598 // UTF-32
599 // ----------------------------------------------------------------------------
600
601 #ifdef WORDS_BIGENDIAN
602 #define wxMBConvUTF32straight wxMBConvUTF32BE
603 #define wxMBConvUTF32swap wxMBConvUTF32LE
604 #else
605 #define wxMBConvUTF32swap wxMBConvUTF32BE
606 #define wxMBConvUTF32straight wxMBConvUTF32LE
607 #endif
608
609
610 WXDLLIMPEXP_DATA_BASE(wxMBConvUTF32LE) wxConvUTF32LE;
611 WXDLLIMPEXP_DATA_BASE(wxMBConvUTF32BE) wxConvUTF32BE;
612
613
614 #ifdef WC_UTF16
615
616 // copy 32bit MB to 16bit String
617 size_t wxMBConvUTF32straight::MB2WC(wchar_t *buf, const char *psz, size_t n) const
618 {
619 size_t len=0;
620
621 while (*(wxUint32*)psz && (!buf || len < n))
622 {
623 wxUint16 cc[2];
624
625 size_t pa=encode_utf16(*(wxUint32*)psz, cc);
626 if (pa == (size_t)-1)
627 return pa;
628
629 if (buf)
630 {
631 *buf++ = cc[0];
632 if (pa > 1)
633 *buf++ = cc[1];
634 }
635 len += pa;
636 psz += sizeof(wxUint32);
637 }
638 if (buf && len<n) *buf=0;
639
640 return len;
641 }
642
643
644 // copy 16bit String to 32bit MB
645 size_t wxMBConvUTF32straight::WC2MB(char *buf, const wchar_t *psz, size_t n) const
646 {
647 size_t len=0;
648
649 while (*psz && (!buf || len < n))
650 {
651 wxUint32 cc;
652
653 // cast is ok for WC_UTF16
654 size_t pa = decode_utf16((const wxUint16 *)psz, cc);
655 if (pa == (size_t)-1)
656 return pa;
657
658 if (buf)
659 {
660 *(wxUint32*)buf = cc;
661 buf += sizeof(wxUint32);
662 }
663 len += sizeof(wxUint32);
664 psz += pa;
665 }
666
667 if (buf && len<=n-sizeof(wxUint32))
668 *(wxUint32*)buf=0;
669
670 return len;
671 }
672
673
674
675 // swap 32bit MB to 16bit String
676 size_t wxMBConvUTF32swap::MB2WC(wchar_t *buf, const char *psz, size_t n) const
677 {
678 size_t len=0;
679
680 while (*(wxUint32*)psz && (!buf || len < n))
681 {
682 char tmp[4];
683 tmp[0] = psz[3]; tmp[1] = psz[2];
684 tmp[2] = psz[1]; tmp[3] = psz[0];
685
686
687 wxUint16 cc[2];
688
689 size_t pa=encode_utf16(*(wxUint32*)tmp, cc);
690 if (pa == (size_t)-1)
691 return pa;
692
693 if (buf)
694 {
695 *buf++ = cc[0];
696 if (pa > 1)
697 *buf++ = cc[1];
698 }
699 len += pa;
700 psz += sizeof(wxUint32);
701 }
702
703 if (buf && len<n)
704 *buf=0;
705
706 return len;
707 }
708
709
710 // swap 16bit String to 32bit MB
711 size_t wxMBConvUTF32swap::WC2MB(char *buf, const wchar_t *psz, size_t n) const
712 {
713 size_t len=0;
714
715 while (*psz && (!buf || len < n))
716 {
717 char cc[4];
718
719 // cast is ok for WC_UTF16
720 size_t pa=decode_utf16((const wxUint16 *)psz, *(wxUint32*)cc);
721 if (pa == (size_t)-1)
722 return pa;
723
724 if (buf)
725 {
726 *buf++ = cc[3];
727 *buf++ = cc[2];
728 *buf++ = cc[1];
729 *buf++ = cc[0];
730 }
731 len += sizeof(wxUint32);
732 psz += pa;
733 }
734
735 if (buf && len<=n-sizeof(wxUint32))
736 *(wxUint32*)buf=0;
737
738 return len;
739 }
740
741 #else // WC_UTF16
742
743
744 // copy 32bit MB to 32bit String
745 size_t wxMBConvUTF32straight::MB2WC(wchar_t *buf, const char *psz, size_t n) const
746 {
747 size_t len=0;
748
749 while (*(wxUint32*)psz && (!buf || len < n))
750 {
751 if (buf)
752 *buf++ = *(wxUint32*)psz;
753 len++;
754 psz += sizeof(wxUint32);
755 }
756
757 if (buf && len<n)
758 *buf=0;
759
760 return len;
761 }
762
763
764 // copy 32bit String to 32bit MB
765 size_t wxMBConvUTF32straight::WC2MB(char *buf, const wchar_t *psz, size_t n) const
766 {
767 size_t len=0;
768
769 while (*psz && (!buf || len < n))
770 {
771 if (buf)
772 {
773 *(wxUint32*)buf = *psz;
774 buf += sizeof(wxUint32);
775 }
776
777 len += sizeof(wxUint32);
778 psz++;
779 }
780
781 if (buf && len<=n-sizeof(wxUint32))
782 *(wxUint32*)buf=0;
783
784 return len;
785 }
786
787
788 // swap 32bit MB to 32bit String
789 size_t wxMBConvUTF32swap::MB2WC(wchar_t *buf, const char *psz, size_t n) const
790 {
791 size_t len=0;
792
793 while (*(wxUint32*)psz && (!buf || len < n))
794 {
795 if (buf)
796 {
797 ((char *)buf)[0] = psz[3];
798 ((char *)buf)[1] = psz[2];
799 ((char *)buf)[2] = psz[1];
800 ((char *)buf)[3] = psz[0];
801 buf++;
802 }
803 len++;
804 psz += sizeof(wxUint32);
805 }
806
807 if (buf && len<n)
808 *buf=0;
809
810 return len;
811 }
812
813
814 // swap 32bit String to 32bit MB
815 size_t wxMBConvUTF32swap::WC2MB(char *buf, const wchar_t *psz, size_t n) const
816 {
817 size_t len=0;
818
819 while (*psz && (!buf || len < n))
820 {
821 if (buf)
822 {
823 *buf++ = ((char *)psz)[3];
824 *buf++ = ((char *)psz)[2];
825 *buf++ = ((char *)psz)[1];
826 *buf++ = ((char *)psz)[0];
827 }
828 len += sizeof(wxUint32);
829 psz++;
830 }
831
832 if (buf && len<=n-sizeof(wxUint32))
833 *(wxUint32*)buf=0;
834
835 return len;
836 }
837
838
839 #endif // WC_UTF16
840
841
842 // ============================================================================
843 // The classes doing conversion using the iconv_xxx() functions
844 // ============================================================================
845
846 #ifdef HAVE_ICONV
847
848 // VS: glibc 2.1.3 is broken in that iconv() conversion to/from UCS4 fails with E2BIG
849 // if output buffer is _exactly_ as big as needed. Such case is (unless there's
850 // yet another bug in glibc) the only case when iconv() returns with (size_t)-1
851 // (which means error) and says there are 0 bytes left in the input buffer --
852 // when _real_ error occurs, bytes-left-in-input buffer is non-zero. Hence,
853 // this alternative test for iconv() failure.
854 // [This bug does not appear in glibc 2.2.]
855 #if defined(__GLIBC__) && __GLIBC__ == 2 && __GLIBC_MINOR__ <= 1
856 #define ICONV_FAILED(cres, bufLeft) ((cres == (size_t)-1) && \
857 (errno != E2BIG || bufLeft != 0))
858 #else
859 #define ICONV_FAILED(cres, bufLeft) (cres == (size_t)-1)
860 #endif
861
862 #define ICONV_CHAR_CAST(x) ((ICONV_CONST char **)(x))
863
864 // ----------------------------------------------------------------------------
865 // wxMBConv_iconv: encapsulates an iconv character set
866 // ----------------------------------------------------------------------------
867
868 class wxMBConv_iconv : public wxMBConv
869 {
870 public:
871 wxMBConv_iconv(const wxChar *name);
872 virtual ~wxMBConv_iconv();
873
874 virtual size_t MB2WC(wchar_t *buf, const char *psz, size_t n) const;
875 virtual size_t WC2MB(char *buf, const wchar_t *psz, size_t n) const;
876
877 bool IsOk() const
878 { return (m2w != (iconv_t)-1) && (w2m != (iconv_t)-1); }
879
880 protected:
881 // the iconv handlers used to translate from multibyte to wide char and in
882 // the other direction
883 iconv_t m2w,
884 w2m;
885
886 private:
887 // the name (for iconv_open()) of a wide char charset -- if none is
888 // available on this machine, it will remain NULL
889 static const char *ms_wcCharsetName;
890
891 // true if the wide char encoding we use (i.e. ms_wcCharsetName) has
892 // different endian-ness than the native one
893 static bool ms_wcNeedsSwap;
894 };
895
896 const char *wxMBConv_iconv::ms_wcCharsetName = NULL;
897 bool wxMBConv_iconv::ms_wcNeedsSwap = false;
898
899 wxMBConv_iconv::wxMBConv_iconv(const wxChar *name)
900 {
901 // Do it the hard way
902 char cname[100];
903 for (size_t i = 0; i < wxStrlen(name)+1; i++)
904 cname[i] = (char) name[i];
905
906 // check for charset that represents wchar_t:
907 if (ms_wcCharsetName == NULL)
908 {
909 ms_wcNeedsSwap = false;
910
911 // try charset with explicit bytesex info (e.g. "UCS-4LE"):
912 ms_wcCharsetName = WC_NAME_BEST;
913 m2w = iconv_open(ms_wcCharsetName, cname);
914
915 if (m2w == (iconv_t)-1)
916 {
917 // try charset w/o bytesex info (e.g. "UCS4")
918 // and check for bytesex ourselves:
919 ms_wcCharsetName = WC_NAME;
920 m2w = iconv_open(ms_wcCharsetName, cname);
921
922 // last bet, try if it knows WCHAR_T pseudo-charset
923 if (m2w == (iconv_t)-1)
924 {
925 ms_wcCharsetName = "WCHAR_T";
926 m2w = iconv_open(ms_wcCharsetName, cname);
927 }
928
929 if (m2w != (iconv_t)-1)
930 {
931 char buf[2], *bufPtr;
932 wchar_t wbuf[2], *wbufPtr;
933 size_t insz, outsz;
934 size_t res;
935
936 buf[0] = 'A';
937 buf[1] = 0;
938 wbuf[0] = 0;
939 insz = 2;
940 outsz = SIZEOF_WCHAR_T * 2;
941 wbufPtr = wbuf;
942 bufPtr = buf;
943
944 res = iconv(m2w, ICONV_CHAR_CAST(&bufPtr), &insz,
945 (char**)&wbufPtr, &outsz);
946
947 if (ICONV_FAILED(res, insz))
948 {
949 ms_wcCharsetName = NULL;
950 wxLogLastError(wxT("iconv"));
951 wxLogError(_("Conversion to charset '%s' doesn't work."), name);
952 }
953 else
954 {
955 ms_wcNeedsSwap = wbuf[0] != (wchar_t)buf[0];
956 }
957 }
958 else
959 {
960 ms_wcCharsetName = NULL;
961
962 // VS: we must not output an error here, since wxWidgets will safely
963 // fall back to using wxEncodingConverter.
964 wxLogTrace(wxT("strconv"), wxT("Impossible to convert to/from charset '%s' with iconv, falling back to wxEncodingConverter."), name);
965 //wxLogError(
966 }
967 }
968 wxLogTrace(wxT("strconv"), wxT("wchar_t charset is '%s', needs swap: %i"), ms_wcCharsetName, ms_wcNeedsSwap);
969 }
970 else // we already have ms_wcCharsetName
971 {
972 m2w = iconv_open(ms_wcCharsetName, cname);
973 }
974
975 // NB: don't ever pass NULL to iconv_open(), it may crash!
976 if ( ms_wcCharsetName )
977 {
978 w2m = iconv_open( cname, ms_wcCharsetName);
979 }
980 else
981 {
982 w2m = (iconv_t)-1;
983 }
984 }
985
986 wxMBConv_iconv::~wxMBConv_iconv()
987 {
988 if ( m2w != (iconv_t)-1 )
989 iconv_close(m2w);
990 if ( w2m != (iconv_t)-1 )
991 iconv_close(w2m);
992 }
993
994 size_t wxMBConv_iconv::MB2WC(wchar_t *buf, const char *psz, size_t n) const
995 {
996 size_t inbuf = strlen(psz);
997 size_t outbuf = n * SIZEOF_WCHAR_T;
998 size_t res, cres;
999 // VS: Use these instead of psz, buf because iconv() modifies its arguments:
1000 wchar_t *bufPtr = buf;
1001 const char *pszPtr = psz;
1002
1003 if (buf)
1004 {
1005 // have destination buffer, convert there
1006 cres = iconv(m2w,
1007 ICONV_CHAR_CAST(&pszPtr), &inbuf,
1008 (char**)&bufPtr, &outbuf);
1009 res = n - (outbuf / SIZEOF_WCHAR_T);
1010
1011 if (ms_wcNeedsSwap)
1012 {
1013 // convert to native endianness
1014 WC_BSWAP(buf /* _not_ bufPtr */, res)
1015 }
1016
1017 // NB: iconv was given only strlen(psz) characters on input, and so
1018 // it couldn't convert the trailing zero. Let's do it ourselves
1019 // if there's some room left for it in the output buffer.
1020 if (res < n)
1021 buf[res] = 0;
1022 }
1023 else
1024 {
1025 // no destination buffer... convert using temp buffer
1026 // to calculate destination buffer requirement
1027 wchar_t tbuf[8];
1028 res = 0;
1029 do {
1030 bufPtr = tbuf;
1031 outbuf = 8*SIZEOF_WCHAR_T;
1032
1033 cres = iconv(m2w,
1034 ICONV_CHAR_CAST(&pszPtr), &inbuf,
1035 (char**)&bufPtr, &outbuf );
1036
1037 res += 8-(outbuf/SIZEOF_WCHAR_T);
1038 } while ((cres==(size_t)-1) && (errno==E2BIG));
1039 }
1040
1041 if (ICONV_FAILED(cres, inbuf))
1042 {
1043 //VS: it is ok if iconv fails, hence trace only
1044 wxLogTrace(wxT("strconv"), wxT("iconv failed: %s"), wxSysErrorMsg(wxSysErrorCode()));
1045 return (size_t)-1;
1046 }
1047
1048 return res;
1049 }
1050
1051 size_t wxMBConv_iconv::WC2MB(char *buf, const wchar_t *psz, size_t n) const
1052 {
1053 size_t inbuf = wxWcslen(psz) * SIZEOF_WCHAR_T;
1054 size_t outbuf = n;
1055 size_t res, cres;
1056
1057 wchar_t *tmpbuf = 0;
1058
1059 if (ms_wcNeedsSwap)
1060 {
1061 // need to copy to temp buffer to switch endianness
1062 // this absolutely doesn't rock!
1063 // (no, doing WC_BSWAP twice on the original buffer won't help, as it
1064 // could be in read-only memory, or be accessed in some other thread)
1065 tmpbuf=(wchar_t*)malloc((inbuf+1)*SIZEOF_WCHAR_T);
1066 memcpy(tmpbuf,psz,(inbuf+1)*SIZEOF_WCHAR_T);
1067 WC_BSWAP(tmpbuf, inbuf)
1068 psz=tmpbuf;
1069 }
1070
1071 if (buf)
1072 {
1073 // have destination buffer, convert there
1074 cres = iconv( w2m, ICONV_CHAR_CAST(&psz), &inbuf, &buf, &outbuf );
1075
1076 res = n-outbuf;
1077
1078 // NB: iconv was given only wcslen(psz) characters on input, and so
1079 // it couldn't convert the trailing zero. Let's do it ourselves
1080 // if there's some room left for it in the output buffer.
1081 if (res < n)
1082 buf[0] = 0;
1083 }
1084 else
1085 {
1086 // no destination buffer... convert using temp buffer
1087 // to calculate destination buffer requirement
1088 char tbuf[16];
1089 res = 0;
1090 do {
1091 buf = tbuf; outbuf = 16;
1092
1093 cres = iconv( w2m, ICONV_CHAR_CAST(&psz), &inbuf, &buf, &outbuf );
1094
1095 res += 16 - outbuf;
1096 } while ((cres==(size_t)-1) && (errno==E2BIG));
1097 }
1098
1099 if (ms_wcNeedsSwap)
1100 {
1101 free(tmpbuf);
1102 }
1103
1104 if (ICONV_FAILED(cres, inbuf))
1105 {
1106 //VS: it is ok if iconv fails, hence trace only
1107 wxLogTrace(wxT("strconv"), wxT("iconv failed: %s"), wxSysErrorMsg(wxSysErrorCode()));
1108 return (size_t)-1;
1109 }
1110
1111 return res;
1112 }
1113
1114 #endif // HAVE_ICONV
1115
1116
1117 // ============================================================================
1118 // Win32 conversion classes
1119 // ============================================================================
1120
1121 #ifdef wxHAVE_WIN32_MB2WC
1122
1123 // from utils.cpp
1124 #if wxUSE_FONTMAP
1125 extern WXDLLIMPEXP_BASE long wxCharsetToCodepage(const wxChar *charset);
1126 extern WXDLLIMPEXP_BASE long wxEncodingToCodepage(wxFontEncoding encoding);
1127 #endif
1128
1129 class wxMBConv_win32 : public wxMBConv
1130 {
1131 public:
1132 wxMBConv_win32()
1133 {
1134 m_CodePage = CP_ACP;
1135 }
1136
1137 #if wxUSE_FONTMAP
1138 wxMBConv_win32(const wxChar* name)
1139 {
1140 m_CodePage = wxCharsetToCodepage(name);
1141 }
1142
1143 wxMBConv_win32(wxFontEncoding encoding)
1144 {
1145 m_CodePage = wxEncodingToCodepage(encoding);
1146 }
1147 #endif
1148
1149 size_t MB2WC(wchar_t *buf, const char *psz, size_t n) const
1150 {
1151 // note that we have to use MB_ERR_INVALID_CHARS flag as it without it
1152 // the behaviour is not compatible with the Unix version (using iconv)
1153 // and break the library itself, e.g. wxTextInputStream::NextChar()
1154 // wouldn't work if reading an incomplete MB char didn't result in an
1155 // error
1156 const size_t len = ::MultiByteToWideChar
1157 (
1158 m_CodePage, // code page
1159 MB_ERR_INVALID_CHARS, // flags: fall on error
1160 psz, // input string
1161 -1, // its length (NUL-terminated)
1162 buf, // output string
1163 buf ? n : 0 // size of output buffer
1164 );
1165
1166 // note that it returns count of written chars for buf != NULL and size
1167 // of the needed buffer for buf == NULL so in either case the length of
1168 // the string (which never includes the terminating NUL) is one less
1169 return len ? len - 1 : (size_t)-1;
1170 }
1171
1172 size_t WC2MB(char *buf, const wchar_t *pwz, size_t n) const
1173 {
1174 /*
1175 we have a problem here: by default, WideCharToMultiByte() may
1176 replace characters unrepresentable in the target code page with bad
1177 quality approximations such as turning "1/2" symbol (U+00BD) into
1178 "1" for the code pages which don't have it and we, obviously, want
1179 to avoid this at any price
1180
1181 the trouble is that this function does it _silently_, i.e. it won't
1182 even tell us whether it did or not... Win98/2000 and higher provide
1183 WC_NO_BEST_FIT_CHARS but it doesn't work for the older systems and
1184 we have to resort to a round trip, i.e. check that converting back
1185 results in the same string -- this is, of course, expensive but
1186 otherwise we simply can't be sure to not garble the data.
1187 */
1188
1189 // determine if we can rely on WC_NO_BEST_FIT_CHARS: according to MSDN
1190 // it doesn't work with CJK encodings (which we test for rather roughly
1191 // here...) nor with UTF-7/8 nor, of course, with Windows versions not
1192 // supporting it
1193 BOOL usedDef wxDUMMY_INITIALIZE(false);
1194 BOOL *pUsedDef;
1195 int flags;
1196 if ( CanUseNoBestFit() && m_CodePage < 50000 )
1197 {
1198 // it's our lucky day
1199 flags = WC_NO_BEST_FIT_CHARS;
1200 pUsedDef = &usedDef;
1201 }
1202 else // old system or unsupported encoding
1203 {
1204 flags = 0;
1205 pUsedDef = NULL;
1206 }
1207
1208 const size_t len = ::WideCharToMultiByte
1209 (
1210 m_CodePage, // code page
1211 flags, // either none or no best fit
1212 pwz, // input string
1213 -1, // it is (wide) NUL-terminated
1214 buf, // output buffer
1215 buf ? n : 0, // and its size
1216 NULL, // default "replacement" char
1217 pUsedDef // [out] was it used?
1218 );
1219
1220 if ( !len )
1221 {
1222 // function totally failed
1223 return (size_t)-1;
1224 }
1225
1226 // if we were really converting, check if we succeeded
1227 if ( buf )
1228 {
1229 if ( flags )
1230 {
1231 // check if the conversion failed, i.e. if any replacements
1232 // were done
1233 if ( usedDef )
1234 return (size_t)-1;
1235 }
1236 else // we must resort to double tripping...
1237 {
1238 wxWCharBuffer wcBuf(n);
1239 if ( MB2WC(wcBuf.data(), buf, n) == (size_t)-1 ||
1240 wcscmp(wcBuf, pwz) != 0 )
1241 {
1242 // we didn't obtain the same thing we started from, hence
1243 // the conversion was lossy and we consider that it failed
1244 return (size_t)-1;
1245 }
1246 }
1247 }
1248
1249 // see the comment above for the reason of "len - 1"
1250 return len - 1;
1251 }
1252
1253 bool IsOk() const { return m_CodePage != -1; }
1254
1255 private:
1256 static bool CanUseNoBestFit()
1257 {
1258 static int s_isWin98Or2k = -1;
1259
1260 if ( s_isWin98Or2k == -1 )
1261 {
1262 int verMaj, verMin;
1263 switch ( wxGetOsVersion(&verMaj, &verMin) )
1264 {
1265 case wxWIN95:
1266 s_isWin98Or2k = verMaj >= 4 && verMin >= 10;
1267 break;
1268
1269 case wxWINDOWS_NT:
1270 s_isWin98Or2k = verMaj >= 5;
1271 break;
1272
1273 default:
1274 // unknown, be conseravtive by default
1275 s_isWin98Or2k = 0;
1276 }
1277
1278 wxASSERT_MSG( s_isWin98Or2k != -1, _T("should be set above") );
1279 }
1280
1281 return s_isWin98Or2k == 1;
1282 }
1283
1284 long m_CodePage;
1285 };
1286
1287 #endif // wxHAVE_WIN32_MB2WC
1288
1289 // ============================================================================
1290 // Cocoa conversion classes
1291 // ============================================================================
1292
1293 #if defined(__WXCOCOA__)
1294
1295 // RN: There is no UTF-32 support in either Core Foundation or
1296 // Cocoa. Strangely enough, internally Core Foundation uses
1297 // UTF 32 internally quite a bit - its just not public (yet).
1298
1299 #include <CoreFoundation/CFString.h>
1300 #include <CoreFoundation/CFStringEncodingExt.h>
1301
1302 CFStringEncoding wxCFStringEncFromFontEnc(wxFontEncoding encoding)
1303 {
1304 CFStringEncoding enc = 0 ;
1305 if ( encoding == wxFONTENCODING_DEFAULT )
1306 {
1307 #if wxUSE_GUI
1308 encoding = wxFont::GetDefaultEncoding() ;
1309 #else
1310 encoding = wxLocale::GetSystemEncoding() ;
1311 #endif
1312 }
1313 else switch( encoding)
1314 {
1315 case wxFONTENCODING_ISO8859_1 :
1316 enc = kCFStringEncodingISOLatin1 ;
1317 break ;
1318 case wxFONTENCODING_ISO8859_2 :
1319 enc = kCFStringEncodingISOLatin2;
1320 break ;
1321 case wxFONTENCODING_ISO8859_3 :
1322 enc = kCFStringEncodingISOLatin3 ;
1323 break ;
1324 case wxFONTENCODING_ISO8859_4 :
1325 enc = kCFStringEncodingISOLatin4;
1326 break ;
1327 case wxFONTENCODING_ISO8859_5 :
1328 enc = kCFStringEncodingISOLatinCyrillic;
1329 break ;
1330 case wxFONTENCODING_ISO8859_6 :
1331 enc = kCFStringEncodingISOLatinArabic;
1332 break ;
1333 case wxFONTENCODING_ISO8859_7 :
1334 enc = kCFStringEncodingISOLatinGreek;
1335 break ;
1336 case wxFONTENCODING_ISO8859_8 :
1337 enc = kCFStringEncodingISOLatinHebrew;
1338 break ;
1339 case wxFONTENCODING_ISO8859_9 :
1340 enc = kCFStringEncodingISOLatin5;
1341 break ;
1342 case wxFONTENCODING_ISO8859_10 :
1343 enc = kCFStringEncodingISOLatin6;
1344 break ;
1345 case wxFONTENCODING_ISO8859_11 :
1346 enc = kCFStringEncodingISOLatinThai;
1347 break ;
1348 case wxFONTENCODING_ISO8859_13 :
1349 enc = kCFStringEncodingISOLatin7;
1350 break ;
1351 case wxFONTENCODING_ISO8859_14 :
1352 enc = kCFStringEncodingISOLatin8;
1353 break ;
1354 case wxFONTENCODING_ISO8859_15 :
1355 enc = kCFStringEncodingISOLatin9;
1356 break ;
1357
1358 case wxFONTENCODING_KOI8 :
1359 enc = kCFStringEncodingKOI8_R;
1360 break ;
1361 case wxFONTENCODING_ALTERNATIVE : // MS-DOS CP866
1362 enc = kCFStringEncodingDOSRussian;
1363 break ;
1364
1365 // case wxFONTENCODING_BULGARIAN :
1366 // enc = ;
1367 // break ;
1368
1369 case wxFONTENCODING_CP437 :
1370 enc =kCFStringEncodingDOSLatinUS ;
1371 break ;
1372 case wxFONTENCODING_CP850 :
1373 enc = kCFStringEncodingDOSLatin1;
1374 break ;
1375 case wxFONTENCODING_CP852 :
1376 enc = kCFStringEncodingDOSLatin2;
1377 break ;
1378 case wxFONTENCODING_CP855 :
1379 enc = kCFStringEncodingDOSCyrillic;
1380 break ;
1381 case wxFONTENCODING_CP866 :
1382 enc =kCFStringEncodingDOSRussian ;
1383 break ;
1384 case wxFONTENCODING_CP874 :
1385 enc = kCFStringEncodingDOSThai;
1386 break ;
1387 case wxFONTENCODING_CP932 :
1388 enc = kCFStringEncodingDOSJapanese;
1389 break ;
1390 case wxFONTENCODING_CP936 :
1391 enc =kCFStringEncodingDOSChineseSimplif ;
1392 break ;
1393 case wxFONTENCODING_CP949 :
1394 enc = kCFStringEncodingDOSKorean;
1395 break ;
1396 case wxFONTENCODING_CP950 :
1397 enc = kCFStringEncodingDOSChineseTrad;
1398 break ;
1399
1400 case wxFONTENCODING_CP1250 :
1401 enc = kCFStringEncodingWindowsLatin2;
1402 break ;
1403 case wxFONTENCODING_CP1251 :
1404 enc =kCFStringEncodingWindowsCyrillic ;
1405 break ;
1406 case wxFONTENCODING_CP1252 :
1407 enc =kCFStringEncodingWindowsLatin1 ;
1408 break ;
1409 case wxFONTENCODING_CP1253 :
1410 enc = kCFStringEncodingWindowsGreek;
1411 break ;
1412 case wxFONTENCODING_CP1254 :
1413 enc = kCFStringEncodingWindowsLatin5;
1414 break ;
1415 case wxFONTENCODING_CP1255 :
1416 enc =kCFStringEncodingWindowsHebrew ;
1417 break ;
1418 case wxFONTENCODING_CP1256 :
1419 enc =kCFStringEncodingWindowsArabic ;
1420 break ;
1421 case wxFONTENCODING_CP1257 :
1422 enc = kCFStringEncodingWindowsBalticRim;
1423 break ;
1424 case wxFONTENCODING_UTF7 :
1425 enc = kCFStringEncodingNonLossyASCII ;
1426 break ;
1427 case wxFONTENCODING_UTF8 :
1428 enc = kCFStringEncodingUTF8 ;
1429 break ;
1430 case wxFONTENCODING_EUC_JP :
1431 enc = kCFStringEncodingEUC_JP;
1432 break ;
1433 case wxFONTENCODING_UTF16 :
1434 enc = kCFStringEncodingUnicode ;
1435 break ;
1436 case wxFONTENCODING_MACROMAN :
1437 enc = kCFStringEncodingMacRoman ;
1438 break ;
1439 case wxFONTENCODING_MACJAPANESE :
1440 enc = kCFStringEncodingMacJapanese ;
1441 break ;
1442 case wxFONTENCODING_MACCHINESETRAD :
1443 enc = kCFStringEncodingMacChineseTrad ;
1444 break ;
1445 case wxFONTENCODING_MACKOREAN :
1446 enc = kCFStringEncodingMacKorean ;
1447 break ;
1448 case wxFONTENCODING_MACARABIC :
1449 enc = kCFStringEncodingMacArabic ;
1450 break ;
1451 case wxFONTENCODING_MACHEBREW :
1452 enc = kCFStringEncodingMacHebrew ;
1453 break ;
1454 case wxFONTENCODING_MACGREEK :
1455 enc = kCFStringEncodingMacGreek ;
1456 break ;
1457 case wxFONTENCODING_MACCYRILLIC :
1458 enc = kCFStringEncodingMacCyrillic ;
1459 break ;
1460 case wxFONTENCODING_MACDEVANAGARI :
1461 enc = kCFStringEncodingMacDevanagari ;
1462 break ;
1463 case wxFONTENCODING_MACGURMUKHI :
1464 enc = kCFStringEncodingMacGurmukhi ;
1465 break ;
1466 case wxFONTENCODING_MACGUJARATI :
1467 enc = kCFStringEncodingMacGujarati ;
1468 break ;
1469 case wxFONTENCODING_MACORIYA :
1470 enc = kCFStringEncodingMacOriya ;
1471 break ;
1472 case wxFONTENCODING_MACBENGALI :
1473 enc = kCFStringEncodingMacBengali ;
1474 break ;
1475 case wxFONTENCODING_MACTAMIL :
1476 enc = kCFStringEncodingMacTamil ;
1477 break ;
1478 case wxFONTENCODING_MACTELUGU :
1479 enc = kCFStringEncodingMacTelugu ;
1480 break ;
1481 case wxFONTENCODING_MACKANNADA :
1482 enc = kCFStringEncodingMacKannada ;
1483 break ;
1484 case wxFONTENCODING_MACMALAJALAM :
1485 enc = kCFStringEncodingMacMalayalam ;
1486 break ;
1487 case wxFONTENCODING_MACSINHALESE :
1488 enc = kCFStringEncodingMacSinhalese ;
1489 break ;
1490 case wxFONTENCODING_MACBURMESE :
1491 enc = kCFStringEncodingMacBurmese ;
1492 break ;
1493 case wxFONTENCODING_MACKHMER :
1494 enc = kCFStringEncodingMacKhmer ;
1495 break ;
1496 case wxFONTENCODING_MACTHAI :
1497 enc = kCFStringEncodingMacThai ;
1498 break ;
1499 case wxFONTENCODING_MACLAOTIAN :
1500 enc = kCFStringEncodingMacLaotian ;
1501 break ;
1502 case wxFONTENCODING_MACGEORGIAN :
1503 enc = kCFStringEncodingMacGeorgian ;
1504 break ;
1505 case wxFONTENCODING_MACARMENIAN :
1506 enc = kCFStringEncodingMacArmenian ;
1507 break ;
1508 case wxFONTENCODING_MACCHINESESIMP :
1509 enc = kCFStringEncodingMacChineseSimp ;
1510 break ;
1511 case wxFONTENCODING_MACTIBETAN :
1512 enc = kCFStringEncodingMacTibetan ;
1513 break ;
1514 case wxFONTENCODING_MACMONGOLIAN :
1515 enc = kCFStringEncodingMacMongolian ;
1516 break ;
1517 case wxFONTENCODING_MACETHIOPIC :
1518 enc = kCFStringEncodingMacEthiopic ;
1519 break ;
1520 case wxFONTENCODING_MACCENTRALEUR :
1521 enc = kCFStringEncodingMacCentralEurRoman ;
1522 break ;
1523 case wxFONTENCODING_MACVIATNAMESE :
1524 enc = kCFStringEncodingMacVietnamese ;
1525 break ;
1526 case wxFONTENCODING_MACARABICEXT :
1527 enc = kCFStringEncodingMacExtArabic ;
1528 break ;
1529 case wxFONTENCODING_MACSYMBOL :
1530 enc = kCFStringEncodingMacSymbol ;
1531 break ;
1532 case wxFONTENCODING_MACDINGBATS :
1533 enc = kCFStringEncodingMacDingbats ;
1534 break ;
1535 case wxFONTENCODING_MACTURKISH :
1536 enc = kCFStringEncodingMacTurkish ;
1537 break ;
1538 case wxFONTENCODING_MACCROATIAN :
1539 enc = kCFStringEncodingMacCroatian ;
1540 break ;
1541 case wxFONTENCODING_MACICELANDIC :
1542 enc = kCFStringEncodingMacIcelandic ;
1543 break ;
1544 case wxFONTENCODING_MACROMANIAN :
1545 enc = kCFStringEncodingMacRomanian ;
1546 break ;
1547 case wxFONTENCODING_MACCELTIC :
1548 enc = kCFStringEncodingMacCeltic ;
1549 break ;
1550 case wxFONTENCODING_MACGAELIC :
1551 enc = kCFStringEncodingMacGaelic ;
1552 break ;
1553 // case wxFONTENCODING_MACKEYBOARD :
1554 // enc = kCFStringEncodingMacKeyboardGlyphs ;
1555 // break ;
1556 default :
1557 // because gcc is picky
1558 break ;
1559 } ;
1560 return enc ;
1561 }
1562
1563 wxFontEncoding wxFontEncFromCFStringEnc(CFStringEncoding encoding)
1564 {
1565 wxFontEncoding enc = wxFONTENCODING_DEFAULT ;
1566
1567 switch( encoding)
1568 {
1569 case kCFStringEncodingISOLatin1 :
1570 enc = wxFONTENCODING_ISO8859_1 ;
1571 break ;
1572 case kCFStringEncodingISOLatin2 :
1573 enc = wxFONTENCODING_ISO8859_2;
1574 break ;
1575 case kCFStringEncodingISOLatin3 :
1576 enc = wxFONTENCODING_ISO8859_3 ;
1577 break ;
1578 case kCFStringEncodingISOLatin4 :
1579 enc = wxFONTENCODING_ISO8859_4;
1580 break ;
1581 case kCFStringEncodingISOLatinCyrillic :
1582 enc = wxFONTENCODING_ISO8859_5;
1583 break ;
1584 case kCFStringEncodingISOLatinArabic :
1585 enc = wxFONTENCODING_ISO8859_6;
1586 break ;
1587 case kCFStringEncodingISOLatinGreek :
1588 enc = wxFONTENCODING_ISO8859_7;
1589 break ;
1590 case kCFStringEncodingISOLatinHebrew :
1591 enc = wxFONTENCODING_ISO8859_8;
1592 break ;
1593 case kCFStringEncodingISOLatin5 :
1594 enc = wxFONTENCODING_ISO8859_9;
1595 break ;
1596 case kCFStringEncodingISOLatin6 :
1597 enc = wxFONTENCODING_ISO8859_10;
1598 break ;
1599 case kCFStringEncodingISOLatin7 :
1600 enc = wxFONTENCODING_ISO8859_13;
1601 break ;
1602 case kCFStringEncodingISOLatin8 :
1603 enc = wxFONTENCODING_ISO8859_14;
1604 break ;
1605 case kCFStringEncodingISOLatin9 :
1606 enc =wxFONTENCODING_ISO8859_15 ;
1607 break ;
1608
1609 case kCFStringEncodingKOI8_R :
1610 enc = wxFONTENCODING_KOI8;
1611 break ;
1612
1613 // case :
1614 // enc = wxFONTENCODING_BULGARIAN;
1615 // break ;
1616
1617 case kCFStringEncodingDOSLatinUS :
1618 enc = wxFONTENCODING_CP437;
1619 break ;
1620 case kCFStringEncodingDOSLatin1 :
1621 enc = wxFONTENCODING_CP850;
1622 break ;
1623 case kCFStringEncodingDOSLatin2 :
1624 enc =wxFONTENCODING_CP852 ;
1625 break ;
1626 case kCFStringEncodingDOSCyrillic :
1627 enc = wxFONTENCODING_CP855;
1628 break ;
1629 case kCFStringEncodingDOSRussian :
1630 enc = wxFONTENCODING_CP866;
1631 break ;
1632 case kCFStringEncodingDOSThai :
1633 enc =wxFONTENCODING_CP874 ;
1634 break ;
1635 case kCFStringEncodingDOSJapanese :
1636 enc = wxFONTENCODING_CP932;
1637 break ;
1638 case kCFStringEncodingDOSChineseSimplif :
1639 enc = wxFONTENCODING_CP936;
1640 break ;
1641 case kCFStringEncodingDOSKorean :
1642 enc = wxFONTENCODING_CP949;
1643 break ;
1644 case kCFStringEncodingDOSChineseTrad :
1645 enc = wxFONTENCODING_CP950;
1646 break ;
1647
1648 case kCFStringEncodingWindowsLatin2 :
1649 enc = wxFONTENCODING_CP1250;
1650 break ;
1651 case kCFStringEncodingWindowsCyrillic :
1652 enc = wxFONTENCODING_CP1251;
1653 break ;
1654 case kCFStringEncodingWindowsLatin1 :
1655 enc = wxFONTENCODING_CP1252;
1656 break ;
1657 case kCFStringEncodingWindowsGreek :
1658 enc = wxFONTENCODING_CP1253;
1659 break ;
1660 case kCFStringEncodingWindowsLatin5 :
1661 enc = wxFONTENCODING_CP1254;
1662 break ;
1663 case kCFStringEncodingWindowsHebrew :
1664 enc = wxFONTENCODING_CP1255;
1665 break ;
1666 case kCFStringEncodingWindowsArabic :
1667 enc = wxFONTENCODING_CP1256;
1668 break ;
1669 case kCFStringEncodingWindowsBalticRim :
1670 enc =wxFONTENCODING_CP1257 ;
1671 break ;
1672 case kCFStringEncodingEUC_JP :
1673 enc = wxFONTENCODING_EUC_JP;
1674 break ;
1675 case kCFStringEncodingUnicode :
1676 enc = wxFONTENCODING_UTF16;
1677 break;
1678 case kCFStringEncodingMacRoman :
1679 enc = wxFONTENCODING_MACROMAN ;
1680 break ;
1681 case kCFStringEncodingMacJapanese :
1682 enc = wxFONTENCODING_MACJAPANESE ;
1683 break ;
1684 case kCFStringEncodingMacChineseTrad :
1685 enc = wxFONTENCODING_MACCHINESETRAD ;
1686 break ;
1687 case kCFStringEncodingMacKorean :
1688 enc = wxFONTENCODING_MACKOREAN ;
1689 break ;
1690 case kCFStringEncodingMacArabic :
1691 enc =wxFONTENCODING_MACARABIC ;
1692 break ;
1693 case kCFStringEncodingMacHebrew :
1694 enc = wxFONTENCODING_MACHEBREW ;
1695 break ;
1696 case kCFStringEncodingMacGreek :
1697 enc = wxFONTENCODING_MACGREEK ;
1698 break ;
1699 case kCFStringEncodingMacCyrillic :
1700 enc = wxFONTENCODING_MACCYRILLIC ;
1701 break ;
1702 case kCFStringEncodingMacDevanagari :
1703 enc = wxFONTENCODING_MACDEVANAGARI ;
1704 break ;
1705 case kCFStringEncodingMacGurmukhi :
1706 enc = wxFONTENCODING_MACGURMUKHI ;
1707 break ;
1708 case kCFStringEncodingMacGujarati :
1709 enc = wxFONTENCODING_MACGUJARATI ;
1710 break ;
1711 case kCFStringEncodingMacOriya :
1712 enc =wxFONTENCODING_MACORIYA ;
1713 break ;
1714 case kCFStringEncodingMacBengali :
1715 enc =wxFONTENCODING_MACBENGALI ;
1716 break ;
1717 case kCFStringEncodingMacTamil :
1718 enc = wxFONTENCODING_MACTAMIL ;
1719 break ;
1720 case kCFStringEncodingMacTelugu :
1721 enc = wxFONTENCODING_MACTELUGU ;
1722 break ;
1723 case kCFStringEncodingMacKannada :
1724 enc = wxFONTENCODING_MACKANNADA ;
1725 break ;
1726 case kCFStringEncodingMacMalayalam :
1727 enc = wxFONTENCODING_MACMALAJALAM ;
1728 break ;
1729 case kCFStringEncodingMacSinhalese :
1730 enc = wxFONTENCODING_MACSINHALESE ;
1731 break ;
1732 case kCFStringEncodingMacBurmese :
1733 enc = wxFONTENCODING_MACBURMESE ;
1734 break ;
1735 case kCFStringEncodingMacKhmer :
1736 enc = wxFONTENCODING_MACKHMER ;
1737 break ;
1738 case kCFStringEncodingMacThai :
1739 enc = wxFONTENCODING_MACTHAI ;
1740 break ;
1741 case kCFStringEncodingMacLaotian :
1742 enc = wxFONTENCODING_MACLAOTIAN ;
1743 break ;
1744 case kCFStringEncodingMacGeorgian :
1745 enc = wxFONTENCODING_MACGEORGIAN ;
1746 break ;
1747 case kCFStringEncodingMacArmenian :
1748 enc = wxFONTENCODING_MACARMENIAN ;
1749 break ;
1750 case kCFStringEncodingMacChineseSimp :
1751 enc = wxFONTENCODING_MACCHINESESIMP ;
1752 break ;
1753 case kCFStringEncodingMacTibetan :
1754 enc = wxFONTENCODING_MACTIBETAN ;
1755 break ;
1756 case kCFStringEncodingMacMongolian :
1757 enc = wxFONTENCODING_MACMONGOLIAN ;
1758 break ;
1759 case kCFStringEncodingMacEthiopic :
1760 enc = wxFONTENCODING_MACETHIOPIC ;
1761 break ;
1762 case kCFStringEncodingMacCentralEurRoman:
1763 enc = wxFONTENCODING_MACCENTRALEUR ;
1764 break ;
1765 case kCFStringEncodingMacVietnamese:
1766 enc = wxFONTENCODING_MACVIATNAMESE ;
1767 break ;
1768 case kCFStringEncodingMacExtArabic :
1769 enc = wxFONTENCODING_MACARABICEXT ;
1770 break ;
1771 case kCFStringEncodingMacSymbol :
1772 enc = wxFONTENCODING_MACSYMBOL ;
1773 break ;
1774 case kCFStringEncodingMacDingbats :
1775 enc = wxFONTENCODING_MACDINGBATS ;
1776 break ;
1777 case kCFStringEncodingMacTurkish :
1778 enc = wxFONTENCODING_MACTURKISH ;
1779 break ;
1780 case kCFStringEncodingMacCroatian :
1781 enc = wxFONTENCODING_MACCROATIAN ;
1782 break ;
1783 case kCFStringEncodingMacIcelandic :
1784 enc = wxFONTENCODING_MACICELANDIC ;
1785 break ;
1786 case kCFStringEncodingMacRomanian :
1787 enc = wxFONTENCODING_MACROMANIAN ;
1788 break ;
1789 case kCFStringEncodingMacCeltic :
1790 enc = wxFONTENCODING_MACCELTIC ;
1791 break ;
1792 case kCFStringEncodingMacGaelic :
1793 enc = wxFONTENCODING_MACGAELIC ;
1794 break ;
1795 // case kCFStringEncodingMacKeyboardGlyphs :
1796 // enc = wxFONTENCODING_MACKEYBOARD ;
1797 // break ;
1798 } ;
1799 return enc ;
1800 }
1801
1802 class wxMBConv_cocoa : public wxMBConv
1803 {
1804 public:
1805 wxMBConv_cocoa()
1806 {
1807 Init(CFStringGetSystemEncoding()) ;
1808 }
1809
1810 wxMBConv_cocoa(const wxChar* name)
1811 {
1812 Init( wxCFStringEncFromFontEnc(wxFontMapper::Get()->CharsetToEncoding(name, false) ) ) ;
1813 }
1814
1815 wxMBConv_cocoa(wxFontEncoding encoding)
1816 {
1817 Init( wxCFStringEncFromFontEnc(encoding) );
1818 }
1819
1820 ~wxMBConv_cocoa()
1821 {
1822 }
1823
1824 void Init( CFStringEncoding encoding)
1825 {
1826 m_char_encoding = encoding ;
1827 m_unicode_encoding = kCFStringEncodingUnicode;
1828 }
1829
1830 size_t MB2WC(wchar_t * szOut, const char * szUnConv, size_t nOutSize) const
1831 {
1832 wxASSERT(szUnConv);
1833
1834 size_t nBufSize = strlen(szUnConv) + 1;
1835 size_t nRealOutSize;
1836
1837 UniChar* szUniCharBuffer = (UniChar*) szOut;
1838 wchar_t* szConvBuffer = szOut;
1839
1840 if (szConvBuffer == NULL && nOutSize != 0)
1841 {
1842 szConvBuffer = new wchar_t[nOutSize] ;
1843 }
1844
1845 #if SIZEOF_WCHAR_T == 4
1846 szUniCharBuffer = new UniChar[nOutSize];
1847 #endif
1848
1849 CFDataRef theData = CFDataCreateWithBytesNoCopy (
1850 NULL, //allocator
1851 (const UInt8*)szUnConv,
1852 nBufSize - 1,
1853 NULL //deallocator
1854 );
1855
1856 wxASSERT(theData);
1857
1858 CFStringRef theString = CFStringCreateFromExternalRepresentation (
1859 NULL,
1860 theData,
1861 m_char_encoding
1862 );
1863
1864 wxASSERT(theString);
1865
1866 if (nOutSize == 0)
1867 {
1868 nRealOutSize = CFStringGetLength(theString) + 1;
1869 CFRelease(theString);
1870 return nRealOutSize - 1;
1871 }
1872
1873 CFRange theRange = { 0, CFStringGetLength(theString) };
1874
1875 CFStringGetCharacters(theString, theRange, szUniCharBuffer);
1876
1877
1878 nRealOutSize = (CFStringGetLength(theString) + 1);
1879
1880 CFRelease(theString);
1881
1882 szUniCharBuffer[nRealOutSize-1] = '\0' ;
1883
1884 #if SIZEOF_WCHAR_T == 4
1885 wxMBConvUTF16 converter ;
1886 converter.MB2WC(szConvBuffer , (const char*)szUniCharBuffer , nRealOutSize ) ;
1887 delete[] szUniCharBuffer;
1888 #endif
1889 if ( szOut == NULL )
1890 delete [] szConvBuffer;
1891
1892 return nRealOutSize ;
1893 }
1894
1895 size_t WC2MB(char *szOut, const wchar_t *szUnConv, size_t nOutSize) const
1896 {
1897 size_t nBufSize = wxWcslen(szUnConv) + 1;
1898 size_t nRealOutSize;
1899 char* szBuffer = szOut;
1900 UniChar* szUniBuffer = (UniChar*) szUnConv;
1901
1902 if (szOut == NULL)
1903 {
1904 // worst case
1905 nRealOutSize = ((nBufSize - 1) << 2)+1 ;
1906 szBuffer = new char[ nRealOutSize ] ;
1907 }
1908 else
1909 nRealOutSize = nOutSize;
1910
1911 #if SIZEOF_WCHAR_T == 4
1912 wxMBConvUTF16BE converter ;
1913 nBufSize = converter.WC2MB( NULL , szUnConv , 0 );
1914 szUniBuffer = new UniChar[ (nBufSize / sizeof(UniChar)) + 1] ;
1915 converter.WC2MB( (char*) szUniBuffer , szUnConv, nBufSize + sizeof(UniChar)) ;
1916 nBufSize /= sizeof(UniChar);
1917 ++nBufSize;
1918 #endif
1919
1920 CFStringRef theString = CFStringCreateWithCharactersNoCopy(
1921 NULL, //allocator
1922 szUniBuffer,
1923 nBufSize,
1924 NULL //deallocator
1925 );
1926
1927 wxASSERT(theString);
1928
1929 //Note that CER puts a BOM when converting to unicode
1930 //so we may want to check and use getchars instead in that case
1931 CFDataRef theData = CFStringCreateExternalRepresentation(
1932 NULL, //allocator
1933 theString,
1934 m_char_encoding,
1935 0 //what to put in characters that can't be converted -
1936 //0 tells CFString to return NULL if it meets such a character
1937 );
1938
1939 if(!theData)
1940 return (size_t)-1;
1941
1942 CFRelease(theString);
1943
1944 nRealOutSize = CFDataGetLength(theData);
1945
1946 if ( szOut == NULL )
1947 delete[] szBuffer;
1948
1949 if(nOutSize == 0)
1950 {
1951 //TODO: This gets flagged as a non-malloced address by the debugger...
1952 //#if SIZEOF_WCHAR_T == 4
1953 // delete[] szUniBuffer;
1954 //#endif
1955 CFRelease(theData);
1956 return nRealOutSize - 1;
1957 }
1958
1959 CFRange theRange = {0, CFDataGetLength(theData) };
1960 CFDataGetBytes(theData, theRange, (UInt8*) szBuffer);
1961
1962 CFRelease(theData);
1963
1964 //TODO: This gets flagged as a non-malloced address by the debugger...
1965 //#if SIZEOF_WCHAR_T == 4
1966 // delete[] szUniBuffer;
1967 //#endif
1968 return nRealOutSize - 1;
1969 }
1970
1971 bool IsOk() const
1972 {
1973 //TODO: check for invalid en/de/coding
1974 return true;
1975 }
1976
1977 private:
1978 CFStringEncoding m_char_encoding ;
1979 CFStringEncoding m_unicode_encoding ;
1980 };
1981
1982 #endif // defined(__WXCOCOA__)
1983
1984 // ============================================================================
1985 // Mac conversion classes
1986 // ============================================================================
1987
1988 #if defined(__WXMAC__) && defined(TARGET_CARBON)
1989
1990 class wxMBConv_mac : public wxMBConv
1991 {
1992 public:
1993 wxMBConv_mac()
1994 {
1995 Init(CFStringGetSystemEncoding()) ;
1996 }
1997
1998 wxMBConv_mac(const wxChar* name)
1999 {
2000 Init( wxMacGetSystemEncFromFontEnc(wxFontMapper::Get()->CharsetToEncoding(name, false) ) ) ;
2001 }
2002
2003 wxMBConv_mac(wxFontEncoding encoding)
2004 {
2005 Init( wxMacGetSystemEncFromFontEnc(encoding) );
2006 }
2007
2008 ~wxMBConv_mac()
2009 {
2010 OSStatus status = noErr ;
2011 status = TECDisposeConverter(m_MB2WC_converter);
2012 status = TECDisposeConverter(m_WC2MB_converter);
2013 }
2014
2015
2016 void Init( TextEncodingBase encoding)
2017 {
2018 OSStatus status = noErr ;
2019 m_char_encoding = encoding ;
2020 m_unicode_encoding = CreateTextEncoding(kTextEncodingUnicodeDefault,0,kUnicode16BitFormat) ;
2021
2022 status = TECCreateConverter(&m_MB2WC_converter,
2023 m_char_encoding,
2024 m_unicode_encoding);
2025 status = TECCreateConverter(&m_WC2MB_converter,
2026 m_unicode_encoding,
2027 m_char_encoding);
2028 }
2029
2030 size_t MB2WC(wchar_t *buf, const char *psz, size_t n) const
2031 {
2032 OSStatus status = noErr ;
2033 ByteCount byteOutLen ;
2034 ByteCount byteInLen = strlen(psz) ;
2035 wchar_t *tbuf = NULL ;
2036 UniChar* ubuf = NULL ;
2037 size_t res = 0 ;
2038
2039 if (buf == NULL)
2040 {
2041 n = byteInLen ;
2042 tbuf = (wchar_t*) malloc( n * SIZEOF_WCHAR_T) ;
2043 }
2044 ByteCount byteBufferLen = n * sizeof( UniChar ) ;
2045 #if SIZEOF_WCHAR_T == 4
2046 ubuf = (UniChar*) malloc( byteBufferLen + 2 ) ;
2047 #else
2048 ubuf = (UniChar*) (buf ? buf : tbuf) ;
2049 #endif
2050 status = TECConvertText(m_MB2WC_converter, (ConstTextPtr) psz , byteInLen, &byteInLen,
2051 (TextPtr) ubuf , byteBufferLen, &byteOutLen);
2052 #if SIZEOF_WCHAR_T == 4
2053 // we have to terminate here, because n might be larger for the trailing zero, and if UniChar
2054 // is not properly terminated we get random characters at the end
2055 ubuf[byteOutLen / sizeof( UniChar ) ] = 0 ;
2056 wxMBConvUTF16BE converter ;
2057 res = converter.MB2WC( (buf ? buf : tbuf) , (const char*)ubuf , n ) ;
2058 free( ubuf ) ;
2059 #else
2060 res = byteOutLen / sizeof( UniChar ) ;
2061 #endif
2062 if ( buf == NULL )
2063 free(tbuf) ;
2064
2065 if ( buf && res < n)
2066 buf[res] = 0;
2067
2068 return res ;
2069 }
2070
2071 size_t WC2MB(char *buf, const wchar_t *psz, size_t n) const
2072 {
2073 OSStatus status = noErr ;
2074 ByteCount byteOutLen ;
2075 ByteCount byteInLen = wxWcslen(psz) * SIZEOF_WCHAR_T ;
2076
2077 char *tbuf = NULL ;
2078
2079 if (buf == NULL)
2080 {
2081 // worst case
2082 n = byteInLen << 1 ;
2083 tbuf = (char*) malloc( n ) ;
2084 }
2085
2086 ByteCount byteBufferLen = n ;
2087 UniChar* ubuf = NULL ;
2088 #if SIZEOF_WCHAR_T == 4
2089 wxMBConvUTF16BE converter ;
2090 size_t unicharlen = converter.WC2MB( NULL , psz , 0 ) ;
2091 byteInLen = unicharlen ;
2092 ubuf = (UniChar*) malloc( byteInLen + 2 ) ;
2093 converter.WC2MB( (char*) ubuf , psz, unicharlen + 2 ) ;
2094 #else
2095 ubuf = (UniChar*) psz ;
2096 #endif
2097 status = TECConvertText(m_WC2MB_converter, (ConstTextPtr) ubuf , byteInLen, &byteInLen,
2098 (TextPtr) (buf ? buf : tbuf) , byteBufferLen, &byteOutLen);
2099 #if SIZEOF_WCHAR_T == 4
2100 free( ubuf ) ;
2101 #endif
2102 if ( buf == NULL )
2103 free(tbuf) ;
2104
2105 size_t res = byteOutLen ;
2106 if ( buf && res < n)
2107 buf[res] = 0;
2108
2109 return res ;
2110 }
2111
2112 bool IsOk() const
2113 { return m_MB2WC_converter != NULL && m_WC2MB_converter != NULL ; }
2114
2115 private:
2116 TECObjectRef m_MB2WC_converter ;
2117 TECObjectRef m_WC2MB_converter ;
2118
2119 TextEncodingBase m_char_encoding ;
2120 TextEncodingBase m_unicode_encoding ;
2121 };
2122
2123 #endif // defined(__WXMAC__) && defined(TARGET_CARBON)
2124
2125 // ============================================================================
2126 // wxEncodingConverter based conversion classes
2127 // ============================================================================
2128
2129 #if wxUSE_FONTMAP
2130
2131 class wxMBConv_wxwin : public wxMBConv
2132 {
2133 private:
2134 void Init()
2135 {
2136 m_ok = m2w.Init(m_enc, wxFONTENCODING_UNICODE) &&
2137 w2m.Init(wxFONTENCODING_UNICODE, m_enc);
2138 }
2139
2140 public:
2141 // temporarily just use wxEncodingConverter stuff,
2142 // so that it works while a better implementation is built
2143 wxMBConv_wxwin(const wxChar* name)
2144 {
2145 if (name)
2146 m_enc = wxFontMapper::Get()->CharsetToEncoding(name, false);
2147 else
2148 m_enc = wxFONTENCODING_SYSTEM;
2149
2150 Init();
2151 }
2152
2153 wxMBConv_wxwin(wxFontEncoding enc)
2154 {
2155 m_enc = enc;
2156
2157 Init();
2158 }
2159
2160 size_t MB2WC(wchar_t *buf, const char *psz, size_t WXUNUSED(n)) const
2161 {
2162 size_t inbuf = strlen(psz);
2163 if (buf)
2164 m2w.Convert(psz,buf);
2165 return inbuf;
2166 }
2167
2168 size_t WC2MB(char *buf, const wchar_t *psz, size_t WXUNUSED(n)) const
2169 {
2170 const size_t inbuf = wxWcslen(psz);
2171 if (buf)
2172 w2m.Convert(psz,buf);
2173
2174 return inbuf;
2175 }
2176
2177 bool IsOk() const { return m_ok; }
2178
2179 public:
2180 wxFontEncoding m_enc;
2181 wxEncodingConverter m2w, w2m;
2182
2183 // were we initialized successfully?
2184 bool m_ok;
2185
2186 DECLARE_NO_COPY_CLASS(wxMBConv_wxwin)
2187 };
2188
2189 #endif // wxUSE_FONTMAP
2190
2191 // ============================================================================
2192 // wxCSConv implementation
2193 // ============================================================================
2194
2195 void wxCSConv::Init()
2196 {
2197 m_name = NULL;
2198 m_convReal = NULL;
2199 m_deferred = true;
2200 }
2201
2202 wxCSConv::wxCSConv(const wxChar *charset)
2203 {
2204 Init();
2205
2206 if ( charset )
2207 {
2208 SetName(charset);
2209 }
2210
2211 m_encoding = wxFONTENCODING_SYSTEM;
2212 }
2213
2214 wxCSConv::wxCSConv(wxFontEncoding encoding)
2215 {
2216 if ( encoding == wxFONTENCODING_MAX || encoding == wxFONTENCODING_DEFAULT )
2217 {
2218 wxFAIL_MSG( _T("invalid encoding value in wxCSConv ctor") );
2219
2220 encoding = wxFONTENCODING_SYSTEM;
2221 }
2222
2223 Init();
2224
2225 m_encoding = encoding;
2226 }
2227
2228 wxCSConv::~wxCSConv()
2229 {
2230 Clear();
2231 }
2232
2233 wxCSConv::wxCSConv(const wxCSConv& conv)
2234 : wxMBConv()
2235 {
2236 Init();
2237
2238 SetName(conv.m_name);
2239 m_encoding = conv.m_encoding;
2240 }
2241
2242 wxCSConv& wxCSConv::operator=(const wxCSConv& conv)
2243 {
2244 Clear();
2245
2246 SetName(conv.m_name);
2247 m_encoding = conv.m_encoding;
2248
2249 return *this;
2250 }
2251
2252 void wxCSConv::Clear()
2253 {
2254 free(m_name);
2255 delete m_convReal;
2256
2257 m_name = NULL;
2258 m_convReal = NULL;
2259 }
2260
2261 void wxCSConv::SetName(const wxChar *charset)
2262 {
2263 if (charset)
2264 {
2265 m_name = wxStrdup(charset);
2266 m_deferred = true;
2267 }
2268 }
2269
2270 wxMBConv *wxCSConv::DoCreate() const
2271 {
2272 // check for the special case of ASCII or ISO8859-1 charset: as we have
2273 // special knowledge of it anyhow, we don't need to create a special
2274 // conversion object
2275 if ( m_encoding == wxFONTENCODING_ISO8859_1 )
2276 {
2277 // don't convert at all
2278 return NULL;
2279 }
2280
2281 // we trust OS to do conversion better than we can so try external
2282 // conversion methods first
2283 //
2284 // the full order is:
2285 // 1. OS conversion (iconv() under Unix or Win32 API)
2286 // 2. hard coded conversions for UTF
2287 // 3. wxEncodingConverter as fall back
2288
2289 // step (1)
2290 #ifdef HAVE_ICONV
2291 #if !wxUSE_FONTMAP
2292 if ( m_name )
2293 #endif // !wxUSE_FONTMAP
2294 {
2295 wxString name(m_name);
2296
2297 #if wxUSE_FONTMAP
2298 if ( name.empty() )
2299 name = wxFontMapper::Get()->GetEncodingName(m_encoding);
2300 #endif // wxUSE_FONTMAP
2301
2302 wxMBConv_iconv *conv = new wxMBConv_iconv(name);
2303 if ( conv->IsOk() )
2304 return conv;
2305
2306 delete conv;
2307 }
2308 #endif // HAVE_ICONV
2309
2310 #ifdef wxHAVE_WIN32_MB2WC
2311 {
2312 #if wxUSE_FONTMAP
2313 wxMBConv_win32 *conv = m_name ? new wxMBConv_win32(m_name)
2314 : new wxMBConv_win32(m_encoding);
2315 if ( conv->IsOk() )
2316 return conv;
2317
2318 delete conv;
2319 #else
2320 return NULL;
2321 #endif
2322 }
2323 #endif // wxHAVE_WIN32_MB2WC
2324 #if defined(__WXMAC__)
2325 {
2326 if ( m_name || ( m_encoding < wxFONTENCODING_UTF16BE ) )
2327 {
2328
2329 wxMBConv_mac *conv = m_name ? new wxMBConv_mac(m_name)
2330 : new wxMBConv_mac(m_encoding);
2331 if ( conv->IsOk() )
2332 return conv;
2333
2334 delete conv;
2335 }
2336 }
2337 #endif
2338 #if defined(__WXCOCOA__)
2339 {
2340 if ( m_name || ( m_encoding <= wxFONTENCODING_UTF16 ) )
2341 {
2342
2343 wxMBConv_cocoa *conv = m_name ? new wxMBConv_cocoa(m_name)
2344 : new wxMBConv_cocoa(m_encoding);
2345 if ( conv->IsOk() )
2346 return conv;
2347
2348 delete conv;
2349 }
2350 }
2351 #endif
2352 // step (2)
2353 wxFontEncoding enc = m_encoding;
2354 #if wxUSE_FONTMAP
2355 if ( enc == wxFONTENCODING_SYSTEM && m_name )
2356 {
2357 // use "false" to suppress interactive dialogs -- we can be called from
2358 // anywhere and popping up a dialog from here is the last thing we want to
2359 // do
2360 enc = wxFontMapper::Get()->CharsetToEncoding(m_name, false);
2361 }
2362 #endif // wxUSE_FONTMAP
2363
2364 switch ( enc )
2365 {
2366 case wxFONTENCODING_UTF7:
2367 return new wxMBConvUTF7;
2368
2369 case wxFONTENCODING_UTF8:
2370 return new wxMBConvUTF8;
2371
2372 case wxFONTENCODING_UTF16BE:
2373 return new wxMBConvUTF16BE;
2374
2375 case wxFONTENCODING_UTF16LE:
2376 return new wxMBConvUTF16LE;
2377
2378 case wxFONTENCODING_UTF32BE:
2379 return new wxMBConvUTF32BE;
2380
2381 case wxFONTENCODING_UTF32LE:
2382 return new wxMBConvUTF32LE;
2383
2384 default:
2385 // nothing to do but put here to suppress gcc warnings
2386 ;
2387 }
2388
2389 // step (3)
2390 #if wxUSE_FONTMAP
2391 {
2392 wxMBConv_wxwin *conv = m_name ? new wxMBConv_wxwin(m_name)
2393 : new wxMBConv_wxwin(m_encoding);
2394 if ( conv->IsOk() )
2395 return conv;
2396
2397 delete conv;
2398 }
2399 #endif // wxUSE_FONTMAP
2400
2401 // NB: This is a hack to prevent deadlock. What could otherwise happen
2402 // in Unicode build: wxConvLocal creation ends up being here
2403 // because of some failure and logs the error. But wxLog will try to
2404 // attach timestamp, for which it will need wxConvLocal (to convert
2405 // time to char* and then wchar_t*), but that fails, tries to log
2406 // error, but wxLog has a (already locked) critical section that
2407 // guards static buffer.
2408 static bool alreadyLoggingError = false;
2409 if (!alreadyLoggingError)
2410 {
2411 alreadyLoggingError = true;
2412 wxLogError(_("Cannot convert from the charset '%s'!"),
2413 m_name ? m_name
2414 :
2415 #if wxUSE_FONTMAP
2416 wxFontMapper::GetEncodingDescription(m_encoding).c_str()
2417 #else // !wxUSE_FONTMAP
2418 wxString::Format(_("encoding %s"), m_encoding).c_str()
2419 #endif // wxUSE_FONTMAP/!wxUSE_FONTMAP
2420 );
2421 alreadyLoggingError = false;
2422 }
2423
2424 return NULL;
2425 }
2426
2427 void wxCSConv::CreateConvIfNeeded() const
2428 {
2429 if ( m_deferred )
2430 {
2431 wxCSConv *self = (wxCSConv *)this; // const_cast
2432
2433 #if wxUSE_INTL
2434 // if we don't have neither the name nor the encoding, use the default
2435 // encoding for this system
2436 if ( !m_name && m_encoding == wxFONTENCODING_SYSTEM )
2437 {
2438 self->m_name = wxStrdup(wxLocale::GetSystemEncodingName());
2439 }
2440 #endif // wxUSE_INTL
2441
2442 self->m_convReal = DoCreate();
2443 self->m_deferred = false;
2444 }
2445 }
2446
2447 size_t wxCSConv::MB2WC(wchar_t *buf, const char *psz, size_t n) const
2448 {
2449 CreateConvIfNeeded();
2450
2451 if (m_convReal)
2452 return m_convReal->MB2WC(buf, psz, n);
2453
2454 // latin-1 (direct)
2455 size_t len = strlen(psz);
2456
2457 if (buf)
2458 {
2459 for (size_t c = 0; c <= len; c++)
2460 buf[c] = (unsigned char)(psz[c]);
2461 }
2462
2463 return len;
2464 }
2465
2466 size_t wxCSConv::WC2MB(char *buf, const wchar_t *psz, size_t n) const
2467 {
2468 CreateConvIfNeeded();
2469
2470 if (m_convReal)
2471 return m_convReal->WC2MB(buf, psz, n);
2472
2473 // latin-1 (direct)
2474 const size_t len = wxWcslen(psz);
2475 if (buf)
2476 {
2477 for (size_t c = 0; c <= len; c++)
2478 {
2479 if (psz[c] > 0xFF)
2480 return (size_t)-1;
2481 buf[c] = (char)psz[c];
2482 }
2483 }
2484 else
2485 {
2486 for (size_t c = 0; c <= len; c++)
2487 {
2488 if (psz[c] > 0xFF)
2489 return (size_t)-1;
2490 }
2491 }
2492
2493 return len;
2494 }
2495
2496 // ----------------------------------------------------------------------------
2497 // globals
2498 // ----------------------------------------------------------------------------
2499
2500 #ifdef __WINDOWS__
2501 static wxMBConv_win32 wxConvLibcObj;
2502 #elif defined(__WXMAC__) && !defined(__MACH__)
2503 static wxMBConv_mac wxConvLibcObj ;
2504 #else
2505 static wxMBConvLibc wxConvLibcObj;
2506 #endif
2507
2508 static wxCSConv wxConvLocalObj(wxFONTENCODING_SYSTEM);
2509 static wxCSConv wxConvISO8859_1Obj(wxFONTENCODING_ISO8859_1);
2510 static wxMBConvUTF7 wxConvUTF7Obj;
2511 static wxMBConvUTF8 wxConvUTF8Obj;
2512
2513
2514 WXDLLIMPEXP_DATA_BASE(wxMBConv&) wxConvLibc = wxConvLibcObj;
2515 WXDLLIMPEXP_DATA_BASE(wxCSConv&) wxConvLocal = wxConvLocalObj;
2516 WXDLLIMPEXP_DATA_BASE(wxCSConv&) wxConvISO8859_1 = wxConvISO8859_1Obj;
2517 WXDLLIMPEXP_DATA_BASE(wxMBConvUTF7&) wxConvUTF7 = wxConvUTF7Obj;
2518 WXDLLIMPEXP_DATA_BASE(wxMBConvUTF8&) wxConvUTF8 = wxConvUTF8Obj;
2519 WXDLLIMPEXP_DATA_BASE(wxMBConv *) wxConvCurrent = &wxConvLibcObj;
2520
2521 #else // !wxUSE_WCHAR_T
2522
2523 // stand-ins in absence of wchar_t
2524 WXDLLIMPEXP_DATA_BASE(wxMBConv) wxConvLibc,
2525 wxConvISO8859_1,
2526 wxConvLocal,
2527 wxConvUTF8;
2528
2529 #endif // wxUSE_WCHAR_T/!wxUSE_WCHAR_T
2530
2531
wxWidgets (Impactor)