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


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