]> 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
reverted previous checkin
[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 license
10 /////////////////////////////////////////////////////////////////////////////
11
12 // ============================================================================
13 // declarations
14 // ============================================================================
15
16 // ----------------------------------------------------------------------------
17 // headers
18 // ----------------------------------------------------------------------------
19
20 #ifdef __GNUG__
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 #include <errno.h>
41 #include <ctype.h>
42 #include <string.h>
43 #include <stdlib.h>
44
45 #include "wx/module.h"
46 #include "wx/strconv.h"
47
48 // ----------------------------------------------------------------------------
49 // globals
50 // ----------------------------------------------------------------------------
51
52 #if wxUSE_WCHAR_T
53 WXDLLEXPORT_DATA(wxMBConv) wxConvLibc;
54 WXDLLEXPORT_DATA(wxCSConv) wxConvLocal((const wxChar *)NULL);
55 #else
56 // stand-ins in absence of wchar_t
57 WXDLLEXPORT_DATA(wxMBConv) wxConvLibc, wxConvFile;
58 #endif // wxUSE_WCHAR_T
59
60 WXDLLEXPORT_DATA(wxMBConv *) wxConvCurrent = &wxConvLibc;
61
62 class wxStrConvModule: public wxModule
63 {
64 public:
65 wxStrConvModule() : wxModule() { }
66 virtual bool OnInit() { return TRUE; }
67 virtual void OnExit()
68 {
69 #if wxUSE_WCHAR_T
70 wxConvLocal.Clear();
71 #endif
72 }
73
74 DECLARE_DYNAMIC_CLASS(wxStrConvModule)
75 };
76
77 IMPLEMENT_DYNAMIC_CLASS(wxStrConvModule, wxModule)
78
79
80 // ----------------------------------------------------------------------------
81 // headers
82 // ----------------------------------------------------------------------------
83
84 #if wxUSE_WCHAR_T
85
86 #ifdef __SALFORDC__
87 #include <clib.h>
88 #endif
89
90 #ifdef HAVE_ICONV
91 #include <iconv.h>
92 #endif
93
94 #include "wx/encconv.h"
95 #include "wx/fontmap.h"
96
97 // ----------------------------------------------------------------------------
98 // macros
99 // ----------------------------------------------------------------------------
100
101 #define BSWAP_UCS4(str, len) { unsigned _c; for (_c=0; _c<len; _c++) str[_c]=wxUINT32_SWAP_ALWAYS(str[_c]); }
102 #define BSWAP_UTF16(str, len) { unsigned _c; for (_c=0; _c<len; _c++) str[_c]=wxUINT16_SWAP_ALWAYS(str[_c]); }
103
104 // under Unix SIZEOF_WCHAR_T is defined by configure, but under other platforms
105 // it might be not defined - assume the most common value
106 #ifndef SIZEOF_WCHAR_T
107 #define SIZEOF_WCHAR_T 2
108 #endif // !defined(SIZEOF_WCHAR_T)
109
110 #if SIZEOF_WCHAR_T == 4
111 #define WC_NAME "UCS4"
112 #define WC_BSWAP BSWAP_UCS4
113 #ifdef WORDS_BIGENDIAN
114 #define WC_NAME_BEST "UCS-4BE"
115 #else
116 #define WC_NAME_BEST "UCS-4LE"
117 #endif
118 #elif SIZEOF_WCHAR_T == 2
119 #define WC_NAME "UTF16"
120 #define WC_BSWAP BSWAP_UTF16
121 #define WC_UTF16
122 #ifdef WORDS_BIGENDIAN
123 #define WC_NAME_BEST "UTF-16BE"
124 #else
125 #define WC_NAME_BEST "UTF-16LE"
126 #endif
127 #else // sizeof(wchar_t) != 2 nor 4
128 // I don't know what to do about this
129 #error "Weird sizeof(wchar_t): please report your platform details to wx-users mailing list"
130 #endif
131
132 // ============================================================================
133 // implementation
134 // ============================================================================
135
136 // ----------------------------------------------------------------------------
137 // UTF-16 en/decoding
138 // ----------------------------------------------------------------------------
139
140 #ifdef WC_UTF16
141
142 static size_t encode_utf16(wxUint32 input, wchar_t *output)
143 {
144 if (input<=0xffff)
145 {
146 if (output) *output++ = (wchar_t) input;
147 return 1;
148 }
149 else if (input>=0x110000)
150 {
151 return (size_t)-1;
152 }
153 else
154 {
155 if (output)
156 {
157 *output++ = (wchar_t) ((input >> 10)+0xd7c0);
158 *output++ = (wchar_t) ((input&0x3ff)+0xdc00);
159 }
160 return 2;
161 }
162 }
163
164 static size_t decode_utf16(const wchar_t* input, wxUint32& output)
165 {
166 if ((*input<0xd800) || (*input>0xdfff))
167 {
168 output = *input;
169 return 1;
170 }
171 else if ((input[1]<0xdc00) || (input[1]>=0xdfff))
172 {
173 output = *input;
174 return (size_t)-1;
175 }
176 else
177 {
178 output = ((input[0] - 0xd7c0) << 10) + (input[1] - 0xdc00);
179 return 2;
180 }
181 }
182
183 #endif // WC_UTF16
184
185 // ----------------------------------------------------------------------------
186 // wxMBConv
187 // ----------------------------------------------------------------------------
188
189 #define IGNORE_LIBC 0
190
191 size_t wxMBConv::MB2WC(wchar_t *buf, const char *psz, size_t n) const
192 {
193 #if IGNORE_LIBC
194 if (buf)
195 {
196 for (size_t i = 0; i < strlen( psz )+1; i++)
197 buf[i] = (wchar_t) psz[i];
198 // printf( "libc %s\n", buf );
199 return strlen( psz );
200 }
201 else
202 {
203 return strlen( psz );
204 }
205 #else
206 return wxMB2WC(buf, psz, n);
207 #endif
208 }
209
210 size_t wxMBConv::WC2MB(char *buf, const wchar_t *psz, size_t n) const
211 {
212 #if IGNORE_LIBC
213 if (buf)
214 {
215 for (size_t i = 0; i < wxStrlen( psz )+1; i++)
216 buf[i] = (char) psz[i];
217 // printf( "libc %s\n", buf );
218 return wxStrlen( psz );
219 }
220 else
221 {
222 return wxStrlen( psz );
223 }
224 #else
225 return wxWC2MB(buf, psz, n);
226 #endif
227 }
228
229 const wxWCharBuffer wxMBConv::cMB2WC(const char *psz) const
230 {
231 if (psz)
232 {
233 size_t nLen = MB2WC((wchar_t *) NULL, psz, 0); // return value excludes /0
234 if (nLen == (size_t)-1)
235 return wxWCharBuffer((wchar_t *) NULL);
236 wxWCharBuffer buf(nLen); // this allocates nLen1+
237 MB2WC((wchar_t *)(const wchar_t *) buf, psz, nLen+1);
238 return buf;
239 }
240 else
241 return wxWCharBuffer((wchar_t *) NULL);
242 }
243
244 const wxCharBuffer wxMBConv::cWC2MB(const wchar_t *psz) const
245 {
246 if (psz)
247 {
248 size_t nLen = WC2MB((char *) NULL, psz, 0); // return value excludes /0
249 if (nLen == (size_t)-1)
250 return wxCharBuffer((char *) NULL);
251 wxCharBuffer buf(nLen); // this allocates nLen+1
252 WC2MB((char *)(const char *) buf, psz, nLen+1);
253 // printf( "str %s\n", (const char*) buf );
254 return buf;
255 }
256 else
257 return wxCharBuffer((char *) NULL);
258 }
259
260 // ----------------------------------------------------------------------------
261 // standard gdk conversion
262 // ----------------------------------------------------------------------------
263
264 #ifdef __WXGTK12__
265
266 WXDLLEXPORT_DATA(wxMBConvGdk) wxConvGdk;
267
268 #include <gdk/gdk.h>
269
270 size_t wxMBConvGdk::MB2WC(wchar_t *buf, const char *psz, size_t n) const
271 {
272 if (buf)
273 {
274 return gdk_mbstowcs((GdkWChar *)buf, psz, n);
275 }
276 else
277 {
278 GdkWChar *nbuf = new GdkWChar[n=strlen(psz)];
279 size_t len = gdk_mbstowcs(nbuf, psz, n);
280 delete[] nbuf;
281 return len;
282 }
283 }
284
285 size_t wxMBConvGdk::WC2MB(char *buf, const wchar_t *psz, size_t n) const
286 {
287 char *mbstr = gdk_wcstombs((GdkWChar *)psz);
288 size_t len = mbstr ? strlen(mbstr) : 0;
289 if (buf)
290 {
291 if (len > n)
292 len = n;
293 memcpy(buf, psz, len);
294 if (len < n)
295 buf[len] = 0;
296 }
297 return len;
298 }
299
300 #endif // GTK > 1.0
301
302 // ----------------------------------------------------------------------------
303 // UTF-7
304 // ----------------------------------------------------------------------------
305
306 WXDLLEXPORT_DATA(wxMBConvUTF7) wxConvUTF7;
307
308 #if 0
309 static char utf7_setD[]="ABCDEFGHIJKLMNOPQRSTUVWXYZ"
310 "abcdefghijklmnopqrstuvwxyz"
311 "0123456789'(),-./:?";
312 static char utf7_setO[]="!\"#$%&*;<=>@[]^_`{|}";
313 static char utf7_setB[]="ABCDEFGHIJKLMNOPQRSTUVWXYZ"
314 "abcdefghijklmnopqrstuvwxyz"
315 "0123456789+/";
316 #endif
317
318 // TODO: write actual implementations of UTF-7 here
319 size_t wxMBConvUTF7::MB2WC(wchar_t * WXUNUSED(buf),
320 const char * WXUNUSED(psz),
321 size_t WXUNUSED(n)) const
322 {
323 return 0;
324 }
325
326 size_t wxMBConvUTF7::WC2MB(char * WXUNUSED(buf),
327 const wchar_t * WXUNUSED(psz),
328 size_t WXUNUSED(n)) const
329 {
330 return 0;
331 }
332
333 // ----------------------------------------------------------------------------
334 // UTF-8
335 // ----------------------------------------------------------------------------
336
337 WXDLLEXPORT_DATA(wxMBConvUTF8) wxConvUTF8;
338
339 static wxUint32 utf8_max[]=
340 { 0x7f, 0x7ff, 0xffff, 0x1fffff, 0x3ffffff, 0x7fffffff, 0xffffffff };
341
342 size_t wxMBConvUTF8::MB2WC(wchar_t *buf, const char *psz, size_t n) const
343 {
344 size_t len = 0;
345
346 while (*psz && ((!buf) || (len < n)))
347 {
348 unsigned char cc = *psz++, fc = cc;
349 unsigned cnt;
350 for (cnt = 0; fc & 0x80; cnt++)
351 fc <<= 1;
352 if (!cnt)
353 {
354 // plain ASCII char
355 if (buf)
356 *buf++ = cc;
357 len++;
358 }
359 else
360 {
361 cnt--;
362 if (!cnt)
363 {
364 // invalid UTF-8 sequence
365 return (size_t)-1;
366 }
367 else
368 {
369 unsigned ocnt = cnt - 1;
370 wxUint32 res = cc & (0x3f >> cnt);
371 while (cnt--)
372 {
373 cc = *psz++;
374 if ((cc & 0xC0) != 0x80)
375 {
376 // invalid UTF-8 sequence
377 return (size_t)-1;
378 }
379 res = (res << 6) | (cc & 0x3f);
380 }
381 if (res <= utf8_max[ocnt])
382 {
383 // illegal UTF-8 encoding
384 return (size_t)-1;
385 }
386 #ifdef WC_UTF16
387 size_t pa = encode_utf16(res, buf);
388 if (pa == (size_t)-1)
389 return (size_t)-1;
390 if (buf)
391 buf += pa;
392 len += pa;
393 #else // !WC_UTF16
394 if (buf)
395 *buf++ = res;
396 len++;
397 #endif // WC_UTF16/!WC_UTF16
398 }
399 }
400 }
401 if (buf && (len < n))
402 *buf = 0;
403 return len;
404 }
405
406 size_t wxMBConvUTF8::WC2MB(char *buf, const wchar_t *psz, size_t n) const
407 {
408 size_t len = 0;
409
410 while (*psz && ((!buf) || (len < n)))
411 {
412 wxUint32 cc;
413 #ifdef WC_UTF16
414 size_t pa = decode_utf16(psz, cc);
415 psz += (pa == (size_t)-1) ? 1 : pa;
416 #else
417 cc=(*psz++) & 0x7fffffff;
418 #endif
419 unsigned cnt;
420 for (cnt = 0; cc > utf8_max[cnt]; cnt++) {}
421 if (!cnt)
422 {
423 // plain ASCII char
424 if (buf)
425 *buf++ = (char) cc;
426 len++;
427 }
428
429 else
430 {
431 len += cnt + 1;
432 if (buf)
433 {
434 *buf++ = (char) ((-128 >> cnt) | ((cc >> (cnt * 6)) & (0x3f >> cnt)));
435 while (cnt--)
436 *buf++ = (char) (0x80 | ((cc >> (cnt * 6)) & 0x3f));
437 }
438 }
439 }
440
441 if (buf && (len<n)) *buf = 0;
442
443 return len;
444 }
445
446 // ============================================================================
447 // wxCharacterSet and derived classes
448 // ============================================================================
449
450 // ----------------------------------------------------------------------------
451 // wxCharacterSet is the ABC for the classes below
452 // ----------------------------------------------------------------------------
453
454 class wxCharacterSet
455 {
456 public:
457 wxCharacterSet(const wxChar*name) : cname(name) {}
458 virtual ~wxCharacterSet() {}
459 virtual size_t MB2WC(wchar_t *buf, const char *psz, size_t n) = 0;
460 virtual size_t WC2MB(char *buf, const wchar_t *psz, size_t n) = 0;
461 virtual bool usable() const = 0;
462 public:
463 const wxChar*cname;
464 };
465
466 // ----------------------------------------------------------------------------
467 // ID_CharSet: implementation of wxCharacterSet using an existing wxMBConv
468 // ----------------------------------------------------------------------------
469
470 class ID_CharSet : public wxCharacterSet
471 {
472 public:
473 ID_CharSet(const wxChar *name, wxMBConv *cnv)
474 : wxCharacterSet(name), work(cnv) {}
475
476 size_t MB2WC(wchar_t *buf, const char *psz, size_t n)
477 { return work ? work->MB2WC(buf,psz,n) : (size_t)-1; }
478
479 size_t WC2MB(char *buf, const wchar_t *psz, size_t n)
480 { return work ? work->WC2MB(buf,psz,n) : (size_t)-1; }
481
482 bool usable() const
483 { return work!=NULL; }
484 public:
485 wxMBConv*work;
486 };
487
488
489 // ============================================================================
490 // The classes doing conversion using the iconv_xxx() functions
491 // ============================================================================
492
493 #ifdef HAVE_ICONV
494
495 // VS: glibc 2.1.3 is broken in that iconv() conversion to/from UCS4 fails with E2BIG
496 // if output buffer is _exactly_ as big as needed. Such case is (unless there's
497 // yet another bug in glibc) the only case when iconv() returns with (size_t)-1
498 // (which means error) and says there are 0 bytes left in the input buffer --
499 // when _real_ error occurs, bytes-left-in-input buffer is non-zero. Hence,
500 // this alternative test for iconv() failure.
501 // [This bug does not appear in glibc 2.2.]
502 #if defined(__GLIBC__) && __GLIBC__ == 2 && __GLIBC_MINOR__ <= 1
503 #define ICONV_FAILED(cres, bufLeft) ((cres == (size_t)-1) && \
504 (errno != E2BIG || bufLeft != 0))
505 #else
506 #define ICONV_FAILED(cres, bufLeft) (cres == (size_t)-1)
507 #endif
508
509 #define ICONV_CHAR_CAST(x) ((ICONV_CONST char **)(x))
510
511 // ----------------------------------------------------------------------------
512 // IC_CharSet: encapsulates an iconv character set
513 // ----------------------------------------------------------------------------
514
515 class IC_CharSet : public wxCharacterSet
516 {
517 public:
518 IC_CharSet(const wxChar *name);
519 virtual ~IC_CharSet();
520
521 virtual size_t MB2WC(wchar_t *buf, const char *psz, size_t n);
522 virtual size_t WC2MB(char *buf, const wchar_t *psz, size_t n);
523
524 bool usable() const
525 { return (m2w != (iconv_t)-1) && (w2m != (iconv_t)-1); }
526
527 protected:
528 // the iconv handlers used to translate from multibyte to wide char and in
529 // the other direction
530 iconv_t m2w,
531 w2m;
532
533 private:
534 // the name (for iconv_open()) of a wide char charset - if none is
535 // available on this machine, it will remain NULL
536 static const char *ms_wcCharsetName;
537
538 // true if the wide char encoding we use (i.e. ms_wcCharsetName) has
539 // different endian-ness than the native one
540 static bool ms_wcNeedsSwap;
541 };
542
543 const char *IC_CharSet::ms_wcCharsetName = NULL;
544 bool IC_CharSet::ms_wcNeedsSwap = FALSE;
545
546 IC_CharSet::IC_CharSet(const wxChar *name)
547 : wxCharacterSet(name)
548 {
549 // Do it the hard way
550 char cname[100];
551 for (size_t i = 0; i < wxStrlen(name)+1; i++)
552 cname[i] = (char) name[i];
553
554 // check for charset that represents wchar_t:
555 if (ms_wcCharsetName == NULL)
556 {
557 ms_wcNeedsSwap = FALSE;
558
559 // try charset with explicit bytesex info (e.g. "UCS-4LE"):
560 ms_wcCharsetName = WC_NAME_BEST;
561 m2w = iconv_open(ms_wcCharsetName, cname);
562
563 if (m2w == (iconv_t)-1)
564 {
565 // try charset w/o bytesex info (e.g. "UCS4")
566 // and check for bytesex ourselves:
567 ms_wcCharsetName = WC_NAME;
568 m2w = iconv_open(ms_wcCharsetName, cname);
569
570 // last bet, try if it knows WCHAR_T pseudo-charset
571 if (m2w == (iconv_t)-1)
572 {
573 ms_wcCharsetName = "WCHAR_T";
574 m2w = iconv_open(ms_wcCharsetName, cname);
575 }
576
577 if (m2w != (iconv_t)-1)
578 {
579 char buf[2], *bufPtr;
580 wchar_t wbuf[2], *wbufPtr;
581 size_t insz, outsz;
582 size_t res;
583
584 buf[0] = 'A';
585 buf[1] = 0;
586 wbuf[0] = 0;
587 insz = 2;
588 outsz = SIZEOF_WCHAR_T * 2;
589 wbufPtr = wbuf;
590 bufPtr = buf;
591
592 res = iconv(m2w, ICONV_CHAR_CAST(&bufPtr), &insz,
593 (char**)&wbufPtr, &outsz);
594
595 if (ICONV_FAILED(res, insz))
596 {
597 ms_wcCharsetName = NULL;
598 wxLogLastError(wxT("iconv"));
599 wxLogError(_("Convertion to charset '%s' doesn't work."), name);
600 }
601 else
602 {
603 ms_wcNeedsSwap = wbuf[0] != (wchar_t)buf[0];
604 }
605 }
606 else
607 {
608 ms_wcCharsetName = NULL;
609
610 // VS: we must not output an error here, since wxWindows will safely
611 // fall back to using wxEncodingConverter.
612 wxLogTrace(wxT("strconv"), wxT("Impossible to convert to/from charset '%s' with iconv, falling back to wxEncodingConverter."), name);
613 //wxLogError(
614 }
615 }
616 wxLogTrace(wxT("strconv"), wxT("wchar_t charset is '%s', needs swap: %i"), ms_wcCharsetName, ms_wcNeedsSwap);
617 }
618 else // we already have ms_wcCharsetName
619 {
620 m2w = iconv_open(ms_wcCharsetName, cname);
621 }
622
623 // NB: don't ever pass NULL to iconv_open(), it may crash!
624 if ( ms_wcCharsetName )
625 {
626 w2m = iconv_open( cname, ms_wcCharsetName);
627 }
628 else
629 {
630 w2m = (iconv_t)-1;
631 }
632 }
633
634 IC_CharSet::~IC_CharSet()
635 {
636 if ( m2w != (iconv_t)-1 )
637 iconv_close(m2w);
638 if ( w2m != (iconv_t)-1 )
639 iconv_close(w2m);
640 }
641
642 size_t IC_CharSet::MB2WC(wchar_t *buf, const char *psz, size_t n)
643 {
644 size_t inbuf = strlen(psz);
645 size_t outbuf = n * SIZEOF_WCHAR_T;
646 size_t res, cres;
647 // VS: Use these instead of psz, buf because iconv() modifies its arguments:
648 wchar_t *bufPtr = buf;
649 const char *pszPtr = psz;
650
651 if (buf)
652 {
653 // have destination buffer, convert there
654 cres = iconv(m2w,
655 ICONV_CHAR_CAST(&pszPtr), &inbuf,
656 (char**)&bufPtr, &outbuf);
657 res = n - (outbuf / SIZEOF_WCHAR_T);
658
659 if (ms_wcNeedsSwap)
660 {
661 // convert to native endianness
662 WC_BSWAP(buf /* _not_ bufPtr */, res)
663 }
664 }
665 else
666 {
667 // no destination buffer... convert using temp buffer
668 // to calculate destination buffer requirement
669 wchar_t tbuf[8];
670 res = 0;
671 do {
672 bufPtr = tbuf;
673 outbuf = 8*SIZEOF_WCHAR_T;
674
675 cres = iconv(m2w,
676 ICONV_CHAR_CAST(&pszPtr), &inbuf,
677 (char**)&bufPtr, &outbuf );
678
679 res += 8-(outbuf/SIZEOF_WCHAR_T);
680 } while ((cres==(size_t)-1) && (errno==E2BIG));
681 }
682
683 if (ICONV_FAILED(cres, inbuf))
684 {
685 //VS: it is ok if iconv fails, hence trace only
686 wxLogTrace(wxT("strconv"), wxT("iconv failed: %s"), wxSysErrorMsg(wxSysErrorCode()));
687 return (size_t)-1;
688 }
689
690 return res;
691 }
692
693 size_t IC_CharSet::WC2MB(char *buf, const wchar_t *psz, size_t n)
694 {
695 #if defined(__BORLANDC__) && (__BORLANDC__ > 0x530)
696 size_t inbuf = std::wcslen(psz) * SIZEOF_WCHAR_T;
697 #else
698 size_t inbuf = ::wcslen(psz) * SIZEOF_WCHAR_T;
699 #endif
700 size_t outbuf = n;
701 size_t res, cres;
702
703 wchar_t *tmpbuf = 0;
704
705 if (ms_wcNeedsSwap)
706 {
707 // need to copy to temp buffer to switch endianness
708 // this absolutely doesn't rock!
709 // (no, doing WC_BSWAP twice on the original buffer won't help, as it
710 // could be in read-only memory, or be accessed in some other thread)
711 tmpbuf=(wchar_t*)malloc((inbuf+1)*SIZEOF_WCHAR_T);
712 memcpy(tmpbuf,psz,(inbuf+1)*SIZEOF_WCHAR_T);
713 WC_BSWAP(tmpbuf, inbuf)
714 psz=tmpbuf;
715 }
716
717 if (buf)
718 {
719 // have destination buffer, convert there
720 cres = iconv( w2m, ICONV_CHAR_CAST(&psz), &inbuf, &buf, &outbuf );
721
722 res = n-outbuf;
723 }
724 else
725 {
726 // no destination buffer... convert using temp buffer
727 // to calculate destination buffer requirement
728 char tbuf[16];
729 res = 0;
730 do {
731 buf = tbuf; outbuf = 16;
732
733 cres = iconv( w2m, ICONV_CHAR_CAST(&psz), &inbuf, &buf, &outbuf );
734
735 res += 16 - outbuf;
736 } while ((cres==(size_t)-1) && (errno==E2BIG));
737 }
738
739 if (ms_wcNeedsSwap)
740 {
741 free(tmpbuf);
742 }
743
744 if (ICONV_FAILED(cres, inbuf))
745 {
746 //VS: it is ok if iconv fails, hence trace only
747 wxLogTrace(wxT("strconv"), wxT("iconv failed: %s"), wxSysErrorMsg(wxSysErrorCode()));
748 return (size_t)-1;
749 }
750
751 return res;
752 }
753
754 #endif // HAVE_ICONV
755
756 // ============================================================================
757 // Win32 conversion classes
758 // ============================================================================
759
760 #if defined(__WIN32__) && !defined(__WXMICROWIN__)
761
762 extern long wxCharsetToCodepage(const wxChar *charset); // from utils.cpp
763
764 class CP_CharSet : public wxCharacterSet
765 {
766 public:
767 CP_CharSet(const wxChar* name)
768 : wxCharacterSet(name)
769 {
770 m_CodePage = wxCharsetToCodepage(name);
771 }
772
773 size_t MB2WC(wchar_t *buf, const char *psz, size_t n)
774 {
775 size_t len =
776 MultiByteToWideChar(m_CodePage, 0, psz, -1, buf, buf ? n : 0);
777 //VS: returns # of written chars for buf!=NULL and *size*
778 // needed buffer for buf==NULL
779 return len ? (buf ? len : len-1) : (size_t)-1;
780 }
781
782 size_t WC2MB(char *buf, const wchar_t *psz, size_t n)
783 {
784 size_t len = WideCharToMultiByte(m_CodePage, 0, psz, -1, buf,
785 buf ? n : 0, NULL, NULL);
786 //VS: returns # of written chars for buf!=NULL and *size*
787 // needed buffer for buf==NULL
788 return len ? (buf ? len : len-1) : (size_t)-1;
789 }
790
791 bool usable() const
792 { return m_CodePage != -1; }
793
794 public:
795 long m_CodePage;
796 };
797 #endif // __WIN32__
798
799 // ============================================================================
800 // wxEncodingConverter based conversion classes
801 // ============================================================================
802
803 #if wxUSE_FONTMAP
804
805 class EC_CharSet : public wxCharacterSet
806 {
807 public:
808 // temporarily just use wxEncodingConverter stuff,
809 // so that it works while a better implementation is built
810 EC_CharSet(const wxChar* name) : wxCharacterSet(name),
811 enc(wxFONTENCODING_SYSTEM)
812 {
813 if (name)
814 enc = wxFontMapper::Get()->CharsetToEncoding(name, FALSE);
815
816 m_ok = m2w.Init(enc, wxFONTENCODING_UNICODE) &&
817 w2m.Init(wxFONTENCODING_UNICODE, enc);
818 }
819
820 size_t MB2WC(wchar_t *buf, const char *psz, size_t WXUNUSED(n))
821 {
822 size_t inbuf = strlen(psz);
823 if (buf)
824 m2w.Convert(psz,buf);
825 return inbuf;
826 }
827
828 size_t WC2MB(char *buf, const wchar_t *psz, size_t WXUNUSED(n))
829 {
830 #if ( defined(__BORLANDC__) && (__BORLANDC__ > 0x530) ) \
831 || ( defined(__MWERKS__) && defined(__WXMSW__) )
832 size_t inbuf = std::wcslen(psz);
833 #else
834 size_t inbuf = ::wcslen(psz);
835 #endif
836 if (buf)
837 w2m.Convert(psz,buf);
838
839 return inbuf;
840 }
841
842 bool usable() const { return m_ok; }
843
844 public:
845 wxFontEncoding enc;
846 wxEncodingConverter m2w, w2m;
847
848 // were we initialized successfully?
849 bool m_ok;
850 };
851
852 #endif // wxUSE_FONTMAP
853
854 // ----------------------------------------------------------------------------
855 // the function creating the wxCharacterSet for the specified charset on the
856 // current system, trying all possibilities
857 // ----------------------------------------------------------------------------
858
859 static wxCharacterSet *wxGetCharacterSet(const wxChar *name)
860 {
861 // check for the special case of ASCII charset
862 #if wxUSE_FONTMAP
863 if ( wxFontMapper::Get()->CharsetToEncoding(name) == wxFONTENCODING_DEFAULT )
864 #else // wxUSE_FONTMAP
865 if ( !name )
866 #endif // wxUSE_FONTMAP/!wxUSE_FONTMAP
867 {
868 // don't convert at all
869 return NULL;
870 }
871
872 // the test above must have taken care of this case
873 wxCHECK_MSG( name, NULL, _T("NULL name must be wxFONTENCODING_DEFAULT") );
874
875 wxCharacterSet *cset;
876
877 if ( wxStricmp(name, wxT("UTF8")) == 0 || wxStricmp(name, wxT("UTF-8")) == 0)
878 {
879 cset = new ID_CharSet(name, &wxConvUTF8);
880 }
881 else
882 {
883 #ifdef HAVE_ICONV
884 cset = new IC_CharSet(name);
885 #else // !HAVE_ICONV
886 cset = NULL;
887 #endif // HAVE_ICONV/!HAVE_ICONV
888 }
889
890 // it can only be NULL in this case
891 #ifndef HAVE_ICONV
892 if ( cset )
893 #endif // !HAVE_ICONV
894 {
895 if ( cset->usable() )
896 return cset;
897
898 delete cset;
899 cset = NULL;
900 }
901
902 #if defined(__WIN32__) && !defined(__WXMICROWIN__)
903 cset = new CP_CharSet(name);
904 if ( cset->usable() )
905 return cset;
906
907 delete cset;
908 cset = NULL;
909 #endif // __WIN32__
910
911 #if wxUSE_FONTMAP
912 cset = new EC_CharSet(name);
913 if ( cset->usable() )
914 return cset;
915
916 delete cset;
917 cset = NULL;
918 #endif // wxUSE_FONTMAP
919
920 wxLogError(_("Cannot convert from encoding '%s'!"), name);
921
922 return NULL;
923 }
924
925 // ============================================================================
926 // wxCSConv implementation
927 // ============================================================================
928
929 wxCSConv::wxCSConv(const wxChar *charset)
930 {
931 m_name = (wxChar *)NULL;
932 m_cset = (wxCharacterSet *) NULL;
933 m_deferred = TRUE;
934
935 SetName(charset);
936 }
937
938 wxCSConv::~wxCSConv()
939 {
940 Clear();
941 }
942
943 wxCSConv::wxCSConv(const wxCSConv& conv)
944 : wxMBConv()
945 {
946 Clear();
947 SetName(conv.m_name);
948 }
949
950 wxCSConv& wxCSConv::operator=(const wxCSConv& conv)
951 {
952 Clear();
953 SetName(conv.m_name);
954 return *this;
955 }
956
957 void wxCSConv::Clear()
958 {
959 if (m_name)
960 free(m_name);
961 if (m_cset)
962 delete m_cset;
963 m_name = NULL;
964 m_cset = NULL;
965 }
966
967 void wxCSConv::SetName(const wxChar *charset)
968 {
969 if (charset)
970 {
971 m_name = wxStrdup(charset);
972 m_deferred = TRUE;
973 }
974 }
975
976 void wxCSConv::LoadNow()
977 {
978 if (m_deferred)
979 {
980 if ( !m_name )
981 {
982 wxString name = wxLocale::GetSystemEncodingName();
983 if ( !name.empty() )
984 {
985 SetName(name);
986 }
987 }
988
989 // wxGetCharacterSet() complains about NULL name
990 m_cset = m_name ? wxGetCharacterSet(m_name) : NULL;
991 m_deferred = FALSE;
992 }
993 }
994
995 size_t wxCSConv::MB2WC(wchar_t *buf, const char *psz, size_t n) const
996 {
997 ((wxCSConv *)this)->LoadNow(); // discard constness
998
999 if (m_cset)
1000 return m_cset->MB2WC(buf, psz, n);
1001
1002 // latin-1 (direct)
1003 size_t len = strlen(psz);
1004
1005 if (buf)
1006 {
1007 for (size_t c = 0; c <= len; c++)
1008 buf[c] = (unsigned char)(psz[c]);
1009 }
1010
1011 return len;
1012 }
1013
1014 size_t wxCSConv::WC2MB(char *buf, const wchar_t *psz, size_t n) const
1015 {
1016 ((wxCSConv *)this)->LoadNow(); // discard constness
1017
1018 if (m_cset)
1019 return m_cset->WC2MB(buf, psz, n);
1020
1021 // latin-1 (direct)
1022 #if ( defined(__BORLANDC__) && (__BORLANDC__ > 0x530) ) \
1023 || ( defined(__MWERKS__) && defined(__WXMSW__) )
1024 size_t len=std::wcslen(psz);
1025 #else
1026 size_t len=::wcslen(psz);
1027 #endif
1028 if (buf)
1029 {
1030 for (size_t c = 0; c <= len; c++)
1031 buf[c] = (psz[c] > 0xff) ? '?' : psz[c];
1032 }
1033
1034 return len;
1035 }
1036
1037 #endif // wxUSE_WCHAR_T
1038
1039
wxWidgets (Impactor)