]> git.saurik.com Git - wxWidgets.git/blob - src/common/strconv.cpp
projects / wxWidgets.git / blob
? search:
summary | shortlog | log | commit | commitdiff | tree
blame | history | raw | HEAD
Inital fill in background, removed tabs, -1->wxID_ANY, TRUE->true, FALSE->false
[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
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 0;
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 0;
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 const size_t len = ::MultiByteToWideChar
1152 (
1153 m_CodePage, // code page
1154 0, // flags (none)
1155 psz, // input string
1156 -1, // its length (NUL-terminated)
1157 buf, // output string
1158 buf ? n : 0 // size of output buffer
1159 );
1160
1161 // note that it returns count of written chars for buf != NULL and size
1162 // of the needed buffer for buf == NULL so in either case the length of
1163 // the string (which never includes the terminating NUL) is one less
1164 return len ? len - 1 : (size_t)-1;
1165 }
1166
1167 size_t WC2MB(char *buf, const wchar_t *pwz, size_t n) const
1168 {
1169 /*
1170 we have a problem here: by default, WideCharToMultiByte() may
1171 replace characters unrepresentable in the target code page with bad
1172 quality approximations such as turning "1/2" symbol (U+00BD) into
1173 "1" for the code pages which don't have it and we, obviously, want
1174 to avoid this at any price
1175
1176 the trouble is that this function does it _silently_, i.e. it won't
1177 even tell us whether it did or not... Win98/2000 and higher provide
1178 WC_NO_BEST_FIT_CHARS but it doesn't work for the older systems and
1179 we have to resort to a round trip, i.e. check that converting back
1180 results in the same string -- this is, of course, expensive but
1181 otherwise we simply can't be sure to not garble the data.
1182 */
1183
1184 // determine if we can rely on WC_NO_BEST_FIT_CHARS: according to MSDN
1185 // it doesn't work with CJK encodings (which we test for rather roughly
1186 // here...) nor with UTF-7/8 nor, of course, with Windows versions not
1187 // supporting it
1188 BOOL usedDef wxDUMMY_INITIALIZE(false),
1189 *pUsedDef;
1190 int flags;
1191 if ( CanUseNoBestFit() && m_CodePage < 50000 )
1192 {
1193 // it's our lucky day
1194 flags = WC_NO_BEST_FIT_CHARS;
1195 pUsedDef = &usedDef;
1196 }
1197 else // old system or unsupported encoding
1198 {
1199 flags = 0;
1200 pUsedDef = NULL;
1201 }
1202
1203 const size_t len = ::WideCharToMultiByte
1204 (
1205 m_CodePage, // code page
1206 flags, // either none or no best fit
1207 pwz, // input string
1208 -1, // it is (wide) NUL-terminated
1209 buf, // output buffer
1210 buf ? n : 0, // and its size
1211 NULL, // default "replacement" char
1212 pUsedDef // [out] was it used?
1213 );
1214
1215 if ( !len )
1216 {
1217 // function totally failed
1218 return (size_t)-1;
1219 }
1220
1221 // if we were really converting, check if we succeeded
1222 if ( buf )
1223 {
1224 if ( flags )
1225 {
1226 // check if the conversion failed, i.e. if any replacements
1227 // were done
1228 if ( usedDef )
1229 return (size_t)-1;
1230 }
1231 else // we must resort to double tripping...
1232 {
1233 wxWCharBuffer wcBuf(n);
1234 if ( MB2WC(wcBuf.data(), buf, n) == (size_t)-1 ||
1235 wcscmp(wcBuf, pwz) != 0 )
1236 {
1237 // we didn't obtain the same thing we started from, hence
1238 // the conversion was lossy and we consider that it failed
1239 return (size_t)-1;
1240 }
1241 }
1242 }
1243
1244 // see the comment above for the reason of "len - 1"
1245 return len - 1;
1246 }
1247
1248 bool IsOk() const { return m_CodePage != -1; }
1249
1250 private:
1251 static bool CanUseNoBestFit()
1252 {
1253 static int s_isWin98Or2k = -1;
1254
1255 if ( s_isWin98Or2k == -1 )
1256 {
1257 int verMaj, verMin;
1258 switch ( wxGetOsVersion(&verMaj, &verMin) )
1259 {
1260 case wxWIN95:
1261 s_isWin98Or2k = verMaj >= 4 && verMin >= 10;
1262 break;
1263
1264 case wxWINDOWS_NT:
1265 s_isWin98Or2k = verMaj >= 5;
1266 break;
1267
1268 default:
1269 // unknown, be conseravtive by default
1270 s_isWin98Or2k = 0;
1271 }
1272
1273 wxASSERT_MSG( s_isWin98Or2k != -1, _T("should be set above") );
1274 }
1275
1276 return s_isWin98Or2k == 1;
1277 }
1278
1279 long m_CodePage;
1280 };
1281
1282 #endif // wxHAVE_WIN32_MB2WC
1283
1284 // ============================================================================
1285 // Mac conversion classes
1286 // ============================================================================
1287
1288 #if defined(__WXMAC__) && defined(TARGET_CARBON)
1289
1290 class wxMBConv_mac : public wxMBConv
1291 {
1292 public:
1293 wxMBConv_mac()
1294 {
1295 Init(CFStringGetSystemEncoding()) ;
1296 }
1297
1298 wxMBConv_mac(const wxChar* name)
1299 {
1300 Init( wxMacGetSystemEncFromFontEnc(wxFontMapper::Get()->CharsetToEncoding(name, FALSE) ) ) ;
1301 }
1302
1303 wxMBConv_mac(wxFontEncoding encoding)
1304 {
1305 Init( wxMacGetSystemEncFromFontEnc(encoding) );
1306 }
1307
1308 ~wxMBConv_mac()
1309 {
1310 OSStatus status = noErr ;
1311 status = TECDisposeConverter(m_MB2WC_converter);
1312 status = TECDisposeConverter(m_WC2MB_converter);
1313 }
1314
1315
1316 void Init( TextEncodingBase encoding)
1317 {
1318 OSStatus status = noErr ;
1319 m_char_encoding = encoding ;
1320 m_unicode_encoding = CreateTextEncoding(kTextEncodingUnicodeDefault,0,kUnicode16BitFormat) ;
1321
1322 status = TECCreateConverter(&m_MB2WC_converter,
1323 m_char_encoding,
1324 m_unicode_encoding);
1325 status = TECCreateConverter(&m_WC2MB_converter,
1326 m_unicode_encoding,
1327 m_char_encoding);
1328 }
1329
1330 size_t MB2WC(wchar_t *buf, const char *psz, size_t n) const
1331 {
1332 OSStatus status = noErr ;
1333 ByteCount byteOutLen ;
1334 ByteCount byteInLen = strlen(psz) ;
1335 wchar_t *tbuf = NULL ;
1336 UniChar* ubuf = NULL ;
1337 size_t res = 0 ;
1338
1339 if (buf == NULL)
1340 {
1341 n = byteInLen ;
1342 tbuf = (wchar_t*) malloc( n * SIZEOF_WCHAR_T) ;
1343 }
1344 ByteCount byteBufferLen = n * sizeof( UniChar ) ;
1345 #if SIZEOF_WCHAR_T == 4
1346 ubuf = (UniChar*) malloc( byteBufferLen + 2 ) ;
1347 #else
1348 ubuf = (UniChar*) (buf ? buf : tbuf) ;
1349 #endif
1350 status = TECConvertText(m_MB2WC_converter, (ConstTextPtr) psz , byteInLen, &byteInLen,
1351 (TextPtr) ubuf , byteBufferLen, &byteOutLen);
1352 #if SIZEOF_WCHAR_T == 4
1353 // we have to terminate here, because n might be larger for the trailing zero, and if UniChar
1354 // is not properly terminated we get random characters at the end
1355 ubuf[byteOutLen / sizeof( UniChar ) ] = 0 ;
1356 wxMBConvUTF16BE converter ;
1357 res = converter.MB2WC( (buf ? buf : tbuf) , (const char*)ubuf , n ) ;
1358 free( ubuf ) ;
1359 #else
1360 res = byteOutLen / sizeof( UniChar ) ;
1361 #endif
1362 if ( buf == NULL )
1363 free(tbuf) ;
1364
1365 if ( buf && res < n)
1366 buf[res] = 0;
1367
1368 return res ;
1369 }
1370
1371 size_t WC2MB(char *buf, const wchar_t *psz, size_t n) const
1372 {
1373 OSStatus status = noErr ;
1374 ByteCount byteOutLen ;
1375 ByteCount byteInLen = wxWcslen(psz) * SIZEOF_WCHAR_T ;
1376
1377 char *tbuf = NULL ;
1378
1379 if (buf == NULL)
1380 {
1381 // worst case
1382 n = byteInLen * 2 ;
1383 tbuf = (char*) malloc( n ) ;
1384 }
1385
1386 ByteCount byteBufferLen = n ;
1387 UniChar* ubuf = NULL ;
1388 #if SIZEOF_WCHAR_T == 4
1389 wxMBConvUTF16BE converter ;
1390 size_t unicharlen = converter.WC2MB( NULL , psz , 0 ) ;
1391 byteInLen = unicharlen ;
1392 ubuf = (UniChar*) malloc( byteInLen + 2 ) ;
1393 converter.WC2MB( (char*) ubuf , psz, unicharlen + 2 ) ;
1394 #else
1395 ubuf = (UniChar*) psz ;
1396 #endif
1397 status = TECConvertText(m_WC2MB_converter, (ConstTextPtr) ubuf , byteInLen, &byteInLen,
1398 (TextPtr) (buf ? buf : tbuf) , byteBufferLen, &byteOutLen);
1399 #if SIZEOF_WCHAR_T == 4
1400 free( ubuf ) ;
1401 #endif
1402 if ( buf == NULL )
1403 free(tbuf) ;
1404
1405 size_t res = byteOutLen ;
1406 if ( buf && res < n)
1407 buf[res] = 0;
1408
1409 return res ;
1410 }
1411
1412 bool IsOk() const
1413 { return m_MB2WC_converter != NULL && m_WC2MB_converter != NULL ; }
1414
1415 private:
1416 TECObjectRef m_MB2WC_converter ;
1417 TECObjectRef m_WC2MB_converter ;
1418
1419 TextEncodingBase m_char_encoding ;
1420 TextEncodingBase m_unicode_encoding ;
1421 };
1422
1423 #endif // defined(__WXMAC__) && defined(TARGET_CARBON)
1424
1425 // ============================================================================
1426 // wxEncodingConverter based conversion classes
1427 // ============================================================================
1428
1429 #if wxUSE_FONTMAP
1430
1431 class wxMBConv_wxwin : public wxMBConv
1432 {
1433 private:
1434 void Init()
1435 {
1436 m_ok = m2w.Init(m_enc, wxFONTENCODING_UNICODE) &&
1437 w2m.Init(wxFONTENCODING_UNICODE, m_enc);
1438 }
1439
1440 public:
1441 // temporarily just use wxEncodingConverter stuff,
1442 // so that it works while a better implementation is built
1443 wxMBConv_wxwin(const wxChar* name)
1444 {
1445 if (name)
1446 m_enc = wxFontMapper::Get()->CharsetToEncoding(name, false);
1447 else
1448 m_enc = wxFONTENCODING_SYSTEM;
1449
1450 Init();
1451 }
1452
1453 wxMBConv_wxwin(wxFontEncoding enc)
1454 {
1455 m_enc = enc;
1456
1457 Init();
1458 }
1459
1460 size_t MB2WC(wchar_t *buf, const char *psz, size_t WXUNUSED(n)) const
1461 {
1462 size_t inbuf = strlen(psz);
1463 if (buf)
1464 m2w.Convert(psz,buf);
1465 return inbuf;
1466 }
1467
1468 size_t WC2MB(char *buf, const wchar_t *psz, size_t WXUNUSED(n)) const
1469 {
1470 const size_t inbuf = wxWcslen(psz);
1471 if (buf)
1472 w2m.Convert(psz,buf);
1473
1474 return inbuf;
1475 }
1476
1477 bool IsOk() const { return m_ok; }
1478
1479 public:
1480 wxFontEncoding m_enc;
1481 wxEncodingConverter m2w, w2m;
1482
1483 // were we initialized successfully?
1484 bool m_ok;
1485
1486 DECLARE_NO_COPY_CLASS(wxMBConv_wxwin)
1487 };
1488
1489 #endif // wxUSE_FONTMAP
1490
1491 // ============================================================================
1492 // wxCSConv implementation
1493 // ============================================================================
1494
1495 void wxCSConv::Init()
1496 {
1497 m_name = NULL;
1498 m_convReal = NULL;
1499 m_deferred = true;
1500 }
1501
1502 wxCSConv::wxCSConv(const wxChar *charset)
1503 {
1504 Init();
1505
1506 if ( charset )
1507 {
1508 SetName(charset);
1509 }
1510
1511 m_encoding = wxFONTENCODING_SYSTEM;
1512 }
1513
1514 wxCSConv::wxCSConv(wxFontEncoding encoding)
1515 {
1516 if ( encoding == wxFONTENCODING_MAX || encoding == wxFONTENCODING_DEFAULT )
1517 {
1518 wxFAIL_MSG( _T("invalid encoding value in wxCSConv ctor") );
1519
1520 encoding = wxFONTENCODING_SYSTEM;
1521 }
1522
1523 Init();
1524
1525 m_encoding = encoding;
1526 }
1527
1528 wxCSConv::~wxCSConv()
1529 {
1530 Clear();
1531 }
1532
1533 wxCSConv::wxCSConv(const wxCSConv& conv)
1534 : wxMBConv()
1535 {
1536 Init();
1537
1538 SetName(conv.m_name);
1539 m_encoding = conv.m_encoding;
1540 }
1541
1542 wxCSConv& wxCSConv::operator=(const wxCSConv& conv)
1543 {
1544 Clear();
1545
1546 SetName(conv.m_name);
1547 m_encoding = conv.m_encoding;
1548
1549 return *this;
1550 }
1551
1552 void wxCSConv::Clear()
1553 {
1554 free(m_name);
1555 delete m_convReal;
1556
1557 m_name = NULL;
1558 m_convReal = NULL;
1559 }
1560
1561 void wxCSConv::SetName(const wxChar *charset)
1562 {
1563 if (charset)
1564 {
1565 m_name = wxStrdup(charset);
1566 m_deferred = true;
1567 }
1568 }
1569
1570 wxMBConv *wxCSConv::DoCreate() const
1571 {
1572 // check for the special case of ASCII or ISO8859-1 charset: as we have
1573 // special knowledge of it anyhow, we don't need to create a special
1574 // conversion object
1575 if ( m_encoding == wxFONTENCODING_ISO8859_1 )
1576 {
1577 // don't convert at all
1578 return NULL;
1579 }
1580
1581 // we trust OS to do conversion better than we can so try external
1582 // conversion methods first
1583 //
1584 // the full order is:
1585 // 1. OS conversion (iconv() under Unix or Win32 API)
1586 // 2. hard coded conversions for UTF
1587 // 3. wxEncodingConverter as fall back
1588
1589 // step (1)
1590 #ifdef HAVE_ICONV
1591 #if !wxUSE_FONTMAP
1592 if ( m_name )
1593 #endif // !wxUSE_FONTMAP
1594 {
1595 wxString name(m_name);
1596
1597 #if wxUSE_FONTMAP
1598 if ( name.empty() )
1599 name = wxFontMapper::Get()->GetEncodingName(m_encoding);
1600 #endif // wxUSE_FONTMAP
1601
1602 wxMBConv_iconv *conv = new wxMBConv_iconv(name);
1603 if ( conv->IsOk() )
1604 return conv;
1605
1606 delete conv;
1607 }
1608 #endif // HAVE_ICONV
1609
1610 #ifdef wxHAVE_WIN32_MB2WC
1611 {
1612 #if wxUSE_FONTMAP
1613 wxMBConv_win32 *conv = m_name ? new wxMBConv_win32(m_name)
1614 : new wxMBConv_win32(m_encoding);
1615 if ( conv->IsOk() )
1616 return conv;
1617
1618 delete conv;
1619 #else
1620 return NULL;
1621 #endif
1622 }
1623 #endif // wxHAVE_WIN32_MB2WC
1624 #if defined(__WXMAC__)
1625 {
1626 if ( m_name || ( m_encoding < wxFONTENCODING_UTF16BE ) )
1627 {
1628
1629 wxMBConv_mac *conv = m_name ? new wxMBConv_mac(m_name)
1630 : new wxMBConv_mac(m_encoding);
1631 if ( conv->IsOk() )
1632 return conv;
1633
1634 delete conv;
1635 }
1636 }
1637 #endif
1638 // step (2)
1639 wxFontEncoding enc = m_encoding;
1640 #if wxUSE_FONTMAP
1641 if ( enc == wxFONTENCODING_SYSTEM && m_name )
1642 {
1643 // use "false" to suppress interactive dialogs -- we can be called from
1644 // anywhere and popping up a dialog from here is the last thing we want to
1645 // do
1646 enc = wxFontMapper::Get()->CharsetToEncoding(m_name, false);
1647 }
1648 #endif // wxUSE_FONTMAP
1649
1650 switch ( enc )
1651 {
1652 case wxFONTENCODING_UTF7:
1653 return new wxMBConvUTF7;
1654
1655 case wxFONTENCODING_UTF8:
1656 return new wxMBConvUTF8;
1657
1658 case wxFONTENCODING_UTF16BE:
1659 return new wxMBConvUTF16BE;
1660
1661 case wxFONTENCODING_UTF16LE:
1662 return new wxMBConvUTF16LE;
1663
1664 case wxFONTENCODING_UTF32BE:
1665 return new wxMBConvUTF32BE;
1666
1667 case wxFONTENCODING_UTF32LE:
1668 return new wxMBConvUTF32LE;
1669
1670 default:
1671 // nothing to do but put here to suppress gcc warnings
1672 ;
1673 }
1674
1675 // step (3)
1676 #if wxUSE_FONTMAP
1677 {
1678 wxMBConv_wxwin *conv = m_name ? new wxMBConv_wxwin(m_name)
1679 : new wxMBConv_wxwin(m_encoding);
1680 if ( conv->IsOk() )
1681 return conv;
1682
1683 delete conv;
1684 }
1685 #endif // wxUSE_FONTMAP
1686
1687 // NB: This is a hack to prevent deadlock. What could otherwise happen
1688 // in Unicode build: wxConvLocal creation ends up being here
1689 // because of some failure and logs the error. But wxLog will try to
1690 // attach timestamp, for which it will need wxConvLocal (to convert
1691 // time to char* and then wchar_t*), but that fails, tries to log
1692 // error, but wxLog has a (already locked) critical section that
1693 // guards static buffer.
1694 static bool alreadyLoggingError = false;
1695 if (!alreadyLoggingError)
1696 {
1697 alreadyLoggingError = true;
1698 wxLogError(_("Cannot convert from the charset '%s'!"),
1699 m_name ? m_name
1700 :
1701 #if wxUSE_FONTMAP
1702 wxFontMapper::GetEncodingDescription(m_encoding).c_str()
1703 #else // !wxUSE_FONTMAP
1704 wxString::Format(_("encoding %s"), m_encoding).c_str()
1705 #endif // wxUSE_FONTMAP/!wxUSE_FONTMAP
1706 );
1707 alreadyLoggingError = false;
1708 }
1709
1710 return NULL;
1711 }
1712
1713 void wxCSConv::CreateConvIfNeeded() const
1714 {
1715 if ( m_deferred )
1716 {
1717 wxCSConv *self = (wxCSConv *)this; // const_cast
1718
1719 #if wxUSE_INTL
1720 // if we don't have neither the name nor the encoding, use the default
1721 // encoding for this system
1722 if ( !m_name && m_encoding == wxFONTENCODING_SYSTEM )
1723 {
1724 self->m_name = wxStrdup(wxLocale::GetSystemEncodingName());
1725 }
1726 #endif // wxUSE_INTL
1727
1728 self->m_convReal = DoCreate();
1729 self->m_deferred = false;
1730 }
1731 }
1732
1733 size_t wxCSConv::MB2WC(wchar_t *buf, const char *psz, size_t n) const
1734 {
1735 CreateConvIfNeeded();
1736
1737 if (m_convReal)
1738 return m_convReal->MB2WC(buf, psz, n);
1739
1740 // latin-1 (direct)
1741 size_t len = strlen(psz);
1742
1743 if (buf)
1744 {
1745 for (size_t c = 0; c <= len; c++)
1746 buf[c] = (unsigned char)(psz[c]);
1747 }
1748
1749 return len;
1750 }
1751
1752 size_t wxCSConv::WC2MB(char *buf, const wchar_t *psz, size_t n) const
1753 {
1754 CreateConvIfNeeded();
1755
1756 if (m_convReal)
1757 return m_convReal->WC2MB(buf, psz, n);
1758
1759 // latin-1 (direct)
1760 const size_t len = wxWcslen(psz);
1761 if (buf)
1762 {
1763 for (size_t c = 0; c <= len; c++)
1764 {
1765 if (psz[c] > 0xFF)
1766 return (size_t)-1;
1767 buf[c] = psz[c];
1768 }
1769 }
1770 else
1771 {
1772 for (size_t c = 0; c <= len; c++)
1773 {
1774 if (psz[c] > 0xFF)
1775 return (size_t)-1;
1776 }
1777 }
1778
1779 return len;
1780 }
1781
1782 // ----------------------------------------------------------------------------
1783 // globals
1784 // ----------------------------------------------------------------------------
1785
1786 #ifdef __WINDOWS__
1787 static wxMBConv_win32 wxConvLibcObj;
1788 #else
1789 static wxMBConvLibc wxConvLibcObj;
1790 #endif
1791
1792 static wxCSConv wxConvLocalObj(wxFONTENCODING_SYSTEM);
1793 static wxCSConv wxConvISO8859_1Obj(wxFONTENCODING_ISO8859_1);
1794 static wxMBConvUTF7 wxConvUTF7Obj;
1795 static wxMBConvUTF8 wxConvUTF8Obj;
1796
1797
1798 WXDLLIMPEXP_DATA_BASE(wxMBConv&) wxConvLibc = wxConvLibcObj;
1799 WXDLLIMPEXP_DATA_BASE(wxCSConv&) wxConvLocal = wxConvLocalObj;
1800 WXDLLIMPEXP_DATA_BASE(wxCSConv&) wxConvISO8859_1 = wxConvISO8859_1Obj;
1801 WXDLLIMPEXP_DATA_BASE(wxMBConvUTF7&) wxConvUTF7 = wxConvUTF7Obj;
1802 WXDLLIMPEXP_DATA_BASE(wxMBConvUTF8&) wxConvUTF8 = wxConvUTF8Obj;
1803 WXDLLIMPEXP_DATA_BASE(wxMBConv *) wxConvCurrent = &wxConvLibcObj;
1804
1805 #else // !wxUSE_WCHAR_T
1806
1807 // stand-ins in absence of wchar_t
1808 WXDLLIMPEXP_DATA_BASE(wxMBConv) wxConvLibc,
1809 wxConvISO8859_1,
1810 wxConvLocal,
1811 wxConvUTF8;
1812
1813 #endif // wxUSE_WCHAR_T/!wxUSE_WCHAR_T
1814
1815
wxWidgets (Impactor)