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