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


113c02acfd93855683ca16ec42cd344e1e5c00ad
[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, Vadim Zeitlin, Vaclav Slavik
9 // Licence: wxWindows licence
10 /////////////////////////////////////////////////////////////////////////////
11
12 // ============================================================================
13 // declarations
14 // ============================================================================
15
16 // ----------------------------------------------------------------------------
17 // headers
18 // ----------------------------------------------------------------------------
19
20 #if defined(__GNUG__) && !defined(NO_GCC_PRAGMA)
21 #pragma implementation "strconv.h"
22 #endif
23
24 // For compilers that support precompilation, includes "wx.h".
25 #include "wx/wxprec.h"
26
27 #ifdef __BORLANDC__
28 #pragma hdrstop
29 #endif
30
31 #ifndef WX_PRECOMP
32 #include "wx/intl.h"
33 #include "wx/log.h"
34 #endif // WX_PRECOMP
35
36 #ifdef __WXMSW__
37 #include "wx/msw/private.h"
38 #endif
39
40 #ifndef __WXWINCE__
41 #include <errno.h>
42 #endif
43
44 #include <ctype.h>
45 #include <string.h>
46 #include <stdlib.h>
47
48 #include "wx/module.h"
49 #include "wx/strconv.h"
50
51 // ----------------------------------------------------------------------------
52 // globals
53 // ----------------------------------------------------------------------------
54
55 #if wxUSE_WCHAR_T
56 WXDLLIMPEXP_DATA_BASE(wxMBConv) wxConvLibc;
57 WXDLLIMPEXP_DATA_BASE(wxCSConv) wxConvLocal((const wxChar *)NULL);
58 WXDLLIMPEXP_DATA_BASE(wxCSConv) wxConvISO8859_1(_T("iso-8859-1"));
59 #else
60 // stand-ins in absence of wchar_t
61 WXDLLIMPEXP_DATA_BASE(wxMBConv) wxConvLibc,
62 wxConvFile,
63 wxConvISO8859_1,
64 wxConvLocal,
65 wxConvUTF8;
66 #endif // wxUSE_WCHAR_T
67
68 WXDLLIMPEXP_DATA_BASE(wxMBConv *) wxConvCurrent = &wxConvLibc;
69
70 class wxStrConvModule: public wxModule
71 {
72 public:
73 wxStrConvModule() : wxModule() { }
74 virtual bool OnInit() { return TRUE; }
75 virtual void OnExit()
76 {
77 #if wxUSE_WCHAR_T
78 wxConvLocal.Clear();
79 wxConvISO8859_1.Clear();
80 #endif
81 }
82
83 DECLARE_DYNAMIC_CLASS(wxStrConvModule)
84 };
85
86 IMPLEMENT_DYNAMIC_CLASS(wxStrConvModule, wxModule)
87
88
89 // ----------------------------------------------------------------------------
90 // headers
91 // ----------------------------------------------------------------------------
92
93 #if wxUSE_WCHAR_T
94
95 #ifdef __SALFORDC__
96 #include <clib.h>
97 #endif
98
99 #ifdef HAVE_ICONV
100 #include <iconv.h>
101 #endif
102
103 #include "wx/encconv.h"
104 #include "wx/fontmap.h"
105
106 // ----------------------------------------------------------------------------
107 // macros
108 // ----------------------------------------------------------------------------
109
110 #define BSWAP_UCS4(str, len) { unsigned _c; for (_c=0; _c<len; _c++) str[_c]=wxUINT32_SWAP_ALWAYS(str[_c]); }
111 #define BSWAP_UTF16(str, len) { unsigned _c; for (_c=0; _c<len; _c++) str[_c]=wxUINT16_SWAP_ALWAYS(str[_c]); }
112
113 // under Unix SIZEOF_WCHAR_T is defined by configure, but under other platforms
114 // it might be not defined - assume the most common value
115 #ifndef SIZEOF_WCHAR_T
116 #define SIZEOF_WCHAR_T 2
117 #endif // !defined(SIZEOF_WCHAR_T)
118
119 #if SIZEOF_WCHAR_T == 4
120 #define WC_NAME "UCS4"
121 #define WC_BSWAP BSWAP_UCS4
122 #ifdef WORDS_BIGENDIAN
123 #define WC_NAME_BEST "UCS-4BE"
124 #else
125 #define WC_NAME_BEST "UCS-4LE"
126 #endif
127 #elif SIZEOF_WCHAR_T == 2
128 #define WC_NAME "UTF16"
129 #define WC_BSWAP BSWAP_UTF16
130 #define WC_UTF16
131 #ifdef WORDS_BIGENDIAN
132 #define WC_NAME_BEST "UTF-16BE"
133 #else
134 #define WC_NAME_BEST "UTF-16LE"
135 #endif
136 #else // sizeof(wchar_t) != 2 nor 4
137 // I don't know what to do about this
138 #error "Weird sizeof(wchar_t): please report your platform details to wx-users mailing list"
139 #endif
140
141 // ============================================================================
142 // implementation
143 // ============================================================================
144
145 // ----------------------------------------------------------------------------
146 // UTF-16 en/decoding to/from UCS-4
147 // ----------------------------------------------------------------------------
148
149
150 static size_t encode_utf16(wxUint32 input, wxUint16 *output)
151 {
152 if (input<=0xffff)
153 {
154 if (output) *output++ = (wxUint16) input;
155 return 1;
156 }
157 else if (input>=0x110000)
158 {
159 return (size_t)-1;
160 }
161 else
162 {
163 if (output)
164 {
165 *output++ = (wxUint16) ((input >> 10)+0xd7c0);
166 *output++ = (wxUint16) ((input&0x3ff)+0xdc00);
167 }
168 return 2;
169 }
170 }
171
172 static size_t decode_utf16(const wxUint16* input, wxUint32& output)
173 {
174 if ((*input<0xd800) || (*input>0xdfff))
175 {
176 output = *input;
177 return 1;
178 }
179 else if ((input[1]<0xdc00) || (input[1]>=0xdfff))
180 {
181 output = *input;
182 return (size_t)-1;
183 }
184 else
185 {
186 output = ((input[0] - 0xd7c0) << 10) + (input[1] - 0xdc00);
187 return 2;
188 }
189 }
190
191
192 // ----------------------------------------------------------------------------
193 // wxMBConv
194 // ----------------------------------------------------------------------------
195
196 #define IGNORE_LIBC 0
197
198 wxMBConv::~wxMBConv()
199 {
200 // nothing to do here
201 }
202
203 size_t wxMBConv::MB2WC(wchar_t *buf, const char *psz, size_t n) const
204 {
205 #if IGNORE_LIBC
206 if (buf)
207 {
208 for (size_t i = 0; i < strlen( psz )+1; i++)
209 buf[i] = (wchar_t) psz[i];
210 return strlen( psz );
211 }
212 else
213 {
214 return strlen( psz );
215 }
216 #else
217 return wxMB2WC(buf, psz, n);
218 #endif
219 }
220
221 size_t wxMBConv::WC2MB(char *buf, const wchar_t *psz, size_t n) const
222 {
223 #if IGNORE_LIBC
224 if (buf)
225 {
226 for (size_t i = 0; i < wxStrlen( psz )+1; i++)
227 buf[i] = (char) psz[i];
228 return wxStrlen( psz );
229 }
230 else
231 {
232 return wxStrlen( psz );
233 }
234 #else
235 return wxWC2MB(buf, psz, n);
236 #endif
237 }
238
239 const wxWCharBuffer wxMBConv::cMB2WC(const char *psz) const
240 {
241 if ( psz )
242 {
243 // calculate the length of the buffer needed first
244 size_t nLen = MB2WC(NULL, psz, 0);
245 if ( nLen != (size_t)-1 )
246 {
247 // now do the actual conversion
248 wxWCharBuffer buf(nLen);
249 MB2WC(buf.data(), psz, nLen + 1); // with the trailing NUL
250
251 return buf;
252 }
253 }
254
255 wxWCharBuffer buf((wchar_t *)NULL);
256
257 return buf;
258 }
259
260 const wxCharBuffer wxMBConv::cWC2MB(const wchar_t *pwz) const
261 {
262 if ( pwz )
263 {
264 size_t nLen = WC2MB(NULL, pwz, 0);
265 if ( nLen != (size_t)-1 )
266 {
267 wxCharBuffer buf(nLen+3); // space for a wxUint32 trailing zero
268 WC2MB(buf.data(), pwz, nLen + 4);
269
270 return buf;
271 }
272 }
273
274 wxCharBuffer buf((char *)NULL);
275
276 return buf;
277 }
278
279 // ----------------------------------------------------------------------------
280 // UTF-7
281 // ----------------------------------------------------------------------------
282
283 WXDLLIMPEXP_DATA_BASE(wxMBConvUTF7) wxConvUTF7;
284
285 #if 0
286 static char utf7_setD[]="ABCDEFGHIJKLMNOPQRSTUVWXYZ"
287 "abcdefghijklmnopqrstuvwxyz"
288 "0123456789'(),-./:?";
289 static char utf7_setO[]="!\"#$%&*;<=>@[]^_`{|}";
290 static char utf7_setB[]="ABCDEFGHIJKLMNOPQRSTUVWXYZ"
291 "abcdefghijklmnopqrstuvwxyz"
292 "0123456789+/";
293 #endif
294
295 // TODO: write actual implementations of UTF-7 here
296 size_t wxMBConvUTF7::MB2WC(wchar_t * WXUNUSED(buf),
297 const char * WXUNUSED(psz),
298 size_t WXUNUSED(n)) const
299 {
300 return 0;
301 }
302
303 size_t wxMBConvUTF7::WC2MB(char * WXUNUSED(buf),
304 const wchar_t * WXUNUSED(psz),
305 size_t WXUNUSED(n)) const
306 {
307 return 0;
308 }
309
310 // ----------------------------------------------------------------------------
311 // UTF-8
312 // ----------------------------------------------------------------------------
313
314 WXDLLIMPEXP_DATA_BASE(wxMBConvUTF8) wxConvUTF8;
315
316 static wxUint32 utf8_max[]=
317 { 0x7f, 0x7ff, 0xffff, 0x1fffff, 0x3ffffff, 0x7fffffff, 0xffffffff };
318
319 size_t wxMBConvUTF8::MB2WC(wchar_t *buf, const char *psz, size_t n) const
320 {
321 size_t len = 0;
322
323 while (*psz && ((!buf) || (len < n)))
324 {
325 unsigned char cc = *psz++, fc = cc;
326 unsigned cnt;
327 for (cnt = 0; fc & 0x80; cnt++)
328 fc <<= 1;
329 if (!cnt)
330 {
331 // plain ASCII char
332 if (buf)
333 *buf++ = cc;
334 len++;
335 }
336 else
337 {
338 cnt--;
339 if (!cnt)
340 {
341 // invalid UTF-8 sequence
342 return (size_t)-1;
343 }
344 else
345 {
346 unsigned ocnt = cnt - 1;
347 wxUint32 res = cc & (0x3f >> cnt);
348 while (cnt--)
349 {
350 cc = *psz++;
351 if ((cc & 0xC0) != 0x80)
352 {
353 // invalid UTF-8 sequence
354 return (size_t)-1;
355 }
356 res = (res << 6) | (cc & 0x3f);
357 }
358 if (res <= utf8_max[ocnt])
359 {
360 // illegal UTF-8 encoding
361 return (size_t)-1;
362 }
363 #ifdef WC_UTF16
364 size_t pa = encode_utf16(res, buf);
365 if (pa == (size_t)-1)
366 return (size_t)-1;
367 if (buf)
368 buf += pa;
369 len += pa;
370 #else // !WC_UTF16
371 if (buf)
372 *buf++ = res;
373 len++;
374 #endif // WC_UTF16/!WC_UTF16
375 }
376 }
377 }
378 if (buf && (len < n))
379 *buf = 0;
380 return len;
381 }
382
383 size_t wxMBConvUTF8::WC2MB(char *buf, const wchar_t *psz, size_t n) const
384 {
385 size_t len = 0;
386
387 while (*psz && ((!buf) || (len < n)))
388 {
389 wxUint32 cc;
390 #ifdef WC_UTF16
391 size_t pa = decode_utf16(psz, cc);
392 psz += (pa == (size_t)-1) ? 1 : pa;
393 #else
394 cc=(*psz++) & 0x7fffffff;
395 #endif
396 unsigned cnt;
397 for (cnt = 0; cc > utf8_max[cnt]; cnt++) {}
398 if (!cnt)
399 {
400 // plain ASCII char
401 if (buf)
402 *buf++ = (char) cc;
403 len++;
404 }
405
406 else
407 {
408 len += cnt + 1;
409 if (buf)
410 {
411 *buf++ = (char) ((-128 >> cnt) | ((cc >> (cnt * 6)) & (0x3f >> cnt)));
412 while (cnt--)
413 *buf++ = (char) (0x80 | ((cc >> (cnt * 6)) & 0x3f));
414 }
415 }
416 }
417
418 if (buf && (len<n)) *buf = 0;
419
420 return len;
421 }
422
423
424
425
426 // ----------------------------------------------------------------------------
427 // UTF-16
428 // ----------------------------------------------------------------------------
429
430 #ifdef WORDS_BIGENDIAN
431 #define wxMBConvUTF16straight wxMBConvUTF16BE
432 #define wxMBConvUTF16swap wxMBConvUTF16LE
433 #else
434 #define wxMBConvUTF16swap wxMBConvUTF16BE
435 #define wxMBConvUTF16straight wxMBConvUTF16LE
436 #endif
437
438
439 WXDLLIMPEXP_DATA_BASE(wxMBConvUTF16LE) wxConvUTF16LE;
440 WXDLLIMPEXP_DATA_BASE(wxMBConvUTF16BE) wxConvUTF16BE;
441
442
443
444
445
446 #ifdef WC_UTF16
447
448
449 // copy 16bit MB to 16bit String
450 size_t wxMBConvUTF16straight::MB2WC(wchar_t *buf, const char *psz, size_t n) const
451 {
452 size_t len=0;
453
454 while (*(wxUint16*)psz && (!buf || len < n))
455 {
456 if (buf)
457 *buf++ = *(wxUint16*)psz;
458 len++;
459
460 psz += sizeof(wxUint16);
461 }
462 if (buf && len<n) *buf=0;
463
464 return len;
465 }
466
467
468 // copy 16bit String to 16bit MB
469 size_t wxMBConvUTF16straight::WC2MB(char *buf, const wchar_t *psz, size_t n) const
470 {
471 size_t len=0;
472
473 while (*psz && (!buf || len < n))
474 {
475 if (buf)
476 {
477 *(wxUint16*)buf = *psz;
478 buf += sizeof(wxUint16);
479 }
480 len += sizeof(wxUint16);
481 psz++;
482 }
483 if (buf && len<=n-sizeof(wxUint16)) *(wxUint16*)buf=0;
484
485 return len;
486 }
487
488
489 // swap 16bit MB to 16bit String
490 size_t wxMBConvUTF16swap::MB2WC(wchar_t *buf, const char *psz, size_t n) const
491 {
492 size_t len=0;
493
494 while (*(wxUint16*)psz && (!buf || len < n))
495 {
496 if (buf)
497 {
498 ((char *)buf)[0] = psz[1];
499 ((char *)buf)[1] = psz[0];
500 buf++;
501 }
502 len++;
503 psz += sizeof(wxUint16);
504 }
505 if (buf && len<n) *buf=0;
506
507 return len;
508 }
509
510
511 // swap 16bit MB to 16bit String
512 size_t wxMBConvUTF16swap::WC2MB(char *buf, const wchar_t *psz, size_t n) const
513 {
514 size_t len=0;
515
516 while (*psz && (!buf || len < n))
517 {
518 if (buf)
519 {
520 *buf++ = ((char*)psz)[1];
521 *buf++ = ((char*)psz)[0];
522 }
523 len += sizeof(wxUint16);
524 psz++;
525 }
526 if (buf && len<=n-sizeof(wxUint16)) *(wxUint16*)buf=0;
527
528 return len;
529 }
530
531
532 #else // WC_UTF16
533
534
535 // copy 16bit MB to 32bit String
536 size_t wxMBConvUTF16straight::MB2WC(wchar_t *buf, const char *psz, size_t n) const
537 {
538 size_t len=0;
539
540 while (*(wxUint16*)psz && (!buf || len < n))
541 {
542 wxUint32 cc;
543 size_t pa=decode_utf16((wxUint16*)psz, cc);
544 if (pa == (size_t)-1)
545 return pa;
546
547 if (buf)
548 *buf++ = cc;
549 len++;
550 psz += pa * sizeof(wxUint16);
551 }
552 if (buf && len<n) *buf=0;
553
554 return len;
555 }
556
557
558 // copy 32bit String to 16bit MB
559 size_t wxMBConvUTF16straight::WC2MB(char *buf, const wchar_t *psz, size_t n) const
560 {
561 size_t len=0;
562
563 while (*psz && (!buf || len < n))
564 {
565 wxUint16 cc[2];
566 size_t pa=encode_utf16(*psz, cc);
567
568 if (pa == (size_t)-1)
569 return pa;
570
571 if (buf)
572 {
573 *((wxUint16*)buf)++ = cc[0];
574 if (pa > 1)
575 *((wxUint16*)buf)++ = cc[1];
576 }
577
578 len += pa*sizeof(wxUint16);
579 psz++;
580 }
581 if (buf && len<=n-sizeof(wxUint16)) *(wxUint16*)buf=0;
582
583 return len;
584 }
585
586
587 // swap 16bit MB to 32bit String
588 size_t wxMBConvUTF16swap::MB2WC(wchar_t *buf, const char *psz, size_t n) const
589 {
590 size_t len=0;
591
592 while (*(wxUint16*)psz && (!buf || len < n))
593 {
594 wxUint32 cc;
595 char tmp[4];
596 tmp[0]=psz[1]; tmp[1]=psz[0];
597 tmp[2]=psz[3]; tmp[3]=psz[2];
598
599 size_t pa=decode_utf16((wxUint16*)tmp, cc);
600 if (pa == (size_t)-1)
601 return pa;
602
603 if (buf)
604 *buf++ = cc;
605
606 len++;
607 psz += pa * sizeof(wxUint16);
608 }
609 if (buf && len<n) *buf=0;
610
611 return len;
612 }
613
614
615 // swap 32bit String to 16bit MB
616 size_t wxMBConvUTF16swap::WC2MB(char *buf, const wchar_t *psz, size_t n) const
617 {
618 size_t len=0;
619
620 while (*psz && (!buf || len < n))
621 {
622 wxUint16 cc[2];
623 size_t pa=encode_utf16(*psz, cc);
624
625 if (pa == (size_t)-1)
626 return pa;
627
628 if (buf)
629 {
630 *buf++ = ((char*)cc)[1];
631 *buf++ = ((char*)cc)[0];
632 if (pa > 1)
633 {
634 *buf++ = ((char*)cc)[3];
635 *buf++ = ((char*)cc)[2];
636 }
637 }
638
639 len += pa*sizeof(wxUint16);
640 psz++;
641 }
642 if (buf && len<=n-sizeof(wxUint16)) *(wxUint16*)buf=0;
643
644 return len;
645 }
646
647 #endif // WC_UTF16
648
649
650 // ----------------------------------------------------------------------------
651 // UTF-32
652 // ----------------------------------------------------------------------------
653
654 #ifdef WORDS_BIGENDIAN
655 #define wxMBConvUTF32straight wxMBConvUTF32BE
656 #define wxMBConvUTF32swap wxMBConvUTF32LE
657 #else
658 #define wxMBConvUTF32swap wxMBConvUTF32BE
659 #define wxMBConvUTF32straight wxMBConvUTF32LE
660 #endif
661
662
663 WXDLLIMPEXP_DATA_BASE(wxMBConvUTF32LE) wxConvUTF32LE;
664 WXDLLIMPEXP_DATA_BASE(wxMBConvUTF32BE) wxConvUTF32BE;
665
666
667 #ifdef WC_UTF16
668
669 // copy 32bit MB to 16bit String
670 size_t wxMBConvUTF32straight::MB2WC(wchar_t *buf, const char *psz, size_t n) const
671 {
672 size_t len=0;
673
674 while (*(wxUint32*)psz && (!buf || len < n))
675 {
676 wxUint16 cc[2];
677
678 size_t pa=encode_utf16(*(wxUint32*)psz, cc);
679 if (pa == (size_t)-1)
680 return pa;
681
682 if (buf)
683 {
684 *buf++ = cc[0];
685 if (pa > 1)
686 *buf++ = cc[1];
687 }
688 len += pa;
689 psz += sizeof(wxUint32);
690 }
691 if (buf && len<n) *buf=0;
692
693 return len;
694 }
695
696
697 // copy 16bit String to 32bit MB
698 size_t wxMBConvUTF32straight::WC2MB(char *buf, const wchar_t *psz, size_t n) const
699 {
700 size_t len=0;
701
702 while (*psz && (!buf || len < n))
703 {
704 wxUint32 cc;
705
706 size_t pa=decode_utf16(psz, cc);
707 if (pa == (size_t)-1)
708 return pa;
709
710 if (buf)
711 {
712 *(wxUint32*)buf = cc;
713 buf += sizeof(wxUint32);
714 }
715 len += sizeof(wxUint32);
716 psz += pa;
717 }
718 if (buf && len<=n-sizeof(wxUint32)) *(wxUint32*)buf=0;
719
720 return len;
721 }
722
723
724
725 // swap 32bit MB to 16bit String
726 size_t wxMBConvUTF32swap::MB2WC(wchar_t *buf, const char *psz, size_t n) const
727 {
728 size_t len=0;
729
730 while (*(wxUint32*)psz && (!buf || len < n))
731 {
732 char tmp[4];
733 tmp[0] = psz[3]; tmp[1] = psz[2];
734 tmp[2] = psz[1]; tmp[3] = psz[0];
735
736
737 wxUint16 cc[2];
738
739 size_t pa=encode_utf16(*(wxUint32*)tmp, cc);
740 if (pa == (size_t)-1)
741 return pa;
742
743 if (buf)
744 {
745 *buf++ = cc[0];
746 if (pa > 1)
747 *buf++ = cc[1];
748 }
749 len += pa;
750 psz += sizeof(wxUint32);
751 }
752 if (buf && len<n) *buf=0;
753
754 return len;
755 }
756
757
758 // swap 16bit String to 32bit MB
759 size_t wxMBConvUTF32swap::WC2MB(char *buf, const wchar_t *psz, size_t n) const
760 {
761 size_t len=0;
762
763 while (*psz && (!buf || len < n))
764 {
765 char cc[4];
766
767 size_t pa=decode_utf16(psz, *(wxUint32*)cc);
768 if (pa == (size_t)-1)
769 return pa;
770
771 if (buf)
772 {
773 *buf++ = cc[3];
774 *buf++ = cc[2];
775 *buf++ = cc[1];
776 *buf++ = cc[0];
777 }
778 len += sizeof(wxUint32);
779 psz += pa;
780 }
781 if (buf && len<=n-sizeof(wxUint32)) *(wxUint32*)buf=0;
782
783 return len;
784 }
785
786 #else // WC_UTF16
787
788
789 // copy 32bit MB to 32bit String
790 size_t wxMBConvUTF32straight::MB2WC(wchar_t *buf, const char *psz, size_t n) const
791 {
792 size_t len=0;
793
794 while (*(wxUint32*)psz && (!buf || len < n))
795 {
796 if (buf)
797 *buf++ = *(wxUint32*)psz;
798 len++;
799 psz += sizeof(wxUint32);
800 }
801 if (buf && len<n) *buf=0;
802
803 return len;
804 }
805
806
807 // copy 32bit String to 32bit MB
808 size_t wxMBConvUTF32straight::WC2MB(char *buf, const wchar_t *psz, size_t n) const
809 {
810 size_t len=0;
811
812 while (*psz && (!buf || len < n))
813 {
814 if (buf)
815 {
816 *(wxUint32*)buf = *psz;
817 buf += sizeof(wxUint32);
818 }
819
820 len += sizeof(wxUint32);
821 psz++;
822 }
823
824 if (buf && len<=n-sizeof(wxUint32)) *(wxUint32*)buf=0;
825
826 return len;
827 }
828
829
830 // swap 32bit MB to 32bit String
831 size_t wxMBConvUTF32swap::MB2WC(wchar_t *buf, const char *psz, size_t n) const
832 {
833 size_t len=0;
834
835 while (*(wxUint32*)psz && (!buf || len < n))
836 {
837 if (buf)
838 {
839 ((char *)buf)[0] = psz[3];
840 ((char *)buf)[1] = psz[2];
841 ((char *)buf)[2] = psz[1];
842 ((char *)buf)[3] = psz[0];
843 buf++;
844 }
845 len++;
846 psz += sizeof(wxUint32);
847 }
848 if (buf && len<n) *buf=0;
849
850 return len;
851 }
852
853
854 // swap 32bit String to 32bit MB
855 size_t wxMBConvUTF32swap::WC2MB(char *buf, const wchar_t *psz, size_t n) const
856 {
857 size_t len=0;
858
859 while (*psz && (!buf || len < n))
860 {
861 if (buf)
862 {
863 *buf++ = ((char *)psz)[3];
864 *buf++ = ((char *)psz)[2];
865 *buf++ = ((char *)psz)[1];
866 *buf++ = ((char *)psz)[0];
867 }
868 len += sizeof(wxUint32);
869 psz++;
870 }
871 if (buf && len<=n-sizeof(wxUint32)) *(wxUint32*)buf=0;
872
873 return len;
874 }
875
876
877 #endif // WC_UTF16
878
879
880 // ============================================================================
881 // wxCharacterSet and derived classes
882 // ============================================================================
883
884 // ----------------------------------------------------------------------------
885 // wxCharacterSet is the ABC for the classes below
886 // ----------------------------------------------------------------------------
887
888 class wxCharacterSet
889 {
890 public:
891 wxCharacterSet() { }
892 virtual ~wxCharacterSet() {}
893
894 virtual size_t MB2WC(wchar_t *buf, const char *psz, size_t n) = 0;
895 virtual size_t WC2MB(char *buf, const wchar_t *psz, size_t n) = 0;
896 virtual bool usable() const = 0;
897 };
898
899 // ----------------------------------------------------------------------------
900 // ID_CharSet: implementation of wxCharacterSet using an existing wxMBConv
901 // ----------------------------------------------------------------------------
902
903 class ID_CharSet : public wxCharacterSet
904 {
905 public:
906 ID_CharSet(wxMBConv *cnv) : work(cnv) {}
907
908 size_t MB2WC(wchar_t *buf, const char *psz, size_t n)
909 { return work ? work->MB2WC(buf,psz,n) : (size_t)-1; }
910
911 size_t WC2MB(char *buf, const wchar_t *psz, size_t n)
912 { return work ? work->WC2MB(buf,psz,n) : (size_t)-1; }
913
914 bool usable() const
915 { return work!=NULL; }
916 public:
917 wxMBConv*work;
918 };
919
920
921 // ============================================================================
922 // The classes doing conversion using the iconv_xxx() functions
923 // ============================================================================
924
925 #ifdef HAVE_ICONV
926
927 // VS: glibc 2.1.3 is broken in that iconv() conversion to/from UCS4 fails with E2BIG
928 // if output buffer is _exactly_ as big as needed. Such case is (unless there's
929 // yet another bug in glibc) the only case when iconv() returns with (size_t)-1
930 // (which means error) and says there are 0 bytes left in the input buffer --
931 // when _real_ error occurs, bytes-left-in-input buffer is non-zero. Hence,
932 // this alternative test for iconv() failure.
933 // [This bug does not appear in glibc 2.2.]
934 #if defined(__GLIBC__) && __GLIBC__ == 2 && __GLIBC_MINOR__ <= 1
935 #define ICONV_FAILED(cres, bufLeft) ((cres == (size_t)-1) && \
936 (errno != E2BIG || bufLeft != 0))
937 #else
938 #define ICONV_FAILED(cres, bufLeft) (cres == (size_t)-1)
939 #endif
940
941 #define ICONV_CHAR_CAST(x) ((ICONV_CONST char **)(x))
942
943 // ----------------------------------------------------------------------------
944 // IC_CharSet: encapsulates an iconv character set
945 // ----------------------------------------------------------------------------
946
947 class IC_CharSet : public wxCharacterSet
948 {
949 public:
950 IC_CharSet(const wxChar *name);
951 virtual ~IC_CharSet();
952
953 virtual size_t MB2WC(wchar_t *buf, const char *psz, size_t n);
954 virtual size_t WC2MB(char *buf, const wchar_t *psz, size_t n);
955
956 bool usable() const
957 { return (m2w != (iconv_t)-1) && (w2m != (iconv_t)-1); }
958
959 protected:
960 // the iconv handlers used to translate from multibyte to wide char and in
961 // the other direction
962 iconv_t m2w,
963 w2m;
964
965 private:
966 // the name (for iconv_open()) of a wide char charset - if none is
967 // available on this machine, it will remain NULL
968 static const char *ms_wcCharsetName;
969
970 // true if the wide char encoding we use (i.e. ms_wcCharsetName) has
971 // different endian-ness than the native one
972 static bool ms_wcNeedsSwap;
973 };
974
975 const char *IC_CharSet::ms_wcCharsetName = NULL;
976 bool IC_CharSet::ms_wcNeedsSwap = FALSE;
977
978 IC_CharSet::IC_CharSet(const wxChar *name)
979 {
980 // Do it the hard way
981 char cname[100];
982 for (size_t i = 0; i < wxStrlen(name)+1; i++)
983 cname[i] = (char) name[i];
984
985 // check for charset that represents wchar_t:
986 if (ms_wcCharsetName == NULL)
987 {
988 ms_wcNeedsSwap = FALSE;
989
990 // try charset with explicit bytesex info (e.g. "UCS-4LE"):
991 ms_wcCharsetName = WC_NAME_BEST;
992 m2w = iconv_open(ms_wcCharsetName, cname);
993
994 if (m2w == (iconv_t)-1)
995 {
996 // try charset w/o bytesex info (e.g. "UCS4")
997 // and check for bytesex ourselves:
998 ms_wcCharsetName = WC_NAME;
999 m2w = iconv_open(ms_wcCharsetName, cname);
1000
1001 // last bet, try if it knows WCHAR_T pseudo-charset
1002 if (m2w == (iconv_t)-1)
1003 {
1004 ms_wcCharsetName = "WCHAR_T";
1005 m2w = iconv_open(ms_wcCharsetName, cname);
1006 }
1007
1008 if (m2w != (iconv_t)-1)
1009 {
1010 char buf[2], *bufPtr;
1011 wchar_t wbuf[2], *wbufPtr;
1012 size_t insz, outsz;
1013 size_t res;
1014
1015 buf[0] = 'A';
1016 buf[1] = 0;
1017 wbuf[0] = 0;
1018 insz = 2;
1019 outsz = SIZEOF_WCHAR_T * 2;
1020 wbufPtr = wbuf;
1021 bufPtr = buf;
1022
1023 res = iconv(m2w, ICONV_CHAR_CAST(&bufPtr), &insz,
1024 (char**)&wbufPtr, &outsz);
1025
1026 if (ICONV_FAILED(res, insz))
1027 {
1028 ms_wcCharsetName = NULL;
1029 wxLogLastError(wxT("iconv"));
1030 wxLogError(_("Conversion to charset '%s' doesn't work."), name);
1031 }
1032 else
1033 {
1034 ms_wcNeedsSwap = wbuf[0] != (wchar_t)buf[0];
1035 }
1036 }
1037 else
1038 {
1039 ms_wcCharsetName = NULL;
1040
1041 // VS: we must not output an error here, since wxWindows will safely
1042 // fall back to using wxEncodingConverter.
1043 wxLogTrace(wxT("strconv"), wxT("Impossible to convert to/from charset '%s' with iconv, falling back to wxEncodingConverter."), name);
1044 //wxLogError(
1045 }
1046 }
1047 wxLogTrace(wxT("strconv"), wxT("wchar_t charset is '%s', needs swap: %i"), ms_wcCharsetName, ms_wcNeedsSwap);
1048 }
1049 else // we already have ms_wcCharsetName
1050 {
1051 m2w = iconv_open(ms_wcCharsetName, cname);
1052 }
1053
1054 // NB: don't ever pass NULL to iconv_open(), it may crash!
1055 if ( ms_wcCharsetName )
1056 {
1057 w2m = iconv_open( cname, ms_wcCharsetName);
1058 }
1059 else
1060 {
1061 w2m = (iconv_t)-1;
1062 }
1063 }
1064
1065 IC_CharSet::~IC_CharSet()
1066 {
1067 if ( m2w != (iconv_t)-1 )
1068 iconv_close(m2w);
1069 if ( w2m != (iconv_t)-1 )
1070 iconv_close(w2m);
1071 }
1072
1073 size_t IC_CharSet::MB2WC(wchar_t *buf, const char *psz, size_t n)
1074 {
1075 size_t inbuf = strlen(psz);
1076 size_t outbuf = n * SIZEOF_WCHAR_T;
1077 size_t res, cres;
1078 // VS: Use these instead of psz, buf because iconv() modifies its arguments:
1079 wchar_t *bufPtr = buf;
1080 const char *pszPtr = psz;
1081
1082 if (buf)
1083 {
1084 // have destination buffer, convert there
1085 cres = iconv(m2w,
1086 ICONV_CHAR_CAST(&pszPtr), &inbuf,
1087 (char**)&bufPtr, &outbuf);
1088 res = n - (outbuf / SIZEOF_WCHAR_T);
1089
1090 if (ms_wcNeedsSwap)
1091 {
1092 // convert to native endianness
1093 WC_BSWAP(buf /* _not_ bufPtr */, res)
1094 }
1095
1096 // NB: iconv was given only strlen(psz) characters on input, and so
1097 // it couldn't convert the trailing zero. Let's do it ourselves
1098 // if there's some room left for it in the output buffer.
1099 if (res < n)
1100 buf[res] = 0;
1101 }
1102 else
1103 {
1104 // no destination buffer... convert using temp buffer
1105 // to calculate destination buffer requirement
1106 wchar_t tbuf[8];
1107 res = 0;
1108 do {
1109 bufPtr = tbuf;
1110 outbuf = 8*SIZEOF_WCHAR_T;
1111
1112 cres = iconv(m2w,
1113 ICONV_CHAR_CAST(&pszPtr), &inbuf,
1114 (char**)&bufPtr, &outbuf );
1115
1116 res += 8-(outbuf/SIZEOF_WCHAR_T);
1117 } while ((cres==(size_t)-1) && (errno==E2BIG));
1118 }
1119
1120 if (ICONV_FAILED(cres, inbuf))
1121 {
1122 //VS: it is ok if iconv fails, hence trace only
1123 wxLogTrace(wxT("strconv"), wxT("iconv failed: %s"), wxSysErrorMsg(wxSysErrorCode()));
1124 return (size_t)-1;
1125 }
1126
1127 return res;
1128 }
1129
1130 size_t IC_CharSet::WC2MB(char *buf, const wchar_t *psz, size_t n)
1131 {
1132 size_t inbuf = wxWcslen(psz) * SIZEOF_WCHAR_T;
1133 size_t outbuf = n;
1134 size_t res, cres;
1135
1136 wchar_t *tmpbuf = 0;
1137
1138 if (ms_wcNeedsSwap)
1139 {
1140 // need to copy to temp buffer to switch endianness
1141 // this absolutely doesn't rock!
1142 // (no, doing WC_BSWAP twice on the original buffer won't help, as it
1143 // could be in read-only memory, or be accessed in some other thread)
1144 tmpbuf=(wchar_t*)malloc((inbuf+1)*SIZEOF_WCHAR_T);
1145 memcpy(tmpbuf,psz,(inbuf+1)*SIZEOF_WCHAR_T);
1146 WC_BSWAP(tmpbuf, inbuf)
1147 psz=tmpbuf;
1148 }
1149
1150 if (buf)
1151 {
1152 // have destination buffer, convert there
1153 cres = iconv( w2m, ICONV_CHAR_CAST(&psz), &inbuf, &buf, &outbuf );
1154
1155 res = n-outbuf;
1156
1157 // NB: iconv was given only wcslen(psz) characters on input, and so
1158 // it couldn't convert the trailing zero. Let's do it ourselves
1159 // if there's some room left for it in the output buffer.
1160 if (res < n)
1161 buf[0] = 0;
1162 }
1163 else
1164 {
1165 // no destination buffer... convert using temp buffer
1166 // to calculate destination buffer requirement
1167 char tbuf[16];
1168 res = 0;
1169 do {
1170 buf = tbuf; outbuf = 16;
1171
1172 cres = iconv( w2m, ICONV_CHAR_CAST(&psz), &inbuf, &buf, &outbuf );
1173
1174 res += 16 - outbuf;
1175 } while ((cres==(size_t)-1) && (errno==E2BIG));
1176 }
1177
1178 if (ms_wcNeedsSwap)
1179 {
1180 free(tmpbuf);
1181 }
1182
1183 if (ICONV_FAILED(cres, inbuf))
1184 {
1185 //VS: it is ok if iconv fails, hence trace only
1186 wxLogTrace(wxT("strconv"), wxT("iconv failed: %s"), wxSysErrorMsg(wxSysErrorCode()));
1187 return (size_t)-1;
1188 }
1189
1190 return res;
1191 }
1192
1193 #endif // HAVE_ICONV
1194
1195 // ============================================================================
1196 // Win32 conversion classes
1197 // ============================================================================
1198
1199 #if defined(__WIN32__) && !defined(__WXMICROWIN__) && !defined(__WXUNIVERSAL__)
1200
1201 // from utils.cpp
1202 extern WXDLLIMPEXP_BASE long wxCharsetToCodepage(const wxChar *charset);
1203 extern WXDLLIMPEXP_BASE long wxEncodingToCodepage(wxFontEncoding encoding);
1204
1205 class CP_CharSet : public wxCharacterSet
1206 {
1207 public:
1208 CP_CharSet(const wxChar* name)
1209 {
1210 m_CodePage = wxCharsetToCodepage(name);
1211 }
1212
1213 CP_CharSet(wxFontEncoding encoding)
1214 {
1215 m_CodePage = wxEncodingToCodepage(encoding);
1216 }
1217
1218 size_t MB2WC(wchar_t *buf, const char *psz, size_t n)
1219 {
1220 const size_t len = ::MultiByteToWideChar
1221 (
1222 m_CodePage, // code page
1223 0, // flags (none)
1224 psz, // input string
1225 -1, // its length (NUL-terminated)
1226 buf, // output string
1227 buf ? n : 0 // size of output buffer
1228 );
1229
1230 // note that it returns # of written chars for buf != NULL and *size*
1231 // of the needed buffer for buf == NULL
1232 return len ? (buf ? len : len - 1) : (size_t)-1;
1233 }
1234
1235 size_t WC2MB(char *buf, const wchar_t *psz, size_t n)
1236 {
1237 const size_t len = ::WideCharToMultiByte
1238 (
1239 m_CodePage, // code page
1240 0, // flags (none)
1241 psz, // input string
1242 -1, // it is (wide) NUL-terminated
1243 buf, // output buffer
1244 buf ? n : 0, // and its size
1245 NULL, // default "replacement" char
1246 NULL // [out] was it used?
1247 );
1248
1249 // see the comment above!
1250 return len ? (buf ? len : len - 1) : (size_t)-1;
1251 }
1252
1253 bool usable() const
1254 { return m_CodePage != -1; }
1255
1256 public:
1257 long m_CodePage;
1258 };
1259 #endif // defined(__WIN32__) && !defined(__WXMICROWIN__) && !defined(__WXUNIVERSAL__)
1260
1261 // ============================================================================
1262 // wxEncodingConverter based conversion classes
1263 // ============================================================================
1264
1265 #if wxUSE_FONTMAP
1266
1267 class EC_CharSet : public wxCharacterSet
1268 {
1269 private:
1270 void Init()
1271 {
1272 m_ok = m2w.Init(m_enc, wxFONTENCODING_UNICODE) &&
1273 w2m.Init(wxFONTENCODING_UNICODE, m_enc);
1274 }
1275
1276 public:
1277 // temporarily just use wxEncodingConverter stuff,
1278 // so that it works while a better implementation is built
1279 EC_CharSet(const wxChar* name)
1280 {
1281 if (name)
1282 m_enc = wxFontMapper::Get()->CharsetToEncoding(name, FALSE);
1283 else
1284 m_enc = wxFONTENCODING_SYSTEM;
1285
1286 Init();
1287 }
1288
1289 EC_CharSet(wxFontEncoding enc)
1290 {
1291 m_enc = enc;
1292
1293 Init();
1294 }
1295
1296 size_t MB2WC(wchar_t *buf, const char *psz, size_t WXUNUSED(n))
1297 {
1298 size_t inbuf = strlen(psz);
1299 if (buf)
1300 m2w.Convert(psz,buf);
1301 return inbuf;
1302 }
1303
1304 size_t WC2MB(char *buf, const wchar_t *psz, size_t WXUNUSED(n))
1305 {
1306 const size_t inbuf = wxWcslen(psz);
1307 if (buf)
1308 w2m.Convert(psz,buf);
1309
1310 return inbuf;
1311 }
1312
1313 bool usable() const { return m_ok; }
1314
1315 public:
1316 wxFontEncoding m_enc;
1317 wxEncodingConverter m2w, w2m;
1318
1319 // were we initialized successfully?
1320 bool m_ok;
1321
1322 DECLARE_NO_COPY_CLASS(EC_CharSet)
1323 };
1324
1325 #endif // wxUSE_FONTMAP
1326
1327 // ----------------------------------------------------------------------------
1328 // the function creating the wxCharacterSet for the specified charset on the
1329 // current system, trying all possibilities
1330 //
1331 // it uses the name if it is given or encoding if name == NULL
1332 // ----------------------------------------------------------------------------
1333
1334 static wxCharacterSet *
1335 wxGetCharacterSet(const wxChar *name, wxFontEncoding encoding)
1336 {
1337 // check for the special case of ASCII charset
1338 if ( (!name && encoding == wxFONTENCODING_DEFAULT)
1339 #if wxUSE_FONTMAP
1340 || (name && wxFontMapper::Get()->
1341 CharsetToEncoding(name) == wxFONTENCODING_DEFAULT)
1342 #endif // wxUSE_FONTMAP
1343 )
1344 {
1345 // don't convert at all
1346 return NULL;
1347 }
1348
1349 wxCharacterSet *cset = NULL;
1350
1351 if (name)
1352 {
1353 if((wxStricmp(name, wxT("UTF8")) == 0) ||
1354 (wxStricmp(name, wxT("UTF-8")) == 0) ||
1355 encoding == wxFONTENCODING_UTF8 )
1356 {
1357 cset = new ID_CharSet(&wxConvUTF8);
1358 }
1359 else if((wxStricmp(name, wxT("UTF16")) == 0) ||
1360 (wxStricmp(name, wxT("UTF-16")) == 0) ||
1361 encoding == wxFONTENCODING_UTF16 )
1362 {
1363 #ifdef WORDS_BIGENDIAN
1364 cset = new ID_CharSet(&wxConvUTF16BE);
1365 #else
1366 cset = new ID_CharSet(&wxConvUTF16LE);
1367 #endif
1368 }
1369 else if((wxStricmp(name, wxT("UTF16BE")) == 0) ||
1370 (wxStricmp(name, wxT("UTF-16BE")) == 0) ||
1371 encoding == wxFONTENCODING_UTF16BE )
1372 {
1373 cset = new ID_CharSet(&wxConvUTF16BE);
1374 }
1375 else if((wxStricmp(name, wxT("UTF16LE")) == 0) ||
1376 (wxStricmp(name, wxT("UTF-16LE")) == 0) ||
1377 encoding == wxFONTENCODING_UTF16LE )
1378 {
1379 cset = new ID_CharSet(&wxConvUTF16LE);
1380 }
1381 else if((wxStricmp(name, wxT("UTF32")) == 0) ||
1382 (wxStricmp(name, wxT("UTF-32")) == 0) ||
1383 (wxStricmp(name, wxT("UCS4")) == 0) ||
1384 (wxStricmp(name, wxT("UCS-4")) == 0) ||
1385 encoding == wxFONTENCODING_UTF32 )
1386 {
1387 #ifdef WORDS_BIGENDIAN
1388 cset = new ID_CharSet(&wxConvUTF32BE);
1389 #else
1390 cset = new ID_CharSet(&wxConvUTF32LE);
1391 #endif
1392 }
1393 else if((wxStricmp(name, wxT("UTF32BE")) == 0) ||
1394 (wxStricmp(name, wxT("UTF-32BE")) == 0) ||
1395 (wxStricmp(name, wxT("UCS4BE")) == 0) ||
1396 (wxStricmp(name, wxT("UCS-4BE")) == 0) ||
1397 encoding == wxFONTENCODING_UTF32BE )
1398 {
1399 cset = new ID_CharSet(&wxConvUTF32BE);
1400 }
1401 else if((wxStricmp(name, wxT("UTF32LE")) == 0) ||
1402 (wxStricmp(name, wxT("UTF-32LE")) == 0) ||
1403 (wxStricmp(name, wxT("UCS4LE")) == 0) ||
1404 (wxStricmp(name, wxT("UCS-4LE")) == 0) ||
1405 encoding == wxFONTENCODING_UTF32 )
1406 {
1407 cset = new ID_CharSet(&wxConvUTF32LE);
1408 }
1409 #ifdef HAVE_ICONV
1410 else
1411 {
1412 cset = new IC_CharSet(name);
1413 }
1414 #endif // HAVE_ICONV
1415 }
1416
1417 // it can only be NULL in this case
1418 #ifndef HAVE_ICONV
1419 if ( cset )
1420 #endif // !HAVE_ICONV
1421 {
1422 if ( cset->usable() )
1423 return cset;
1424
1425 delete cset;
1426 cset = NULL;
1427 }
1428
1429 #if defined(__WIN32__) && !defined(__WXMICROWIN__) && !defined(__WXUNIVERSAL__)
1430 cset = name ? new CP_CharSet(name) : new CP_CharSet(encoding);
1431 if ( cset->usable() )
1432 return cset;
1433
1434 delete cset;
1435 cset = NULL;
1436 #endif // defined(__WIN32__) && !defined(__WXMICROWIN__) && !defined(__WXUNIVERSAL__)
1437
1438 #if wxUSE_FONTMAP
1439 cset = name ? new EC_CharSet(name) : new EC_CharSet(encoding);
1440 if ( cset->usable() )
1441 return cset;
1442
1443 delete cset;
1444 cset = NULL;
1445 #endif // wxUSE_FONTMAP
1446
1447 wxLogError(_("Cannot convert from encoding '%s'!"),
1448 name ? name
1449 :
1450 #if wxUSE_FONTMAP
1451 wxFontMapper::GetEncodingDescription(encoding).c_str()
1452 #else // !wxUSE_FONTMAP
1453 wxString::Format(_T("%s"), encoding).c_str()
1454 #endif // wxUSE_FONTMAP/!wxUSE_FONTMAP
1455 );
1456
1457 return NULL;
1458 }
1459
1460 // ============================================================================
1461 // wxCSConv implementation
1462 // ============================================================================
1463
1464 void wxCSConv::Init()
1465 {
1466 m_name = (wxChar *)NULL;
1467 m_cset = (wxCharacterSet *) NULL;
1468 m_deferred = TRUE;
1469 }
1470
1471 wxCSConv::wxCSConv(const wxChar *charset)
1472 {
1473 Init();
1474 m_encoding = wxFONTENCODING_DEFAULT;
1475
1476 SetName(charset);
1477 }
1478
1479 wxCSConv::wxCSConv(wxFontEncoding encoding)
1480 {
1481 Init();
1482
1483 m_encoding = encoding;
1484 }
1485
1486 wxCSConv::~wxCSConv()
1487 {
1488 Clear();
1489 }
1490
1491 wxCSConv::wxCSConv(const wxCSConv& conv)
1492 : wxMBConv()
1493 {
1494 Init();
1495
1496 SetName(conv.m_name);
1497 m_encoding = conv.m_encoding;
1498 }
1499
1500 wxCSConv& wxCSConv::operator=(const wxCSConv& conv)
1501 {
1502 Clear();
1503
1504 SetName(conv.m_name);
1505 m_encoding = conv.m_encoding;
1506
1507 return *this;
1508 }
1509
1510 void wxCSConv::Clear()
1511 {
1512 free(m_name);
1513 delete m_cset;
1514
1515 m_name = NULL;
1516 m_cset = NULL;
1517 }
1518
1519 void wxCSConv::SetName(const wxChar *charset)
1520 {
1521 if (charset)
1522 {
1523 m_name = wxStrdup(charset);
1524 m_deferred = TRUE;
1525 }
1526 }
1527
1528 void wxCSConv::LoadNow()
1529 {
1530 if ( m_deferred )
1531 {
1532 // it would probably be better to make GetSystemEncodingName() always
1533 // available (i.e. even when wxUSE_INTL == 0)?
1534 #if wxUSE_INTL
1535 if ( !m_name && m_encoding == wxFONTENCODING_DEFAULT )
1536 {
1537 wxString name = wxLocale::GetSystemEncodingName();
1538 if ( !name.empty() )
1539 {
1540 SetName(name);
1541 }
1542 }
1543 #endif // wxUSE_INTL
1544
1545 // wxGetCharacterSet() complains about NULL name
1546 m_cset = wxGetCharacterSet(m_name, m_encoding);
1547 m_deferred = FALSE;
1548 }
1549 }
1550
1551 size_t wxCSConv::MB2WC(wchar_t *buf, const char *psz, size_t n) const
1552 {
1553 ((wxCSConv *)this)->LoadNow(); // discard constness
1554
1555 if (m_cset)
1556 return m_cset->MB2WC(buf, psz, n);
1557
1558 // latin-1 (direct)
1559 size_t len = strlen(psz);
1560
1561 if (buf)
1562 {
1563 for (size_t c = 0; c <= len; c++)
1564 buf[c] = (unsigned char)(psz[c]);
1565 }
1566
1567 return len;
1568 }
1569
1570 size_t wxCSConv::WC2MB(char *buf, const wchar_t *psz, size_t n) const
1571 {
1572 ((wxCSConv *)this)->LoadNow(); // discard constness
1573
1574 if (m_cset)
1575 return m_cset->WC2MB(buf, psz, n);
1576
1577 // latin-1 (direct)
1578 const size_t len = wxWcslen(psz);
1579 if (buf)
1580 {
1581 for (size_t c = 0; c <= len; c++)
1582 buf[c] = (psz[c] > 0xff) ? '?' : psz[c];
1583 }
1584
1585 return len;
1586 }
1587
1588 #endif // wxUSE_WCHAR_T
1589
1590
wxWidgets (Impactor)