]>
Commit | Line | Data |
---|---|---|
6001e347 RR |
1 | ///////////////////////////////////////////////////////////////////////////// |
2 | // Name: strconv.cpp | |
3 | // Purpose: Unicode conversion classes | |
3a0d76bc | 4 | // Author: Ove Kaaven, Robert Roebling, Vadim Zeitlin, Vaclav Slavik |
6001e347 RR |
5 | // Modified by: |
6 | // Created: 29/01/98 | |
7 | // RCS-ID: $Id$ | |
e95354ec VZ |
8 | // Copyright: (c) 1999 Ove Kaaven, Robert Roebling, Vaclav Slavik |
9 | // (c) 2000-2003 Vadim Zeitlin | |
65571936 | 10 | // Licence: wxWindows licence |
6001e347 RR |
11 | ///////////////////////////////////////////////////////////////////////////// |
12 | ||
f6bcfd97 BP |
13 | // ============================================================================ |
14 | // declarations | |
15 | // ============================================================================ | |
16 | ||
17 | // ---------------------------------------------------------------------------- | |
18 | // headers | |
19 | // ---------------------------------------------------------------------------- | |
20 | ||
14f355c2 | 21 | #if defined(__GNUG__) && !defined(NO_GCC_PRAGMA) |
6001e347 RR |
22 | #pragma implementation "strconv.h" |
23 | #endif | |
24 | ||
25 | // For compilers that support precompilation, includes "wx.h". | |
26 | #include "wx/wxprec.h" | |
27 | ||
28 | #ifdef __BORLANDC__ | |
29 | #pragma hdrstop | |
30 | #endif | |
31 | ||
373658eb VZ |
32 | #ifndef WX_PRECOMP |
33 | #include "wx/intl.h" | |
34 | #include "wx/log.h" | |
35 | #endif // WX_PRECOMP | |
36 | ||
bde4baac VZ |
37 | #include "wx/strconv.h" |
38 | ||
39 | #if wxUSE_WCHAR_T | |
40 | ||
0a1c1e62 | 41 | #ifdef __WXMSW__ |
373658eb | 42 | #include "wx/msw/private.h" |
7608a683 WS |
43 | #endif |
44 | ||
45 | #ifdef __WINDOWS__ | |
13dd924a | 46 | #include "wx/msw/missing.h" |
0a1c1e62 GRG |
47 | #endif |
48 | ||
1c193821 | 49 | #ifndef __WXWINCE__ |
1cd52418 | 50 | #include <errno.h> |
1c193821 JS |
51 | #endif |
52 | ||
6001e347 RR |
53 | #include <ctype.h> |
54 | #include <string.h> | |
55 | #include <stdlib.h> | |
56 | ||
e95354ec VZ |
57 | #if defined(__WIN32__) && !defined(__WXMICROWIN__) |
58 | #define wxHAVE_WIN32_MB2WC | |
59 | #endif // __WIN32__ but !__WXMICROWIN__ | |
60 | ||
373658eb VZ |
61 | // ---------------------------------------------------------------------------- |
62 | // headers | |
63 | // ---------------------------------------------------------------------------- | |
7af284fd | 64 | |
6001e347 | 65 | #ifdef __SALFORDC__ |
373658eb | 66 | #include <clib.h> |
6001e347 RR |
67 | #endif |
68 | ||
b040e242 | 69 | #ifdef HAVE_ICONV |
373658eb | 70 | #include <iconv.h> |
1cd52418 | 71 | #endif |
1cd52418 | 72 | |
373658eb VZ |
73 | #include "wx/encconv.h" |
74 | #include "wx/fontmap.h" | |
7608a683 | 75 | #include "wx/utils.h" |
373658eb | 76 | |
335d31e0 | 77 | #ifdef __WXMAC__ |
4227afa4 SC |
78 | #include <ATSUnicode.h> |
79 | #include <TextCommon.h> | |
80 | #include <TextEncodingConverter.h> | |
335d31e0 SC |
81 | |
82 | #include "wx/mac/private.h" // includes mac headers | |
83 | #endif | |
373658eb VZ |
84 | // ---------------------------------------------------------------------------- |
85 | // macros | |
86 | // ---------------------------------------------------------------------------- | |
3e61dfb0 | 87 | |
1cd52418 | 88 | #define BSWAP_UCS4(str, len) { unsigned _c; for (_c=0; _c<len; _c++) str[_c]=wxUINT32_SWAP_ALWAYS(str[_c]); } |
3a0d76bc | 89 | #define BSWAP_UTF16(str, len) { unsigned _c; for (_c=0; _c<len; _c++) str[_c]=wxUINT16_SWAP_ALWAYS(str[_c]); } |
1cd52418 OK |
90 | |
91 | #if SIZEOF_WCHAR_T == 4 | |
3a0d76bc VS |
92 | #define WC_NAME "UCS4" |
93 | #define WC_BSWAP BSWAP_UCS4 | |
94 | #ifdef WORDS_BIGENDIAN | |
95 | #define WC_NAME_BEST "UCS-4BE" | |
96 | #else | |
97 | #define WC_NAME_BEST "UCS-4LE" | |
98 | #endif | |
1cd52418 | 99 | #elif SIZEOF_WCHAR_T == 2 |
3a0d76bc VS |
100 | #define WC_NAME "UTF16" |
101 | #define WC_BSWAP BSWAP_UTF16 | |
a3f2769e | 102 | #define WC_UTF16 |
3a0d76bc VS |
103 | #ifdef WORDS_BIGENDIAN |
104 | #define WC_NAME_BEST "UTF-16BE" | |
105 | #else | |
106 | #define WC_NAME_BEST "UTF-16LE" | |
107 | #endif | |
bab1e722 | 108 | #else // sizeof(wchar_t) != 2 nor 4 |
bde4baac VZ |
109 | // does this ever happen? |
110 | #error "Unknown sizeof(wchar_t): please report this to wx-dev@lists.wxwindows.org" | |
1cd52418 OK |
111 | #endif |
112 | ||
373658eb VZ |
113 | // ============================================================================ |
114 | // implementation | |
115 | // ============================================================================ | |
116 | ||
117 | // ---------------------------------------------------------------------------- | |
c91830cb | 118 | // UTF-16 en/decoding to/from UCS-4 |
373658eb | 119 | // ---------------------------------------------------------------------------- |
6001e347 | 120 | |
b0a6bb75 | 121 | |
c91830cb | 122 | static size_t encode_utf16(wxUint32 input, wxUint16 *output) |
1cd52418 | 123 | { |
dccce9ea | 124 | if (input<=0xffff) |
4def3b35 | 125 | { |
999836aa VZ |
126 | if (output) |
127 | *output = (wxUint16) input; | |
4def3b35 | 128 | return 1; |
dccce9ea VZ |
129 | } |
130 | else if (input>=0x110000) | |
4def3b35 VS |
131 | { |
132 | return (size_t)-1; | |
dccce9ea VZ |
133 | } |
134 | else | |
4def3b35 | 135 | { |
dccce9ea | 136 | if (output) |
4def3b35 | 137 | { |
c91830cb | 138 | *output++ = (wxUint16) ((input >> 10)+0xd7c0); |
999836aa | 139 | *output = (wxUint16) ((input&0x3ff)+0xdc00); |
4def3b35 VS |
140 | } |
141 | return 2; | |
1cd52418 | 142 | } |
1cd52418 OK |
143 | } |
144 | ||
c91830cb | 145 | static size_t decode_utf16(const wxUint16* input, wxUint32& output) |
1cd52418 | 146 | { |
dccce9ea | 147 | if ((*input<0xd800) || (*input>0xdfff)) |
4def3b35 VS |
148 | { |
149 | output = *input; | |
150 | return 1; | |
dccce9ea VZ |
151 | } |
152 | else if ((input[1]<0xdc00) || (input[1]>=0xdfff)) | |
4def3b35 VS |
153 | { |
154 | output = *input; | |
155 | return (size_t)-1; | |
dccce9ea VZ |
156 | } |
157 | else | |
4def3b35 VS |
158 | { |
159 | output = ((input[0] - 0xd7c0) << 10) + (input[1] - 0xdc00); | |
160 | return 2; | |
161 | } | |
1cd52418 OK |
162 | } |
163 | ||
b0a6bb75 | 164 | |
f6bcfd97 | 165 | // ---------------------------------------------------------------------------- |
6001e347 | 166 | // wxMBConv |
f6bcfd97 | 167 | // ---------------------------------------------------------------------------- |
6001e347 | 168 | |
2b5f62a0 VZ |
169 | wxMBConv::~wxMBConv() |
170 | { | |
171 | // nothing to do here | |
172 | } | |
173 | ||
6001e347 RR |
174 | const wxWCharBuffer wxMBConv::cMB2WC(const char *psz) const |
175 | { | |
2b5f62a0 | 176 | if ( psz ) |
6001e347 | 177 | { |
2b5f62a0 VZ |
178 | // calculate the length of the buffer needed first |
179 | size_t nLen = MB2WC(NULL, psz, 0); | |
180 | if ( nLen != (size_t)-1 ) | |
181 | { | |
182 | // now do the actual conversion | |
183 | wxWCharBuffer buf(nLen); | |
635f33ce VS |
184 | nLen = MB2WC(buf.data(), psz, nLen + 1); // with the trailing NULL |
185 | if ( nLen != (size_t)-1 ) | |
186 | { | |
187 | return buf; | |
188 | } | |
2b5f62a0 | 189 | } |
f6bcfd97 | 190 | } |
2b5f62a0 VZ |
191 | |
192 | wxWCharBuffer buf((wchar_t *)NULL); | |
193 | ||
194 | return buf; | |
6001e347 RR |
195 | } |
196 | ||
e5cceba0 | 197 | const wxCharBuffer wxMBConv::cWC2MB(const wchar_t *pwz) const |
6001e347 | 198 | { |
2b5f62a0 VZ |
199 | if ( pwz ) |
200 | { | |
201 | size_t nLen = WC2MB(NULL, pwz, 0); | |
202 | if ( nLen != (size_t)-1 ) | |
203 | { | |
c91830cb | 204 | wxCharBuffer buf(nLen+3); // space for a wxUint32 trailing zero |
635f33ce VS |
205 | nLen = WC2MB(buf.data(), pwz, nLen + 4); |
206 | if ( nLen != (size_t)-1 ) | |
207 | { | |
208 | return buf; | |
209 | } | |
2b5f62a0 VZ |
210 | } |
211 | } | |
212 | ||
213 | wxCharBuffer buf((char *)NULL); | |
e5cceba0 | 214 | |
e5cceba0 | 215 | return buf; |
6001e347 RR |
216 | } |
217 | ||
6001e347 | 218 | // ---------------------------------------------------------------------------- |
bde4baac | 219 | // wxMBConvLibc |
6001e347 RR |
220 | // ---------------------------------------------------------------------------- |
221 | ||
bde4baac VZ |
222 | size_t wxMBConvLibc::MB2WC(wchar_t *buf, const char *psz, size_t n) const |
223 | { | |
224 | return wxMB2WC(buf, psz, n); | |
225 | } | |
226 | ||
227 | size_t wxMBConvLibc::WC2MB(char *buf, const wchar_t *psz, size_t n) const | |
228 | { | |
229 | return wxWC2MB(buf, psz, n); | |
230 | } | |
231 | ||
232 | // ---------------------------------------------------------------------------- | |
233 | // UTF-7 | |
234 | // ---------------------------------------------------------------------------- | |
6001e347 RR |
235 | |
236 | #if 0 | |
237 | static char utf7_setD[]="ABCDEFGHIJKLMNOPQRSTUVWXYZ" | |
238 | "abcdefghijklmnopqrstuvwxyz" | |
239 | "0123456789'(),-./:?"; | |
240 | static char utf7_setO[]="!\"#$%&*;<=>@[]^_`{|}"; | |
241 | static char utf7_setB[]="ABCDEFGHIJKLMNOPQRSTUVWXYZ" | |
242 | "abcdefghijklmnopqrstuvwxyz" | |
243 | "0123456789+/"; | |
244 | #endif | |
245 | ||
246 | // TODO: write actual implementations of UTF-7 here | |
247 | size_t wxMBConvUTF7::MB2WC(wchar_t * WXUNUSED(buf), | |
248 | const char * WXUNUSED(psz), | |
249 | size_t WXUNUSED(n)) const | |
250 | { | |
251 | return 0; | |
252 | } | |
253 | ||
254 | size_t wxMBConvUTF7::WC2MB(char * WXUNUSED(buf), | |
255 | const wchar_t * WXUNUSED(psz), | |
256 | size_t WXUNUSED(n)) const | |
257 | { | |
258 | return 0; | |
259 | } | |
260 | ||
f6bcfd97 | 261 | // ---------------------------------------------------------------------------- |
6001e347 | 262 | // UTF-8 |
f6bcfd97 | 263 | // ---------------------------------------------------------------------------- |
6001e347 | 264 | |
dccce9ea | 265 | static wxUint32 utf8_max[]= |
4def3b35 | 266 | { 0x7f, 0x7ff, 0xffff, 0x1fffff, 0x3ffffff, 0x7fffffff, 0xffffffff }; |
6001e347 RR |
267 | |
268 | size_t wxMBConvUTF8::MB2WC(wchar_t *buf, const char *psz, size_t n) const | |
269 | { | |
4def3b35 VS |
270 | size_t len = 0; |
271 | ||
dccce9ea | 272 | while (*psz && ((!buf) || (len < n))) |
4def3b35 VS |
273 | { |
274 | unsigned char cc = *psz++, fc = cc; | |
275 | unsigned cnt; | |
dccce9ea | 276 | for (cnt = 0; fc & 0x80; cnt++) |
4def3b35 | 277 | fc <<= 1; |
dccce9ea | 278 | if (!cnt) |
4def3b35 VS |
279 | { |
280 | // plain ASCII char | |
dccce9ea | 281 | if (buf) |
4def3b35 VS |
282 | *buf++ = cc; |
283 | len++; | |
dccce9ea VZ |
284 | } |
285 | else | |
4def3b35 VS |
286 | { |
287 | cnt--; | |
dccce9ea | 288 | if (!cnt) |
4def3b35 VS |
289 | { |
290 | // invalid UTF-8 sequence | |
291 | return (size_t)-1; | |
dccce9ea VZ |
292 | } |
293 | else | |
4def3b35 VS |
294 | { |
295 | unsigned ocnt = cnt - 1; | |
296 | wxUint32 res = cc & (0x3f >> cnt); | |
dccce9ea | 297 | while (cnt--) |
4def3b35 VS |
298 | { |
299 | cc = *psz++; | |
dccce9ea | 300 | if ((cc & 0xC0) != 0x80) |
4def3b35 VS |
301 | { |
302 | // invalid UTF-8 sequence | |
303 | return (size_t)-1; | |
304 | } | |
305 | res = (res << 6) | (cc & 0x3f); | |
306 | } | |
dccce9ea | 307 | if (res <= utf8_max[ocnt]) |
4def3b35 VS |
308 | { |
309 | // illegal UTF-8 encoding | |
310 | return (size_t)-1; | |
311 | } | |
1cd52418 | 312 | #ifdef WC_UTF16 |
b5153fd8 VZ |
313 | // cast is ok because wchar_t == wxUuint16 if WC_UTF16 |
314 | size_t pa = encode_utf16(res, (wxUint16 *)buf); | |
4def3b35 VS |
315 | if (pa == (size_t)-1) |
316 | return (size_t)-1; | |
dccce9ea | 317 | if (buf) |
4def3b35 VS |
318 | buf += pa; |
319 | len += pa; | |
373658eb | 320 | #else // !WC_UTF16 |
dccce9ea | 321 | if (buf) |
4def3b35 VS |
322 | *buf++ = res; |
323 | len++; | |
373658eb | 324 | #endif // WC_UTF16/!WC_UTF16 |
4def3b35 VS |
325 | } |
326 | } | |
6001e347 | 327 | } |
dccce9ea | 328 | if (buf && (len < n)) |
4def3b35 VS |
329 | *buf = 0; |
330 | return len; | |
6001e347 RR |
331 | } |
332 | ||
333 | size_t wxMBConvUTF8::WC2MB(char *buf, const wchar_t *psz, size_t n) const | |
334 | { | |
4def3b35 | 335 | size_t len = 0; |
6001e347 | 336 | |
dccce9ea | 337 | while (*psz && ((!buf) || (len < n))) |
4def3b35 VS |
338 | { |
339 | wxUint32 cc; | |
1cd52418 | 340 | #ifdef WC_UTF16 |
b5153fd8 VZ |
341 | // cast is ok for WC_UTF16 |
342 | size_t pa = decode_utf16((const wxUint16 *)psz, cc); | |
4def3b35 | 343 | psz += (pa == (size_t)-1) ? 1 : pa; |
1cd52418 | 344 | #else |
4def3b35 VS |
345 | cc=(*psz++) & 0x7fffffff; |
346 | #endif | |
347 | unsigned cnt; | |
348 | for (cnt = 0; cc > utf8_max[cnt]; cnt++) {} | |
dccce9ea | 349 | if (!cnt) |
4def3b35 VS |
350 | { |
351 | // plain ASCII char | |
dccce9ea | 352 | if (buf) |
574c939e | 353 | *buf++ = (char) cc; |
4def3b35 | 354 | len++; |
dccce9ea VZ |
355 | } |
356 | ||
357 | else | |
4def3b35 VS |
358 | { |
359 | len += cnt + 1; | |
dccce9ea | 360 | if (buf) |
4def3b35 | 361 | { |
574c939e | 362 | *buf++ = (char) ((-128 >> cnt) | ((cc >> (cnt * 6)) & (0x3f >> cnt))); |
4def3b35 | 363 | while (cnt--) |
574c939e | 364 | *buf++ = (char) (0x80 | ((cc >> (cnt * 6)) & 0x3f)); |
4def3b35 VS |
365 | } |
366 | } | |
6001e347 | 367 | } |
4def3b35 VS |
368 | |
369 | if (buf && (len<n)) *buf = 0; | |
adb45366 | 370 | |
4def3b35 | 371 | return len; |
6001e347 RR |
372 | } |
373 | ||
c91830cb VZ |
374 | |
375 | ||
376 | ||
377 | // ---------------------------------------------------------------------------- | |
378 | // UTF-16 | |
379 | // ---------------------------------------------------------------------------- | |
380 | ||
381 | #ifdef WORDS_BIGENDIAN | |
bde4baac VZ |
382 | #define wxMBConvUTF16straight wxMBConvUTF16BE |
383 | #define wxMBConvUTF16swap wxMBConvUTF16LE | |
c91830cb | 384 | #else |
bde4baac VZ |
385 | #define wxMBConvUTF16swap wxMBConvUTF16BE |
386 | #define wxMBConvUTF16straight wxMBConvUTF16LE | |
c91830cb VZ |
387 | #endif |
388 | ||
389 | ||
c91830cb VZ |
390 | #ifdef WC_UTF16 |
391 | ||
c91830cb VZ |
392 | // copy 16bit MB to 16bit String |
393 | size_t wxMBConvUTF16straight::MB2WC(wchar_t *buf, const char *psz, size_t n) const | |
394 | { | |
395 | size_t len=0; | |
396 | ||
397 | while (*(wxUint16*)psz && (!buf || len < n)) | |
398 | { | |
399 | if (buf) | |
400 | *buf++ = *(wxUint16*)psz; | |
401 | len++; | |
402 | ||
403 | psz += sizeof(wxUint16); | |
404 | } | |
405 | if (buf && len<n) *buf=0; | |
406 | ||
407 | return len; | |
408 | } | |
409 | ||
410 | ||
411 | // copy 16bit String to 16bit MB | |
412 | size_t wxMBConvUTF16straight::WC2MB(char *buf, const wchar_t *psz, size_t n) const | |
413 | { | |
414 | size_t len=0; | |
415 | ||
416 | while (*psz && (!buf || len < n)) | |
417 | { | |
418 | if (buf) | |
419 | { | |
420 | *(wxUint16*)buf = *psz; | |
421 | buf += sizeof(wxUint16); | |
422 | } | |
423 | len += sizeof(wxUint16); | |
424 | psz++; | |
425 | } | |
426 | if (buf && len<=n-sizeof(wxUint16)) *(wxUint16*)buf=0; | |
427 | ||
428 | return len; | |
429 | } | |
430 | ||
431 | ||
432 | // swap 16bit MB to 16bit String | |
433 | size_t wxMBConvUTF16swap::MB2WC(wchar_t *buf, const char *psz, size_t n) const | |
434 | { | |
435 | size_t len=0; | |
436 | ||
437 | while (*(wxUint16*)psz && (!buf || len < n)) | |
438 | { | |
439 | if (buf) | |
440 | { | |
441 | ((char *)buf)[0] = psz[1]; | |
442 | ((char *)buf)[1] = psz[0]; | |
443 | buf++; | |
444 | } | |
445 | len++; | |
446 | psz += sizeof(wxUint16); | |
447 | } | |
448 | if (buf && len<n) *buf=0; | |
449 | ||
450 | return len; | |
451 | } | |
452 | ||
453 | ||
454 | // swap 16bit MB to 16bit String | |
455 | size_t wxMBConvUTF16swap::WC2MB(char *buf, const wchar_t *psz, size_t n) const | |
456 | { | |
457 | size_t len=0; | |
458 | ||
459 | while (*psz && (!buf || len < n)) | |
460 | { | |
461 | if (buf) | |
462 | { | |
463 | *buf++ = ((char*)psz)[1]; | |
464 | *buf++ = ((char*)psz)[0]; | |
465 | } | |
466 | len += sizeof(wxUint16); | |
467 | psz++; | |
468 | } | |
469 | if (buf && len<=n-sizeof(wxUint16)) *(wxUint16*)buf=0; | |
470 | ||
471 | return len; | |
472 | } | |
473 | ||
474 | ||
475 | #else // WC_UTF16 | |
476 | ||
477 | ||
478 | // copy 16bit MB to 32bit String | |
479 | size_t wxMBConvUTF16straight::MB2WC(wchar_t *buf, const char *psz, size_t n) const | |
480 | { | |
481 | size_t len=0; | |
482 | ||
483 | while (*(wxUint16*)psz && (!buf || len < n)) | |
484 | { | |
485 | wxUint32 cc; | |
486 | size_t pa=decode_utf16((wxUint16*)psz, cc); | |
487 | if (pa == (size_t)-1) | |
488 | return pa; | |
489 | ||
490 | if (buf) | |
491 | *buf++ = cc; | |
492 | len++; | |
493 | psz += pa * sizeof(wxUint16); | |
494 | } | |
495 | if (buf && len<n) *buf=0; | |
496 | ||
497 | return len; | |
498 | } | |
499 | ||
500 | ||
501 | // copy 32bit String to 16bit MB | |
502 | size_t wxMBConvUTF16straight::WC2MB(char *buf, const wchar_t *psz, size_t n) const | |
503 | { | |
504 | size_t len=0; | |
505 | ||
506 | while (*psz && (!buf || len < n)) | |
507 | { | |
508 | wxUint16 cc[2]; | |
509 | size_t pa=encode_utf16(*psz, cc); | |
510 | ||
511 | if (pa == (size_t)-1) | |
512 | return pa; | |
513 | ||
514 | if (buf) | |
515 | { | |
69b80d28 | 516 | *(wxUint16*)buf = cc[0]; |
b5153fd8 | 517 | buf += sizeof(wxUint16); |
c91830cb | 518 | if (pa > 1) |
69b80d28 VZ |
519 | { |
520 | *(wxUint16*)buf = cc[1]; | |
521 | buf += sizeof(wxUint16); | |
522 | } | |
c91830cb VZ |
523 | } |
524 | ||
525 | len += pa*sizeof(wxUint16); | |
526 | psz++; | |
527 | } | |
528 | if (buf && len<=n-sizeof(wxUint16)) *(wxUint16*)buf=0; | |
529 | ||
530 | return len; | |
531 | } | |
532 | ||
533 | ||
534 | // swap 16bit MB to 32bit String | |
535 | size_t wxMBConvUTF16swap::MB2WC(wchar_t *buf, const char *psz, size_t n) const | |
536 | { | |
537 | size_t len=0; | |
538 | ||
539 | while (*(wxUint16*)psz && (!buf || len < n)) | |
540 | { | |
541 | wxUint32 cc; | |
542 | char tmp[4]; | |
543 | tmp[0]=psz[1]; tmp[1]=psz[0]; | |
544 | tmp[2]=psz[3]; tmp[3]=psz[2]; | |
545 | ||
546 | size_t pa=decode_utf16((wxUint16*)tmp, cc); | |
547 | if (pa == (size_t)-1) | |
548 | return pa; | |
549 | ||
550 | if (buf) | |
551 | *buf++ = cc; | |
552 | ||
553 | len++; | |
554 | psz += pa * sizeof(wxUint16); | |
555 | } | |
556 | if (buf && len<n) *buf=0; | |
557 | ||
558 | return len; | |
559 | } | |
560 | ||
561 | ||
562 | // swap 32bit String to 16bit MB | |
563 | size_t wxMBConvUTF16swap::WC2MB(char *buf, const wchar_t *psz, size_t n) const | |
564 | { | |
565 | size_t len=0; | |
566 | ||
567 | while (*psz && (!buf || len < n)) | |
568 | { | |
569 | wxUint16 cc[2]; | |
570 | size_t pa=encode_utf16(*psz, cc); | |
571 | ||
572 | if (pa == (size_t)-1) | |
573 | return pa; | |
574 | ||
575 | if (buf) | |
576 | { | |
577 | *buf++ = ((char*)cc)[1]; | |
578 | *buf++ = ((char*)cc)[0]; | |
579 | if (pa > 1) | |
580 | { | |
581 | *buf++ = ((char*)cc)[3]; | |
582 | *buf++ = ((char*)cc)[2]; | |
583 | } | |
584 | } | |
585 | ||
586 | len += pa*sizeof(wxUint16); | |
587 | psz++; | |
588 | } | |
589 | if (buf && len<=n-sizeof(wxUint16)) *(wxUint16*)buf=0; | |
590 | ||
591 | return len; | |
592 | } | |
593 | ||
594 | #endif // WC_UTF16 | |
595 | ||
596 | ||
597 | // ---------------------------------------------------------------------------- | |
598 | // UTF-32 | |
599 | // ---------------------------------------------------------------------------- | |
600 | ||
601 | #ifdef WORDS_BIGENDIAN | |
602 | #define wxMBConvUTF32straight wxMBConvUTF32BE | |
603 | #define wxMBConvUTF32swap wxMBConvUTF32LE | |
604 | #else | |
605 | #define wxMBConvUTF32swap wxMBConvUTF32BE | |
606 | #define wxMBConvUTF32straight wxMBConvUTF32LE | |
607 | #endif | |
608 | ||
609 | ||
610 | WXDLLIMPEXP_DATA_BASE(wxMBConvUTF32LE) wxConvUTF32LE; | |
611 | WXDLLIMPEXP_DATA_BASE(wxMBConvUTF32BE) wxConvUTF32BE; | |
612 | ||
613 | ||
614 | #ifdef WC_UTF16 | |
615 | ||
616 | // copy 32bit MB to 16bit String | |
617 | size_t wxMBConvUTF32straight::MB2WC(wchar_t *buf, const char *psz, size_t n) const | |
618 | { | |
619 | size_t len=0; | |
620 | ||
621 | while (*(wxUint32*)psz && (!buf || len < n)) | |
622 | { | |
623 | wxUint16 cc[2]; | |
624 | ||
625 | size_t pa=encode_utf16(*(wxUint32*)psz, cc); | |
626 | if (pa == (size_t)-1) | |
627 | return pa; | |
628 | ||
629 | if (buf) | |
630 | { | |
631 | *buf++ = cc[0]; | |
632 | if (pa > 1) | |
633 | *buf++ = cc[1]; | |
634 | } | |
635 | len += pa; | |
636 | psz += sizeof(wxUint32); | |
637 | } | |
638 | if (buf && len<n) *buf=0; | |
639 | ||
640 | return len; | |
641 | } | |
642 | ||
643 | ||
644 | // copy 16bit String to 32bit MB | |
645 | size_t wxMBConvUTF32straight::WC2MB(char *buf, const wchar_t *psz, size_t n) const | |
646 | { | |
647 | size_t len=0; | |
648 | ||
649 | while (*psz && (!buf || len < n)) | |
650 | { | |
651 | wxUint32 cc; | |
652 | ||
b5153fd8 VZ |
653 | // cast is ok for WC_UTF16 |
654 | size_t pa = decode_utf16((const wxUint16 *)psz, cc); | |
c91830cb VZ |
655 | if (pa == (size_t)-1) |
656 | return pa; | |
657 | ||
658 | if (buf) | |
659 | { | |
660 | *(wxUint32*)buf = cc; | |
661 | buf += sizeof(wxUint32); | |
662 | } | |
663 | len += sizeof(wxUint32); | |
664 | psz += pa; | |
665 | } | |
b5153fd8 VZ |
666 | |
667 | if (buf && len<=n-sizeof(wxUint32)) | |
668 | *(wxUint32*)buf=0; | |
c91830cb VZ |
669 | |
670 | return len; | |
671 | } | |
672 | ||
673 | ||
674 | ||
675 | // swap 32bit MB to 16bit String | |
676 | size_t wxMBConvUTF32swap::MB2WC(wchar_t *buf, const char *psz, size_t n) const | |
677 | { | |
678 | size_t len=0; | |
679 | ||
680 | while (*(wxUint32*)psz && (!buf || len < n)) | |
681 | { | |
682 | char tmp[4]; | |
683 | tmp[0] = psz[3]; tmp[1] = psz[2]; | |
684 | tmp[2] = psz[1]; tmp[3] = psz[0]; | |
685 | ||
686 | ||
687 | wxUint16 cc[2]; | |
688 | ||
689 | size_t pa=encode_utf16(*(wxUint32*)tmp, cc); | |
690 | if (pa == (size_t)-1) | |
691 | return pa; | |
692 | ||
693 | if (buf) | |
694 | { | |
695 | *buf++ = cc[0]; | |
696 | if (pa > 1) | |
697 | *buf++ = cc[1]; | |
698 | } | |
699 | len += pa; | |
700 | psz += sizeof(wxUint32); | |
701 | } | |
b5153fd8 VZ |
702 | |
703 | if (buf && len<n) | |
704 | *buf=0; | |
c91830cb VZ |
705 | |
706 | return len; | |
707 | } | |
708 | ||
709 | ||
710 | // swap 16bit String to 32bit MB | |
711 | size_t wxMBConvUTF32swap::WC2MB(char *buf, const wchar_t *psz, size_t n) const | |
712 | { | |
713 | size_t len=0; | |
714 | ||
715 | while (*psz && (!buf || len < n)) | |
716 | { | |
717 | char cc[4]; | |
718 | ||
b5153fd8 VZ |
719 | // cast is ok for WC_UTF16 |
720 | size_t pa=decode_utf16((const wxUint16 *)psz, *(wxUint32*)cc); | |
c91830cb VZ |
721 | if (pa == (size_t)-1) |
722 | return pa; | |
723 | ||
724 | if (buf) | |
725 | { | |
726 | *buf++ = cc[3]; | |
727 | *buf++ = cc[2]; | |
728 | *buf++ = cc[1]; | |
729 | *buf++ = cc[0]; | |
730 | } | |
731 | len += sizeof(wxUint32); | |
732 | psz += pa; | |
733 | } | |
b5153fd8 VZ |
734 | |
735 | if (buf && len<=n-sizeof(wxUint32)) | |
736 | *(wxUint32*)buf=0; | |
c91830cb VZ |
737 | |
738 | return len; | |
739 | } | |
740 | ||
741 | #else // WC_UTF16 | |
742 | ||
743 | ||
744 | // copy 32bit MB to 32bit String | |
745 | size_t wxMBConvUTF32straight::MB2WC(wchar_t *buf, const char *psz, size_t n) const | |
746 | { | |
747 | size_t len=0; | |
748 | ||
749 | while (*(wxUint32*)psz && (!buf || len < n)) | |
750 | { | |
751 | if (buf) | |
752 | *buf++ = *(wxUint32*)psz; | |
753 | len++; | |
754 | psz += sizeof(wxUint32); | |
755 | } | |
b5153fd8 VZ |
756 | |
757 | if (buf && len<n) | |
758 | *buf=0; | |
c91830cb VZ |
759 | |
760 | return len; | |
761 | } | |
762 | ||
763 | ||
764 | // copy 32bit String to 32bit MB | |
765 | size_t wxMBConvUTF32straight::WC2MB(char *buf, const wchar_t *psz, size_t n) const | |
766 | { | |
767 | size_t len=0; | |
768 | ||
769 | while (*psz && (!buf || len < n)) | |
770 | { | |
771 | if (buf) | |
772 | { | |
773 | *(wxUint32*)buf = *psz; | |
774 | buf += sizeof(wxUint32); | |
775 | } | |
776 | ||
777 | len += sizeof(wxUint32); | |
778 | psz++; | |
779 | } | |
780 | ||
b5153fd8 VZ |
781 | if (buf && len<=n-sizeof(wxUint32)) |
782 | *(wxUint32*)buf=0; | |
c91830cb VZ |
783 | |
784 | return len; | |
785 | } | |
786 | ||
787 | ||
788 | // swap 32bit MB to 32bit String | |
789 | size_t wxMBConvUTF32swap::MB2WC(wchar_t *buf, const char *psz, size_t n) const | |
790 | { | |
791 | size_t len=0; | |
792 | ||
793 | while (*(wxUint32*)psz && (!buf || len < n)) | |
794 | { | |
795 | if (buf) | |
796 | { | |
797 | ((char *)buf)[0] = psz[3]; | |
798 | ((char *)buf)[1] = psz[2]; | |
799 | ((char *)buf)[2] = psz[1]; | |
800 | ((char *)buf)[3] = psz[0]; | |
801 | buf++; | |
802 | } | |
803 | len++; | |
804 | psz += sizeof(wxUint32); | |
805 | } | |
b5153fd8 VZ |
806 | |
807 | if (buf && len<n) | |
808 | *buf=0; | |
c91830cb VZ |
809 | |
810 | return len; | |
811 | } | |
812 | ||
813 | ||
814 | // swap 32bit String to 32bit MB | |
815 | size_t wxMBConvUTF32swap::WC2MB(char *buf, const wchar_t *psz, size_t n) const | |
816 | { | |
817 | size_t len=0; | |
818 | ||
819 | while (*psz && (!buf || len < n)) | |
820 | { | |
821 | if (buf) | |
822 | { | |
823 | *buf++ = ((char *)psz)[3]; | |
824 | *buf++ = ((char *)psz)[2]; | |
825 | *buf++ = ((char *)psz)[1]; | |
826 | *buf++ = ((char *)psz)[0]; | |
827 | } | |
828 | len += sizeof(wxUint32); | |
829 | psz++; | |
830 | } | |
b5153fd8 VZ |
831 | |
832 | if (buf && len<=n-sizeof(wxUint32)) | |
833 | *(wxUint32*)buf=0; | |
c91830cb VZ |
834 | |
835 | return len; | |
836 | } | |
837 | ||
838 | ||
839 | #endif // WC_UTF16 | |
840 | ||
841 | ||
36acb880 VZ |
842 | // ============================================================================ |
843 | // The classes doing conversion using the iconv_xxx() functions | |
844 | // ============================================================================ | |
3caec1bb | 845 | |
b040e242 | 846 | #ifdef HAVE_ICONV |
3a0d76bc | 847 | |
3caec1bb VS |
848 | // VS: glibc 2.1.3 is broken in that iconv() conversion to/from UCS4 fails with E2BIG |
849 | // if output buffer is _exactly_ as big as needed. Such case is (unless there's | |
850 | // yet another bug in glibc) the only case when iconv() returns with (size_t)-1 | |
851 | // (which means error) and says there are 0 bytes left in the input buffer -- | |
852 | // when _real_ error occurs, bytes-left-in-input buffer is non-zero. Hence, | |
853 | // this alternative test for iconv() failure. | |
854 | // [This bug does not appear in glibc 2.2.] | |
855 | #if defined(__GLIBC__) && __GLIBC__ == 2 && __GLIBC_MINOR__ <= 1 | |
856 | #define ICONV_FAILED(cres, bufLeft) ((cres == (size_t)-1) && \ | |
857 | (errno != E2BIG || bufLeft != 0)) | |
858 | #else | |
859 | #define ICONV_FAILED(cres, bufLeft) (cres == (size_t)-1) | |
860 | #endif | |
861 | ||
ab217dba | 862 | #define ICONV_CHAR_CAST(x) ((ICONV_CONST char **)(x)) |
36acb880 VZ |
863 | |
864 | // ---------------------------------------------------------------------------- | |
e95354ec | 865 | // wxMBConv_iconv: encapsulates an iconv character set |
36acb880 VZ |
866 | // ---------------------------------------------------------------------------- |
867 | ||
e95354ec | 868 | class wxMBConv_iconv : public wxMBConv |
1cd52418 OK |
869 | { |
870 | public: | |
e95354ec VZ |
871 | wxMBConv_iconv(const wxChar *name); |
872 | virtual ~wxMBConv_iconv(); | |
36acb880 | 873 | |
bde4baac VZ |
874 | virtual size_t MB2WC(wchar_t *buf, const char *psz, size_t n) const; |
875 | virtual size_t WC2MB(char *buf, const wchar_t *psz, size_t n) const; | |
36acb880 | 876 | |
e95354ec | 877 | bool IsOk() const |
36acb880 VZ |
878 | { return (m2w != (iconv_t)-1) && (w2m != (iconv_t)-1); } |
879 | ||
880 | protected: | |
881 | // the iconv handlers used to translate from multibyte to wide char and in | |
882 | // the other direction | |
883 | iconv_t m2w, | |
884 | w2m; | |
885 | ||
886 | private: | |
e95354ec | 887 | // the name (for iconv_open()) of a wide char charset -- if none is |
36acb880 VZ |
888 | // available on this machine, it will remain NULL |
889 | static const char *ms_wcCharsetName; | |
890 | ||
891 | // true if the wide char encoding we use (i.e. ms_wcCharsetName) has | |
892 | // different endian-ness than the native one | |
405d8f46 | 893 | static bool ms_wcNeedsSwap; |
36acb880 VZ |
894 | }; |
895 | ||
e95354ec VZ |
896 | const char *wxMBConv_iconv::ms_wcCharsetName = NULL; |
897 | bool wxMBConv_iconv::ms_wcNeedsSwap = false; | |
36acb880 | 898 | |
e95354ec | 899 | wxMBConv_iconv::wxMBConv_iconv(const wxChar *name) |
36acb880 | 900 | { |
04c79127 RR |
901 | // Do it the hard way |
902 | char cname[100]; | |
903 | for (size_t i = 0; i < wxStrlen(name)+1; i++) | |
904 | cname[i] = (char) name[i]; | |
905 | ||
36acb880 VZ |
906 | // check for charset that represents wchar_t: |
907 | if (ms_wcCharsetName == NULL) | |
f1339c56 | 908 | { |
e95354ec | 909 | ms_wcNeedsSwap = false; |
dccce9ea | 910 | |
36acb880 VZ |
911 | // try charset with explicit bytesex info (e.g. "UCS-4LE"): |
912 | ms_wcCharsetName = WC_NAME_BEST; | |
04c79127 | 913 | m2w = iconv_open(ms_wcCharsetName, cname); |
3a0d76bc | 914 | |
36acb880 VZ |
915 | if (m2w == (iconv_t)-1) |
916 | { | |
917 | // try charset w/o bytesex info (e.g. "UCS4") | |
918 | // and check for bytesex ourselves: | |
919 | ms_wcCharsetName = WC_NAME; | |
04c79127 | 920 | m2w = iconv_open(ms_wcCharsetName, cname); |
36acb880 VZ |
921 | |
922 | // last bet, try if it knows WCHAR_T pseudo-charset | |
3a0d76bc VS |
923 | if (m2w == (iconv_t)-1) |
924 | { | |
36acb880 | 925 | ms_wcCharsetName = "WCHAR_T"; |
04c79127 | 926 | m2w = iconv_open(ms_wcCharsetName, cname); |
36acb880 | 927 | } |
3a0d76bc | 928 | |
36acb880 VZ |
929 | if (m2w != (iconv_t)-1) |
930 | { | |
931 | char buf[2], *bufPtr; | |
932 | wchar_t wbuf[2], *wbufPtr; | |
933 | size_t insz, outsz; | |
934 | size_t res; | |
935 | ||
936 | buf[0] = 'A'; | |
937 | buf[1] = 0; | |
938 | wbuf[0] = 0; | |
939 | insz = 2; | |
940 | outsz = SIZEOF_WCHAR_T * 2; | |
941 | wbufPtr = wbuf; | |
942 | bufPtr = buf; | |
943 | ||
944 | res = iconv(m2w, ICONV_CHAR_CAST(&bufPtr), &insz, | |
945 | (char**)&wbufPtr, &outsz); | |
946 | ||
947 | if (ICONV_FAILED(res, insz)) | |
3a0d76bc | 948 | { |
36acb880 VZ |
949 | ms_wcCharsetName = NULL; |
950 | wxLogLastError(wxT("iconv")); | |
2b5f62a0 | 951 | wxLogError(_("Conversion to charset '%s' doesn't work."), name); |
3a0d76bc VS |
952 | } |
953 | else | |
954 | { | |
36acb880 | 955 | ms_wcNeedsSwap = wbuf[0] != (wchar_t)buf[0]; |
3a0d76bc VS |
956 | } |
957 | } | |
36acb880 VZ |
958 | else |
959 | { | |
960 | ms_wcCharsetName = NULL; | |
373658eb | 961 | |
77ffb593 | 962 | // VS: we must not output an error here, since wxWidgets will safely |
957686c8 VS |
963 | // fall back to using wxEncodingConverter. |
964 | wxLogTrace(wxT("strconv"), wxT("Impossible to convert to/from charset '%s' with iconv, falling back to wxEncodingConverter."), name); | |
965 | //wxLogError( | |
36acb880 | 966 | } |
3a0d76bc | 967 | } |
36acb880 | 968 | wxLogTrace(wxT("strconv"), wxT("wchar_t charset is '%s', needs swap: %i"), ms_wcCharsetName, ms_wcNeedsSwap); |
3a0d76bc | 969 | } |
36acb880 | 970 | else // we already have ms_wcCharsetName |
3caec1bb | 971 | { |
04c79127 | 972 | m2w = iconv_open(ms_wcCharsetName, cname); |
f1339c56 | 973 | } |
dccce9ea | 974 | |
36acb880 VZ |
975 | // NB: don't ever pass NULL to iconv_open(), it may crash! |
976 | if ( ms_wcCharsetName ) | |
f1339c56 | 977 | { |
04c79127 | 978 | w2m = iconv_open( cname, ms_wcCharsetName); |
36acb880 | 979 | } |
405d8f46 VZ |
980 | else |
981 | { | |
982 | w2m = (iconv_t)-1; | |
983 | } | |
36acb880 | 984 | } |
3caec1bb | 985 | |
e95354ec | 986 | wxMBConv_iconv::~wxMBConv_iconv() |
36acb880 VZ |
987 | { |
988 | if ( m2w != (iconv_t)-1 ) | |
989 | iconv_close(m2w); | |
990 | if ( w2m != (iconv_t)-1 ) | |
991 | iconv_close(w2m); | |
992 | } | |
3a0d76bc | 993 | |
bde4baac | 994 | size_t wxMBConv_iconv::MB2WC(wchar_t *buf, const char *psz, size_t n) const |
36acb880 VZ |
995 | { |
996 | size_t inbuf = strlen(psz); | |
997 | size_t outbuf = n * SIZEOF_WCHAR_T; | |
998 | size_t res, cres; | |
999 | // VS: Use these instead of psz, buf because iconv() modifies its arguments: | |
1000 | wchar_t *bufPtr = buf; | |
1001 | const char *pszPtr = psz; | |
1002 | ||
1003 | if (buf) | |
1004 | { | |
1005 | // have destination buffer, convert there | |
1006 | cres = iconv(m2w, | |
1007 | ICONV_CHAR_CAST(&pszPtr), &inbuf, | |
1008 | (char**)&bufPtr, &outbuf); | |
1009 | res = n - (outbuf / SIZEOF_WCHAR_T); | |
dccce9ea | 1010 | |
36acb880 | 1011 | if (ms_wcNeedsSwap) |
3a0d76bc | 1012 | { |
36acb880 VZ |
1013 | // convert to native endianness |
1014 | WC_BSWAP(buf /* _not_ bufPtr */, res) | |
3a0d76bc | 1015 | } |
adb45366 | 1016 | |
49dd9820 VS |
1017 | // NB: iconv was given only strlen(psz) characters on input, and so |
1018 | // it couldn't convert the trailing zero. Let's do it ourselves | |
1019 | // if there's some room left for it in the output buffer. | |
1020 | if (res < n) | |
1021 | buf[res] = 0; | |
36acb880 VZ |
1022 | } |
1023 | else | |
1024 | { | |
1025 | // no destination buffer... convert using temp buffer | |
1026 | // to calculate destination buffer requirement | |
1027 | wchar_t tbuf[8]; | |
1028 | res = 0; | |
1029 | do { | |
1030 | bufPtr = tbuf; | |
1031 | outbuf = 8*SIZEOF_WCHAR_T; | |
1032 | ||
1033 | cres = iconv(m2w, | |
1034 | ICONV_CHAR_CAST(&pszPtr), &inbuf, | |
1035 | (char**)&bufPtr, &outbuf ); | |
1036 | ||
1037 | res += 8-(outbuf/SIZEOF_WCHAR_T); | |
1038 | } while ((cres==(size_t)-1) && (errno==E2BIG)); | |
f1339c56 | 1039 | } |
dccce9ea | 1040 | |
36acb880 | 1041 | if (ICONV_FAILED(cres, inbuf)) |
f1339c56 | 1042 | { |
36acb880 VZ |
1043 | //VS: it is ok if iconv fails, hence trace only |
1044 | wxLogTrace(wxT("strconv"), wxT("iconv failed: %s"), wxSysErrorMsg(wxSysErrorCode())); | |
1045 | return (size_t)-1; | |
1046 | } | |
1047 | ||
1048 | return res; | |
1049 | } | |
1050 | ||
bde4baac | 1051 | size_t wxMBConv_iconv::WC2MB(char *buf, const wchar_t *psz, size_t n) const |
36acb880 | 1052 | { |
f8d791e0 | 1053 | size_t inbuf = wxWcslen(psz) * SIZEOF_WCHAR_T; |
36acb880 VZ |
1054 | size_t outbuf = n; |
1055 | size_t res, cres; | |
3a0d76bc | 1056 | |
36acb880 | 1057 | wchar_t *tmpbuf = 0; |
3caec1bb | 1058 | |
36acb880 VZ |
1059 | if (ms_wcNeedsSwap) |
1060 | { | |
1061 | // need to copy to temp buffer to switch endianness | |
1062 | // this absolutely doesn't rock! | |
1063 | // (no, doing WC_BSWAP twice on the original buffer won't help, as it | |
1064 | // could be in read-only memory, or be accessed in some other thread) | |
1065 | tmpbuf=(wchar_t*)malloc((inbuf+1)*SIZEOF_WCHAR_T); | |
1066 | memcpy(tmpbuf,psz,(inbuf+1)*SIZEOF_WCHAR_T); | |
1067 | WC_BSWAP(tmpbuf, inbuf) | |
1068 | psz=tmpbuf; | |
1069 | } | |
3a0d76bc | 1070 | |
36acb880 VZ |
1071 | if (buf) |
1072 | { | |
1073 | // have destination buffer, convert there | |
1074 | cres = iconv( w2m, ICONV_CHAR_CAST(&psz), &inbuf, &buf, &outbuf ); | |
3a0d76bc | 1075 | |
36acb880 | 1076 | res = n-outbuf; |
adb45366 | 1077 | |
49dd9820 VS |
1078 | // NB: iconv was given only wcslen(psz) characters on input, and so |
1079 | // it couldn't convert the trailing zero. Let's do it ourselves | |
1080 | // if there's some room left for it in the output buffer. | |
1081 | if (res < n) | |
1082 | buf[0] = 0; | |
36acb880 VZ |
1083 | } |
1084 | else | |
1085 | { | |
1086 | // no destination buffer... convert using temp buffer | |
1087 | // to calculate destination buffer requirement | |
1088 | char tbuf[16]; | |
1089 | res = 0; | |
1090 | do { | |
1091 | buf = tbuf; outbuf = 16; | |
1092 | ||
1093 | cres = iconv( w2m, ICONV_CHAR_CAST(&psz), &inbuf, &buf, &outbuf ); | |
dccce9ea | 1094 | |
36acb880 VZ |
1095 | res += 16 - outbuf; |
1096 | } while ((cres==(size_t)-1) && (errno==E2BIG)); | |
f1339c56 | 1097 | } |
dccce9ea | 1098 | |
36acb880 VZ |
1099 | if (ms_wcNeedsSwap) |
1100 | { | |
1101 | free(tmpbuf); | |
1102 | } | |
dccce9ea | 1103 | |
36acb880 VZ |
1104 | if (ICONV_FAILED(cres, inbuf)) |
1105 | { | |
1106 | //VS: it is ok if iconv fails, hence trace only | |
1107 | wxLogTrace(wxT("strconv"), wxT("iconv failed: %s"), wxSysErrorMsg(wxSysErrorCode())); | |
1108 | return (size_t)-1; | |
1109 | } | |
1110 | ||
1111 | return res; | |
1112 | } | |
1113 | ||
b040e242 | 1114 | #endif // HAVE_ICONV |
36acb880 | 1115 | |
e95354ec | 1116 | |
36acb880 VZ |
1117 | // ============================================================================ |
1118 | // Win32 conversion classes | |
1119 | // ============================================================================ | |
1cd52418 | 1120 | |
e95354ec | 1121 | #ifdef wxHAVE_WIN32_MB2WC |
373658eb | 1122 | |
8b04d4c4 | 1123 | // from utils.cpp |
d775fa82 | 1124 | #if wxUSE_FONTMAP |
8b04d4c4 VZ |
1125 | extern WXDLLIMPEXP_BASE long wxCharsetToCodepage(const wxChar *charset); |
1126 | extern WXDLLIMPEXP_BASE long wxEncodingToCodepage(wxFontEncoding encoding); | |
7608a683 | 1127 | #endif |
373658eb | 1128 | |
e95354ec | 1129 | class wxMBConv_win32 : public wxMBConv |
1cd52418 OK |
1130 | { |
1131 | public: | |
bde4baac VZ |
1132 | wxMBConv_win32() |
1133 | { | |
1134 | m_CodePage = CP_ACP; | |
1135 | } | |
1136 | ||
7608a683 | 1137 | #if wxUSE_FONTMAP |
e95354ec | 1138 | wxMBConv_win32(const wxChar* name) |
bde4baac VZ |
1139 | { |
1140 | m_CodePage = wxCharsetToCodepage(name); | |
1141 | } | |
dccce9ea | 1142 | |
e95354ec | 1143 | wxMBConv_win32(wxFontEncoding encoding) |
bde4baac VZ |
1144 | { |
1145 | m_CodePage = wxEncodingToCodepage(encoding); | |
1146 | } | |
7608a683 | 1147 | #endif |
8b04d4c4 | 1148 | |
bde4baac | 1149 | size_t MB2WC(wchar_t *buf, const char *psz, size_t n) const |
f1339c56 | 1150 | { |
02272c9c VZ |
1151 | // note that we have to use MB_ERR_INVALID_CHARS flag as it without it |
1152 | // the behaviour is not compatible with the Unix version (using iconv) | |
1153 | // and break the library itself, e.g. wxTextInputStream::NextChar() | |
1154 | // wouldn't work if reading an incomplete MB char didn't result in an | |
1155 | // error | |
2b5f62a0 VZ |
1156 | const size_t len = ::MultiByteToWideChar |
1157 | ( | |
1158 | m_CodePage, // code page | |
02272c9c | 1159 | MB_ERR_INVALID_CHARS, // flags: fall on error |
2b5f62a0 VZ |
1160 | psz, // input string |
1161 | -1, // its length (NUL-terminated) | |
b4da152e | 1162 | buf, // output string |
2b5f62a0 VZ |
1163 | buf ? n : 0 // size of output buffer |
1164 | ); | |
1165 | ||
03a991bc VZ |
1166 | // note that it returns count of written chars for buf != NULL and size |
1167 | // of the needed buffer for buf == NULL so in either case the length of | |
1168 | // the string (which never includes the terminating NUL) is one less | |
1169 | return len ? len - 1 : (size_t)-1; | |
f1339c56 | 1170 | } |
dccce9ea | 1171 | |
13dd924a | 1172 | size_t WC2MB(char *buf, const wchar_t *pwz, size_t n) const |
f1339c56 | 1173 | { |
13dd924a VZ |
1174 | /* |
1175 | we have a problem here: by default, WideCharToMultiByte() may | |
1176 | replace characters unrepresentable in the target code page with bad | |
1177 | quality approximations such as turning "1/2" symbol (U+00BD) into | |
1178 | "1" for the code pages which don't have it and we, obviously, want | |
1179 | to avoid this at any price | |
d775fa82 | 1180 | |
13dd924a VZ |
1181 | the trouble is that this function does it _silently_, i.e. it won't |
1182 | even tell us whether it did or not... Win98/2000 and higher provide | |
1183 | WC_NO_BEST_FIT_CHARS but it doesn't work for the older systems and | |
1184 | we have to resort to a round trip, i.e. check that converting back | |
1185 | results in the same string -- this is, of course, expensive but | |
1186 | otherwise we simply can't be sure to not garble the data. | |
1187 | */ | |
1188 | ||
1189 | // determine if we can rely on WC_NO_BEST_FIT_CHARS: according to MSDN | |
1190 | // it doesn't work with CJK encodings (which we test for rather roughly | |
1191 | // here...) nor with UTF-7/8 nor, of course, with Windows versions not | |
1192 | // supporting it | |
907173e5 WS |
1193 | BOOL usedDef wxDUMMY_INITIALIZE(false); |
1194 | BOOL *pUsedDef; | |
13dd924a VZ |
1195 | int flags; |
1196 | if ( CanUseNoBestFit() && m_CodePage < 50000 ) | |
1197 | { | |
1198 | // it's our lucky day | |
1199 | flags = WC_NO_BEST_FIT_CHARS; | |
1200 | pUsedDef = &usedDef; | |
1201 | } | |
1202 | else // old system or unsupported encoding | |
1203 | { | |
1204 | flags = 0; | |
1205 | pUsedDef = NULL; | |
1206 | } | |
1207 | ||
2b5f62a0 VZ |
1208 | const size_t len = ::WideCharToMultiByte |
1209 | ( | |
1210 | m_CodePage, // code page | |
13dd924a VZ |
1211 | flags, // either none or no best fit |
1212 | pwz, // input string | |
2b5f62a0 VZ |
1213 | -1, // it is (wide) NUL-terminated |
1214 | buf, // output buffer | |
1215 | buf ? n : 0, // and its size | |
1216 | NULL, // default "replacement" char | |
13dd924a | 1217 | pUsedDef // [out] was it used? |
2b5f62a0 VZ |
1218 | ); |
1219 | ||
13dd924a VZ |
1220 | if ( !len ) |
1221 | { | |
1222 | // function totally failed | |
1223 | return (size_t)-1; | |
1224 | } | |
1225 | ||
1226 | // if we were really converting, check if we succeeded | |
1227 | if ( buf ) | |
1228 | { | |
1229 | if ( flags ) | |
1230 | { | |
1231 | // check if the conversion failed, i.e. if any replacements | |
1232 | // were done | |
1233 | if ( usedDef ) | |
1234 | return (size_t)-1; | |
1235 | } | |
1236 | else // we must resort to double tripping... | |
1237 | { | |
1238 | wxWCharBuffer wcBuf(n); | |
1239 | if ( MB2WC(wcBuf.data(), buf, n) == (size_t)-1 || | |
1240 | wcscmp(wcBuf, pwz) != 0 ) | |
1241 | { | |
1242 | // we didn't obtain the same thing we started from, hence | |
1243 | // the conversion was lossy and we consider that it failed | |
1244 | return (size_t)-1; | |
1245 | } | |
1246 | } | |
1247 | } | |
1248 | ||
03a991bc | 1249 | // see the comment above for the reason of "len - 1" |
13dd924a | 1250 | return len - 1; |
f1339c56 | 1251 | } |
dccce9ea | 1252 | |
13dd924a VZ |
1253 | bool IsOk() const { return m_CodePage != -1; } |
1254 | ||
1255 | private: | |
1256 | static bool CanUseNoBestFit() | |
1257 | { | |
1258 | static int s_isWin98Or2k = -1; | |
1259 | ||
1260 | if ( s_isWin98Or2k == -1 ) | |
1261 | { | |
1262 | int verMaj, verMin; | |
1263 | switch ( wxGetOsVersion(&verMaj, &verMin) ) | |
1264 | { | |
1265 | case wxWIN95: | |
1266 | s_isWin98Or2k = verMaj >= 4 && verMin >= 10; | |
1267 | break; | |
1268 | ||
1269 | case wxWINDOWS_NT: | |
1270 | s_isWin98Or2k = verMaj >= 5; | |
1271 | break; | |
1272 | ||
1273 | default: | |
1274 | // unknown, be conseravtive by default | |
1275 | s_isWin98Or2k = 0; | |
1276 | } | |
1277 | ||
1278 | wxASSERT_MSG( s_isWin98Or2k != -1, _T("should be set above") ); | |
1279 | } | |
1280 | ||
1281 | return s_isWin98Or2k == 1; | |
1282 | } | |
f1339c56 | 1283 | |
b1d66b54 | 1284 | long m_CodePage; |
1cd52418 | 1285 | }; |
e95354ec VZ |
1286 | |
1287 | #endif // wxHAVE_WIN32_MB2WC | |
1288 | ||
335d31e0 SC |
1289 | // ============================================================================ |
1290 | // Mac conversion classes | |
1291 | // ============================================================================ | |
1292 | ||
1293 | #if defined(__WXMAC__) && defined(TARGET_CARBON) | |
1294 | ||
1295 | class wxMBConv_mac : public wxMBConv | |
1296 | { | |
1297 | public: | |
1298 | wxMBConv_mac() | |
1299 | { | |
1300 | Init(CFStringGetSystemEncoding()) ; | |
1301 | } | |
1302 | ||
1303 | wxMBConv_mac(const wxChar* name) | |
1304 | { | |
d775fa82 | 1305 | Init( wxMacGetSystemEncFromFontEnc(wxFontMapper::Get()->CharsetToEncoding(name, false) ) ) ; |
335d31e0 SC |
1306 | } |
1307 | ||
1308 | wxMBConv_mac(wxFontEncoding encoding) | |
1309 | { | |
d775fa82 WS |
1310 | Init( wxMacGetSystemEncFromFontEnc(encoding) ); |
1311 | } | |
1312 | ||
1313 | ~wxMBConv_mac() | |
1314 | { | |
1315 | OSStatus status = noErr ; | |
1316 | status = TECDisposeConverter(m_MB2WC_converter); | |
1317 | status = TECDisposeConverter(m_WC2MB_converter); | |
1318 | } | |
1319 | ||
1320 | ||
1321 | void Init( TextEncodingBase encoding) | |
1322 | { | |
1323 | OSStatus status = noErr ; | |
1324 | m_char_encoding = encoding ; | |
1325 | m_unicode_encoding = CreateTextEncoding(kTextEncodingUnicodeDefault,0,kUnicode16BitFormat) ; | |
1326 | ||
1327 | status = TECCreateConverter(&m_MB2WC_converter, | |
1328 | m_char_encoding, | |
1329 | m_unicode_encoding); | |
1330 | status = TECCreateConverter(&m_WC2MB_converter, | |
1331 | m_unicode_encoding, | |
1332 | m_char_encoding); | |
1333 | } | |
1334 | ||
335d31e0 SC |
1335 | size_t MB2WC(wchar_t *buf, const char *psz, size_t n) const |
1336 | { | |
d775fa82 WS |
1337 | OSStatus status = noErr ; |
1338 | ByteCount byteOutLen ; | |
1339 | ByteCount byteInLen = strlen(psz) ; | |
1340 | wchar_t *tbuf = NULL ; | |
1341 | UniChar* ubuf = NULL ; | |
1342 | size_t res = 0 ; | |
1343 | ||
1344 | if (buf == NULL) | |
1345 | { | |
1346 | n = byteInLen ; | |
1347 | tbuf = (wchar_t*) malloc( n * SIZEOF_WCHAR_T) ; | |
1348 | } | |
1349 | ByteCount byteBufferLen = n * sizeof( UniChar ) ; | |
f3a355ce | 1350 | #if SIZEOF_WCHAR_T == 4 |
d775fa82 | 1351 | ubuf = (UniChar*) malloc( byteBufferLen + 2 ) ; |
f3a355ce | 1352 | #else |
d775fa82 | 1353 | ubuf = (UniChar*) (buf ? buf : tbuf) ; |
f3a355ce | 1354 | #endif |
d775fa82 WS |
1355 | status = TECConvertText(m_MB2WC_converter, (ConstTextPtr) psz , byteInLen, &byteInLen, |
1356 | (TextPtr) ubuf , byteBufferLen, &byteOutLen); | |
f3a355ce | 1357 | #if SIZEOF_WCHAR_T == 4 |
8471ea90 SC |
1358 | // we have to terminate here, because n might be larger for the trailing zero, and if UniChar |
1359 | // is not properly terminated we get random characters at the end | |
1360 | ubuf[byteOutLen / sizeof( UniChar ) ] = 0 ; | |
d775fa82 WS |
1361 | wxMBConvUTF16BE converter ; |
1362 | res = converter.MB2WC( (buf ? buf : tbuf) , (const char*)ubuf , n ) ; | |
1363 | free( ubuf ) ; | |
f3a355ce | 1364 | #else |
d775fa82 | 1365 | res = byteOutLen / sizeof( UniChar ) ; |
f3a355ce | 1366 | #endif |
d775fa82 WS |
1367 | if ( buf == NULL ) |
1368 | free(tbuf) ; | |
335d31e0 | 1369 | |
335d31e0 SC |
1370 | if ( buf && res < n) |
1371 | buf[res] = 0; | |
1372 | ||
d775fa82 | 1373 | return res ; |
335d31e0 SC |
1374 | } |
1375 | ||
1376 | size_t WC2MB(char *buf, const wchar_t *psz, size_t n) const | |
d775fa82 WS |
1377 | { |
1378 | OSStatus status = noErr ; | |
1379 | ByteCount byteOutLen ; | |
1380 | ByteCount byteInLen = wxWcslen(psz) * SIZEOF_WCHAR_T ; | |
1381 | ||
1382 | char *tbuf = NULL ; | |
1383 | ||
1384 | if (buf == NULL) | |
1385 | { | |
1386 | // worst case | |
1387 | n = byteInLen * 2 ; | |
1388 | tbuf = (char*) malloc( n ) ; | |
1389 | } | |
1390 | ||
1391 | ByteCount byteBufferLen = n ; | |
1392 | UniChar* ubuf = NULL ; | |
f3a355ce | 1393 | #if SIZEOF_WCHAR_T == 4 |
d775fa82 WS |
1394 | wxMBConvUTF16BE converter ; |
1395 | size_t unicharlen = converter.WC2MB( NULL , psz , 0 ) ; | |
1396 | byteInLen = unicharlen ; | |
1397 | ubuf = (UniChar*) malloc( byteInLen + 2 ) ; | |
1398 | converter.WC2MB( (char*) ubuf , psz, unicharlen + 2 ) ; | |
f3a355ce | 1399 | #else |
d775fa82 | 1400 | ubuf = (UniChar*) psz ; |
f3a355ce | 1401 | #endif |
d775fa82 WS |
1402 | status = TECConvertText(m_WC2MB_converter, (ConstTextPtr) ubuf , byteInLen, &byteInLen, |
1403 | (TextPtr) (buf ? buf : tbuf) , byteBufferLen, &byteOutLen); | |
f3a355ce | 1404 | #if SIZEOF_WCHAR_T == 4 |
d775fa82 | 1405 | free( ubuf ) ; |
f3a355ce | 1406 | #endif |
d775fa82 WS |
1407 | if ( buf == NULL ) |
1408 | free(tbuf) ; | |
335d31e0 | 1409 | |
d775fa82 | 1410 | size_t res = byteOutLen ; |
335d31e0 SC |
1411 | if ( buf && res < n) |
1412 | buf[res] = 0; | |
1413 | ||
d775fa82 | 1414 | return res ; |
335d31e0 SC |
1415 | } |
1416 | ||
1417 | bool IsOk() const | |
1418 | { return m_MB2WC_converter != NULL && m_WC2MB_converter != NULL ; } | |
1419 | ||
1420 | private: | |
d775fa82 WS |
1421 | TECObjectRef m_MB2WC_converter ; |
1422 | TECObjectRef m_WC2MB_converter ; | |
1423 | ||
1424 | TextEncodingBase m_char_encoding ; | |
1425 | TextEncodingBase m_unicode_encoding ; | |
335d31e0 SC |
1426 | }; |
1427 | ||
1428 | #endif // defined(__WXMAC__) && defined(TARGET_CARBON) | |
1e6feb95 | 1429 | |
36acb880 VZ |
1430 | // ============================================================================ |
1431 | // wxEncodingConverter based conversion classes | |
1432 | // ============================================================================ | |
1433 | ||
1e6feb95 | 1434 | #if wxUSE_FONTMAP |
1cd52418 | 1435 | |
e95354ec | 1436 | class wxMBConv_wxwin : public wxMBConv |
1cd52418 | 1437 | { |
8b04d4c4 VZ |
1438 | private: |
1439 | void Init() | |
1440 | { | |
1441 | m_ok = m2w.Init(m_enc, wxFONTENCODING_UNICODE) && | |
1442 | w2m.Init(wxFONTENCODING_UNICODE, m_enc); | |
1443 | } | |
1444 | ||
6001e347 | 1445 | public: |
f1339c56 RR |
1446 | // temporarily just use wxEncodingConverter stuff, |
1447 | // so that it works while a better implementation is built | |
e95354ec | 1448 | wxMBConv_wxwin(const wxChar* name) |
f1339c56 RR |
1449 | { |
1450 | if (name) | |
e95354ec | 1451 | m_enc = wxFontMapper::Get()->CharsetToEncoding(name, false); |
8b04d4c4 VZ |
1452 | else |
1453 | m_enc = wxFONTENCODING_SYSTEM; | |
cafbf6fb | 1454 | |
8b04d4c4 VZ |
1455 | Init(); |
1456 | } | |
1457 | ||
e95354ec | 1458 | wxMBConv_wxwin(wxFontEncoding enc) |
8b04d4c4 VZ |
1459 | { |
1460 | m_enc = enc; | |
1461 | ||
1462 | Init(); | |
f1339c56 | 1463 | } |
dccce9ea | 1464 | |
bde4baac | 1465 | size_t MB2WC(wchar_t *buf, const char *psz, size_t WXUNUSED(n)) const |
f1339c56 RR |
1466 | { |
1467 | size_t inbuf = strlen(psz); | |
dccce9ea | 1468 | if (buf) |
4def3b35 | 1469 | m2w.Convert(psz,buf); |
f1339c56 RR |
1470 | return inbuf; |
1471 | } | |
dccce9ea | 1472 | |
bde4baac | 1473 | size_t WC2MB(char *buf, const wchar_t *psz, size_t WXUNUSED(n)) const |
f1339c56 | 1474 | { |
f8d791e0 | 1475 | const size_t inbuf = wxWcslen(psz); |
f1339c56 RR |
1476 | if (buf) |
1477 | w2m.Convert(psz,buf); | |
dccce9ea | 1478 | |
f1339c56 RR |
1479 | return inbuf; |
1480 | } | |
dccce9ea | 1481 | |
e95354ec | 1482 | bool IsOk() const { return m_ok; } |
f1339c56 RR |
1483 | |
1484 | public: | |
8b04d4c4 | 1485 | wxFontEncoding m_enc; |
f1339c56 | 1486 | wxEncodingConverter m2w, w2m; |
cafbf6fb VZ |
1487 | |
1488 | // were we initialized successfully? | |
1489 | bool m_ok; | |
fc7a2a60 | 1490 | |
e95354ec | 1491 | DECLARE_NO_COPY_CLASS(wxMBConv_wxwin) |
f6bcfd97 | 1492 | }; |
6001e347 | 1493 | |
1e6feb95 VZ |
1494 | #endif // wxUSE_FONTMAP |
1495 | ||
36acb880 VZ |
1496 | // ============================================================================ |
1497 | // wxCSConv implementation | |
1498 | // ============================================================================ | |
1499 | ||
8b04d4c4 | 1500 | void wxCSConv::Init() |
6001e347 | 1501 | { |
e95354ec VZ |
1502 | m_name = NULL; |
1503 | m_convReal = NULL; | |
1504 | m_deferred = true; | |
1505 | } | |
1506 | ||
8b04d4c4 VZ |
1507 | wxCSConv::wxCSConv(const wxChar *charset) |
1508 | { | |
1509 | Init(); | |
82713003 | 1510 | |
e95354ec VZ |
1511 | if ( charset ) |
1512 | { | |
e95354ec VZ |
1513 | SetName(charset); |
1514 | } | |
bda3d86a VZ |
1515 | |
1516 | m_encoding = wxFONTENCODING_SYSTEM; | |
6001e347 RR |
1517 | } |
1518 | ||
8b04d4c4 VZ |
1519 | wxCSConv::wxCSConv(wxFontEncoding encoding) |
1520 | { | |
bda3d86a | 1521 | if ( encoding == wxFONTENCODING_MAX || encoding == wxFONTENCODING_DEFAULT ) |
e95354ec VZ |
1522 | { |
1523 | wxFAIL_MSG( _T("invalid encoding value in wxCSConv ctor") ); | |
1524 | ||
1525 | encoding = wxFONTENCODING_SYSTEM; | |
1526 | } | |
1527 | ||
8b04d4c4 VZ |
1528 | Init(); |
1529 | ||
bda3d86a | 1530 | m_encoding = encoding; |
8b04d4c4 VZ |
1531 | } |
1532 | ||
6001e347 RR |
1533 | wxCSConv::~wxCSConv() |
1534 | { | |
65e50848 JS |
1535 | Clear(); |
1536 | } | |
1537 | ||
54380f29 | 1538 | wxCSConv::wxCSConv(const wxCSConv& conv) |
8b04d4c4 | 1539 | : wxMBConv() |
54380f29 | 1540 | { |
8b04d4c4 VZ |
1541 | Init(); |
1542 | ||
54380f29 | 1543 | SetName(conv.m_name); |
8b04d4c4 | 1544 | m_encoding = conv.m_encoding; |
54380f29 GD |
1545 | } |
1546 | ||
1547 | wxCSConv& wxCSConv::operator=(const wxCSConv& conv) | |
1548 | { | |
1549 | Clear(); | |
8b04d4c4 | 1550 | |
54380f29 | 1551 | SetName(conv.m_name); |
8b04d4c4 VZ |
1552 | m_encoding = conv.m_encoding; |
1553 | ||
54380f29 GD |
1554 | return *this; |
1555 | } | |
1556 | ||
65e50848 JS |
1557 | void wxCSConv::Clear() |
1558 | { | |
8b04d4c4 | 1559 | free(m_name); |
e95354ec | 1560 | delete m_convReal; |
8b04d4c4 | 1561 | |
65e50848 | 1562 | m_name = NULL; |
e95354ec | 1563 | m_convReal = NULL; |
6001e347 RR |
1564 | } |
1565 | ||
1566 | void wxCSConv::SetName(const wxChar *charset) | |
1567 | { | |
f1339c56 RR |
1568 | if (charset) |
1569 | { | |
1570 | m_name = wxStrdup(charset); | |
e95354ec | 1571 | m_deferred = true; |
f1339c56 | 1572 | } |
6001e347 RR |
1573 | } |
1574 | ||
e95354ec VZ |
1575 | wxMBConv *wxCSConv::DoCreate() const |
1576 | { | |
c547282d VZ |
1577 | // check for the special case of ASCII or ISO8859-1 charset: as we have |
1578 | // special knowledge of it anyhow, we don't need to create a special | |
1579 | // conversion object | |
1580 | if ( m_encoding == wxFONTENCODING_ISO8859_1 ) | |
f1339c56 | 1581 | { |
e95354ec VZ |
1582 | // don't convert at all |
1583 | return NULL; | |
1584 | } | |
dccce9ea | 1585 | |
e95354ec VZ |
1586 | // we trust OS to do conversion better than we can so try external |
1587 | // conversion methods first | |
1588 | // | |
1589 | // the full order is: | |
1590 | // 1. OS conversion (iconv() under Unix or Win32 API) | |
1591 | // 2. hard coded conversions for UTF | |
1592 | // 3. wxEncodingConverter as fall back | |
1593 | ||
1594 | // step (1) | |
1595 | #ifdef HAVE_ICONV | |
c547282d | 1596 | #if !wxUSE_FONTMAP |
e95354ec | 1597 | if ( m_name ) |
c547282d | 1598 | #endif // !wxUSE_FONTMAP |
e95354ec | 1599 | { |
c547282d VZ |
1600 | wxString name(m_name); |
1601 | ||
1602 | #if wxUSE_FONTMAP | |
1603 | if ( name.empty() ) | |
1604 | name = wxFontMapper::Get()->GetEncodingName(m_encoding); | |
1605 | #endif // wxUSE_FONTMAP | |
1606 | ||
1607 | wxMBConv_iconv *conv = new wxMBConv_iconv(name); | |
e95354ec VZ |
1608 | if ( conv->IsOk() ) |
1609 | return conv; | |
1610 | ||
1611 | delete conv; | |
1612 | } | |
1613 | #endif // HAVE_ICONV | |
1614 | ||
1615 | #ifdef wxHAVE_WIN32_MB2WC | |
1616 | { | |
7608a683 | 1617 | #if wxUSE_FONTMAP |
e95354ec VZ |
1618 | wxMBConv_win32 *conv = m_name ? new wxMBConv_win32(m_name) |
1619 | : new wxMBConv_win32(m_encoding); | |
1620 | if ( conv->IsOk() ) | |
1621 | return conv; | |
1622 | ||
1623 | delete conv; | |
7608a683 WS |
1624 | #else |
1625 | return NULL; | |
1626 | #endif | |
e95354ec VZ |
1627 | } |
1628 | #endif // wxHAVE_WIN32_MB2WC | |
d775fa82 WS |
1629 | #if defined(__WXMAC__) |
1630 | { | |
1631 | if ( m_name || ( m_encoding < wxFONTENCODING_UTF16BE ) ) | |
1632 | { | |
1633 | ||
1634 | wxMBConv_mac *conv = m_name ? new wxMBConv_mac(m_name) | |
1635 | : new wxMBConv_mac(m_encoding); | |
1636 | if ( conv->IsOk() ) | |
1637 | return conv; | |
1638 | ||
1639 | delete conv; | |
1640 | } | |
335d31e0 SC |
1641 | } |
1642 | #endif | |
e95354ec VZ |
1643 | // step (2) |
1644 | wxFontEncoding enc = m_encoding; | |
1645 | #if wxUSE_FONTMAP | |
c547282d VZ |
1646 | if ( enc == wxFONTENCODING_SYSTEM && m_name ) |
1647 | { | |
1648 | // use "false" to suppress interactive dialogs -- we can be called from | |
1649 | // anywhere and popping up a dialog from here is the last thing we want to | |
1650 | // do | |
1651 | enc = wxFontMapper::Get()->CharsetToEncoding(m_name, false); | |
1652 | } | |
e95354ec VZ |
1653 | #endif // wxUSE_FONTMAP |
1654 | ||
1655 | switch ( enc ) | |
1656 | { | |
1657 | case wxFONTENCODING_UTF7: | |
1658 | return new wxMBConvUTF7; | |
1659 | ||
1660 | case wxFONTENCODING_UTF8: | |
1661 | return new wxMBConvUTF8; | |
1662 | ||
e95354ec VZ |
1663 | case wxFONTENCODING_UTF16BE: |
1664 | return new wxMBConvUTF16BE; | |
1665 | ||
1666 | case wxFONTENCODING_UTF16LE: | |
1667 | return new wxMBConvUTF16LE; | |
1668 | ||
e95354ec VZ |
1669 | case wxFONTENCODING_UTF32BE: |
1670 | return new wxMBConvUTF32BE; | |
1671 | ||
1672 | case wxFONTENCODING_UTF32LE: | |
1673 | return new wxMBConvUTF32LE; | |
1674 | ||
1675 | default: | |
1676 | // nothing to do but put here to suppress gcc warnings | |
1677 | ; | |
1678 | } | |
1679 | ||
1680 | // step (3) | |
1681 | #if wxUSE_FONTMAP | |
1682 | { | |
1683 | wxMBConv_wxwin *conv = m_name ? new wxMBConv_wxwin(m_name) | |
1684 | : new wxMBConv_wxwin(m_encoding); | |
1685 | if ( conv->IsOk() ) | |
1686 | return conv; | |
1687 | ||
1688 | delete conv; | |
1689 | } | |
1690 | #endif // wxUSE_FONTMAP | |
1691 | ||
a58d4f4d VS |
1692 | // NB: This is a hack to prevent deadlock. What could otherwise happen |
1693 | // in Unicode build: wxConvLocal creation ends up being here | |
1694 | // because of some failure and logs the error. But wxLog will try to | |
1695 | // attach timestamp, for which it will need wxConvLocal (to convert | |
1696 | // time to char* and then wchar_t*), but that fails, tries to log | |
1697 | // error, but wxLog has a (already locked) critical section that | |
1698 | // guards static buffer. | |
1699 | static bool alreadyLoggingError = false; | |
1700 | if (!alreadyLoggingError) | |
1701 | { | |
1702 | alreadyLoggingError = true; | |
1703 | wxLogError(_("Cannot convert from the charset '%s'!"), | |
1704 | m_name ? m_name | |
e95354ec VZ |
1705 | : |
1706 | #if wxUSE_FONTMAP | |
1707 | wxFontMapper::GetEncodingDescription(m_encoding).c_str() | |
1708 | #else // !wxUSE_FONTMAP | |
1709 | wxString::Format(_("encoding %s"), m_encoding).c_str() | |
1710 | #endif // wxUSE_FONTMAP/!wxUSE_FONTMAP | |
1711 | ); | |
a58d4f4d VS |
1712 | alreadyLoggingError = false; |
1713 | } | |
e95354ec VZ |
1714 | |
1715 | return NULL; | |
1716 | } | |
1717 | ||
1718 | void wxCSConv::CreateConvIfNeeded() const | |
1719 | { | |
1720 | if ( m_deferred ) | |
1721 | { | |
1722 | wxCSConv *self = (wxCSConv *)this; // const_cast | |
bda3d86a VZ |
1723 | |
1724 | #if wxUSE_INTL | |
1725 | // if we don't have neither the name nor the encoding, use the default | |
1726 | // encoding for this system | |
1727 | if ( !m_name && m_encoding == wxFONTENCODING_SYSTEM ) | |
1728 | { | |
4d312c22 | 1729 | self->m_name = wxStrdup(wxLocale::GetSystemEncodingName()); |
bda3d86a VZ |
1730 | } |
1731 | #endif // wxUSE_INTL | |
1732 | ||
e95354ec VZ |
1733 | self->m_convReal = DoCreate(); |
1734 | self->m_deferred = false; | |
6001e347 | 1735 | } |
6001e347 RR |
1736 | } |
1737 | ||
1738 | size_t wxCSConv::MB2WC(wchar_t *buf, const char *psz, size_t n) const | |
1739 | { | |
e95354ec | 1740 | CreateConvIfNeeded(); |
dccce9ea | 1741 | |
e95354ec VZ |
1742 | if (m_convReal) |
1743 | return m_convReal->MB2WC(buf, psz, n); | |
f1339c56 RR |
1744 | |
1745 | // latin-1 (direct) | |
4def3b35 | 1746 | size_t len = strlen(psz); |
dccce9ea | 1747 | |
f1339c56 RR |
1748 | if (buf) |
1749 | { | |
4def3b35 | 1750 | for (size_t c = 0; c <= len; c++) |
f1339c56 RR |
1751 | buf[c] = (unsigned char)(psz[c]); |
1752 | } | |
dccce9ea | 1753 | |
f1339c56 | 1754 | return len; |
6001e347 RR |
1755 | } |
1756 | ||
1757 | size_t wxCSConv::WC2MB(char *buf, const wchar_t *psz, size_t n) const | |
1758 | { | |
e95354ec | 1759 | CreateConvIfNeeded(); |
dccce9ea | 1760 | |
e95354ec VZ |
1761 | if (m_convReal) |
1762 | return m_convReal->WC2MB(buf, psz, n); | |
1cd52418 | 1763 | |
f1339c56 | 1764 | // latin-1 (direct) |
f8d791e0 | 1765 | const size_t len = wxWcslen(psz); |
f1339c56 RR |
1766 | if (buf) |
1767 | { | |
4def3b35 | 1768 | for (size_t c = 0; c <= len; c++) |
24642831 VS |
1769 | { |
1770 | if (psz[c] > 0xFF) | |
1771 | return (size_t)-1; | |
907173e5 | 1772 | buf[c] = (char)psz[c]; |
24642831 VS |
1773 | } |
1774 | } | |
1775 | else | |
1776 | { | |
1777 | for (size_t c = 0; c <= len; c++) | |
1778 | { | |
1779 | if (psz[c] > 0xFF) | |
1780 | return (size_t)-1; | |
1781 | } | |
f1339c56 | 1782 | } |
dccce9ea | 1783 | |
f1339c56 | 1784 | return len; |
6001e347 RR |
1785 | } |
1786 | ||
bde4baac VZ |
1787 | // ---------------------------------------------------------------------------- |
1788 | // globals | |
1789 | // ---------------------------------------------------------------------------- | |
1790 | ||
1791 | #ifdef __WINDOWS__ | |
1792 | static wxMBConv_win32 wxConvLibcObj; | |
f81f5901 SC |
1793 | #elif defined(__WXMAC__) && !defined(__MACH__) |
1794 | static wxMBConv_mac wxConvLibcObj ; | |
bde4baac | 1795 | #else |
dcc8fac0 | 1796 | static wxMBConvLibc wxConvLibcObj; |
bde4baac VZ |
1797 | #endif |
1798 | ||
1799 | static wxCSConv wxConvLocalObj(wxFONTENCODING_SYSTEM); | |
1800 | static wxCSConv wxConvISO8859_1Obj(wxFONTENCODING_ISO8859_1); | |
1801 | static wxMBConvUTF7 wxConvUTF7Obj; | |
1802 | static wxMBConvUTF8 wxConvUTF8Obj; | |
1803 | ||
1804 | ||
1805 | WXDLLIMPEXP_DATA_BASE(wxMBConv&) wxConvLibc = wxConvLibcObj; | |
1806 | WXDLLIMPEXP_DATA_BASE(wxCSConv&) wxConvLocal = wxConvLocalObj; | |
1807 | WXDLLIMPEXP_DATA_BASE(wxCSConv&) wxConvISO8859_1 = wxConvISO8859_1Obj; | |
1808 | WXDLLIMPEXP_DATA_BASE(wxMBConvUTF7&) wxConvUTF7 = wxConvUTF7Obj; | |
1809 | WXDLLIMPEXP_DATA_BASE(wxMBConvUTF8&) wxConvUTF8 = wxConvUTF8Obj; | |
1810 | WXDLLIMPEXP_DATA_BASE(wxMBConv *) wxConvCurrent = &wxConvLibcObj; | |
1811 | ||
1812 | #else // !wxUSE_WCHAR_T | |
1813 | ||
1814 | // stand-ins in absence of wchar_t | |
1815 | WXDLLIMPEXP_DATA_BASE(wxMBConv) wxConvLibc, | |
1816 | wxConvISO8859_1, | |
1817 | wxConvLocal, | |
1818 | wxConvUTF8; | |
1819 | ||
1820 | #endif // wxUSE_WCHAR_T/!wxUSE_WCHAR_T | |
6001e347 RR |
1821 | |
1822 |