Commit | Line | Data |
---|---|---|
6001e347 RR |
1 | /////////////////////////////////////////////////////////////////////////////// |
2 | // Name: strconv.h | |
3 | // Purpose: conversion routines for char sets any Unicode | |
467e0479 | 4 | // Author: Ove Kaaven, Robert Roebling, Vadim Zeitlin |
6001e347 RR |
5 | // Modified by: |
6 | // Created: 29/01/98 | |
7 | // RCS-ID: $Id$ | |
467e0479 VZ |
8 | // Copyright: (c) 1998 Ove Kaaven, Robert Roebling |
9 | // (c) 1998-2006 Vadim Zeitlin | |
65571936 | 10 | // Licence: wxWindows licence |
6001e347 RR |
11 | /////////////////////////////////////////////////////////////////////////////// |
12 | ||
d36c9347 VZ |
13 | #ifndef _WX_STRCONV_H_ |
14 | #define _WX_STRCONV_H_ | |
6001e347 | 15 | |
6001e347 | 16 | #include "wx/defs.h" |
e3f6cbd9 | 17 | #include "wx/chartype.h" |
6001e347 RR |
18 | #include "wx/buffer.h" |
19 | ||
7db39dd6 CE |
20 | #ifdef __DIGITALMARS__ |
21 | #include "typeinfo.h" | |
22 | #endif | |
23 | ||
9dea36ef DW |
24 | #if defined(__VISAGECPP__) && __IBMCPP__ >= 400 |
25 | # undef __BSEXCPT__ | |
26 | #endif | |
dccce9ea | 27 | |
9b4da627 | 28 | #ifndef __WXPALMOS5__ |
6001e347 | 29 | #include <stdlib.h> |
9b4da627 | 30 | #endif // ! __WXPALMOS5__ |
6001e347 RR |
31 | |
32 | #if wxUSE_WCHAR_T | |
33 | ||
b5dbe15d | 34 | class WXDLLIMPEXP_FWD_BASE wxString; |
86501081 | 35 | |
483b0434 VZ |
36 | // the error value returned by wxMBConv methods |
37 | #define wxCONV_FAILED ((size_t)-1) | |
38 | ||
467e0479 VZ |
39 | // the default value for some length parameters meaning that the string is |
40 | // NUL-terminated | |
41 | #define wxNO_LEN ((size_t)-1) | |
42 | ||
e90c1d2a | 43 | // ---------------------------------------------------------------------------- |
bde4baac | 44 | // wxMBConv (abstract base class for conversions) |
e90c1d2a | 45 | // ---------------------------------------------------------------------------- |
6001e347 | 46 | |
509da451 VZ |
47 | // When deriving a new class from wxMBConv you must reimplement ToWChar() and |
48 | // FromWChar() methods which are not pure virtual only for historical reasons, | |
49 | // don't let the fact that the existing classes implement MB2WC/WC2MB() instead | |
50 | // confuse you. | |
51 | // | |
d36c9347 VZ |
52 | // You also have to implement Clone() to allow copying the conversions |
53 | // polymorphically. | |
54 | // | |
509da451 | 55 | // And you might need to override GetMBNulLen() as well. |
bddd7a8d | 56 | class WXDLLIMPEXP_BASE wxMBConv |
6001e347 RR |
57 | { |
58 | public: | |
483b0434 VZ |
59 | // The functions doing actual conversion from/to narrow to/from wide |
60 | // character strings. | |
bde4baac | 61 | // |
483b0434 VZ |
62 | // On success, the return value is the length (i.e. the number of |
63 | // characters, not bytes) of the converted string including any trailing | |
64 | // L'\0' or (possibly multiple) '\0'(s). If the conversion fails or if | |
65 | // there is not enough space for everything, including the trailing NUL | |
467e0479 | 66 | // character(s), in the output buffer, wxCONV_FAILED is returned. |
483b0434 VZ |
67 | // |
68 | // In the special case when dstLen is 0 (outputBuf may be NULL then) the | |
69 | // return value is the length of the needed buffer but nothing happens | |
467e0479 VZ |
70 | // otherwise. If srcLen is wxNO_LEN, the entire string, up to and |
71 | // including the trailing NUL(s), is converted, otherwise exactly srcLen | |
72 | // bytes are. | |
483b0434 VZ |
73 | // |
74 | // Typical usage: | |
75 | // | |
76 | // size_t dstLen = conv.ToWChar(NULL, 0, src); | |
77 | // if ( dstLen != wxCONV_FAILED ) | |
78 | // ... handle error ... | |
79 | // wchar_t *wbuf = new wchar_t[dstLen]; | |
80 | // conv.ToWChar(wbuf, dstLen, src); | |
81 | // | |
82 | virtual size_t ToWChar(wchar_t *dst, size_t dstLen, | |
467e0479 | 83 | const char *src, size_t srcLen = wxNO_LEN) const; |
483b0434 VZ |
84 | |
85 | virtual size_t FromWChar(char *dst, size_t dstLen, | |
467e0479 | 86 | const wchar_t *src, size_t srcLen = wxNO_LEN) const; |
483b0434 | 87 | |
e90c1d2a | 88 | |
483b0434 VZ |
89 | // Convenience functions for translating NUL-terminated strings: returns |
90 | // the buffer containing the converted string or NULL pointer if the | |
91 | // conversion failed. | |
eec47cc6 VZ |
92 | const wxWCharBuffer cMB2WC(const char *in) const; |
93 | const wxCharBuffer cWC2MB(const wchar_t *in) const; | |
6001e347 | 94 | |
483b0434 VZ |
95 | // Convenience functions for converting strings which may contain embedded |
96 | // NULs and don't have to be NUL-terminated. | |
f5fb6871 | 97 | // |
f6a02087 VZ |
98 | // inLen is the length of the buffer including trailing NUL if any or |
99 | // wxNO_LEN if the input is NUL-terminated. | |
eec47cc6 VZ |
100 | // |
101 | // outLen receives, if not NULL, the length of the converted string or 0 if | |
102 | // the conversion failed (returning 0 and not -1 in this case makes it | |
103 | // difficult to distinguish between failed conversion and empty input but | |
f6a02087 VZ |
104 | // this is done for backwards compatibility). Notice that the rules for |
105 | // whether outLen accounts or not for the last NUL are the same as for | |
106 | // To/FromWChar() above: if inLen is specified, outLen is exactly the | |
107 | // number of characters converted, whether the last one of them was NUL or | |
108 | // not. But if inLen == wxNO_LEN then outLen doesn't account for the last | |
109 | // NUL even though it is present. | |
eec47cc6 VZ |
110 | const wxWCharBuffer |
111 | cMB2WC(const char *in, size_t inLen, size_t *outLen) const; | |
112 | const wxCharBuffer | |
113 | cWC2MB(const wchar_t *in, size_t inLen, size_t *outLen) const; | |
f5fb6871 | 114 | |
bde4baac | 115 | // convenience functions for converting MB or WC to/from wxWin default |
6001e347 | 116 | #if wxUSE_UNICODE |
e90c1d2a VZ |
117 | const wxWCharBuffer cMB2WX(const char *psz) const { return cMB2WC(psz); } |
118 | const wxCharBuffer cWX2MB(const wchar_t *psz) const { return cWC2MB(psz); } | |
119 | const wchar_t* cWC2WX(const wchar_t *psz) const { return psz; } | |
f6bcfd97 | 120 | const wchar_t* cWX2WC(const wchar_t *psz) const { return psz; } |
e90c1d2a VZ |
121 | #else // ANSI |
122 | const char* cMB2WX(const char *psz) const { return psz; } | |
123 | const char* cWX2MB(const char *psz) const { return psz; } | |
124 | const wxCharBuffer cWC2WX(const wchar_t *psz) const { return cWC2MB(psz); } | |
125 | const wxWCharBuffer cWX2WC(const char *psz) const { return cMB2WC(psz); } | |
126 | #endif // Unicode/ANSI | |
2b5f62a0 | 127 | |
c1464d9d VZ |
128 | // this function is used in the implementation of cMB2WC() to distinguish |
129 | // between the following cases: | |
eec47cc6 | 130 | // |
c1464d9d VZ |
131 | // a) var width encoding with strings terminated by a single NUL |
132 | // (usual multibyte encodings): return 1 in this case | |
133 | // b) fixed width encoding with 2 bytes/char and so terminated by | |
134 | // 2 NULs (UTF-16/UCS-2 and variants): return 2 in this case | |
135 | // c) fixed width encoding with 4 bytes/char and so terminated by | |
136 | // 4 NULs (UTF-32/UCS-4 and variants): return 4 in this case | |
137 | // | |
138 | // anything else is not supported currently and -1 should be returned | |
7ef3ab50 VZ |
139 | virtual size_t GetMBNulLen() const { return 1; } |
140 | ||
483b0434 VZ |
141 | // return the maximal value currently returned by GetMBNulLen() for any |
142 | // encoding | |
143 | static size_t GetMaxMBNulLen() { return 4 /* for UTF-32 */; } | |
144 | ||
111d9948 VS |
145 | #if wxUSE_UNICODE_UTF8 |
146 | // return true if the converter's charset is UTF-8, i.e. char* strings | |
147 | // decoded using this object can be directly copied to wxString's internal | |
148 | // storage without converting to WC and than back to UTF-8 MB string | |
149 | virtual bool IsUTF8() const { return false; } | |
150 | #endif | |
483b0434 VZ |
151 | |
152 | // The old conversion functions. The existing classes currently mostly | |
153 | // implement these ones but we're in transition to using To/FromWChar() | |
154 | // instead and any new classes should implement just the new functions. | |
155 | // For now, however, we provide default implementation of To/FromWChar() in | |
156 | // this base class in terms of MB2WC/WC2MB() to avoid having to rewrite all | |
157 | // the conversions at once. | |
158 | // | |
159 | // On success, the return value is the length (i.e. the number of | |
160 | // characters, not bytes) not counting the trailing NUL(s) of the converted | |
161 | // string. On failure, (size_t)-1 is returned. In the special case when | |
162 | // outputBuf is NULL the return value is the same one but nothing is | |
163 | // written to the buffer. | |
164 | // | |
165 | // Note that outLen is the length of the output buffer, not the length of | |
166 | // the input (which is always supposed to be terminated by one or more | |
167 | // NULs, as appropriate for the encoding)! | |
509da451 VZ |
168 | virtual size_t MB2WC(wchar_t *out, const char *in, size_t outLen) const; |
169 | virtual size_t WC2MB(char *out, const wchar_t *in, size_t outLen) const; | |
483b0434 VZ |
170 | |
171 | ||
d36c9347 VZ |
172 | // make a heap-allocated copy of this object |
173 | virtual wxMBConv *Clone() const = 0; | |
174 | ||
7ef3ab50 VZ |
175 | // virtual dtor for any base class |
176 | virtual ~wxMBConv(); | |
6001e347 RR |
177 | }; |
178 | ||
bde4baac VZ |
179 | // ---------------------------------------------------------------------------- |
180 | // wxMBConvLibc uses standard mbstowcs() and wcstombs() functions for | |
181 | // conversion (hence it depends on the current locale) | |
182 | // ---------------------------------------------------------------------------- | |
183 | ||
184 | class WXDLLIMPEXP_BASE wxMBConvLibc : public wxMBConv | |
185 | { | |
186 | public: | |
75736a9c DS |
187 | virtual size_t MB2WC(wchar_t *outputBuf, const char *psz, size_t outputSize) const; |
188 | virtual size_t WC2MB(char *outputBuf, const wchar_t *psz, size_t outputSize) const; | |
d36c9347 VZ |
189 | |
190 | virtual wxMBConv *Clone() const { return new wxMBConvLibc; } | |
111d9948 VS |
191 | |
192 | #if wxUSE_UNICODE_UTF8 | |
193 | virtual bool IsUTF8() const { return wxLocaleIsUtf8; } | |
194 | #endif | |
bde4baac VZ |
195 | }; |
196 | ||
5576edf8 RR |
197 | #ifdef __UNIX__ |
198 | ||
199 | // ---------------------------------------------------------------------------- | |
200 | // wxConvBrokenFileNames is made for Unix in Unicode mode when | |
201 | // files are accidentally written in an encoding which is not | |
202 | // the system encoding. Typically, the system encoding will be | |
203 | // UTF8 but there might be files stored in ISO8859-1 on disk. | |
204 | // ---------------------------------------------------------------------------- | |
205 | ||
206 | class WXDLLIMPEXP_BASE wxConvBrokenFileNames : public wxMBConv | |
207 | { | |
208 | public: | |
86501081 | 209 | wxConvBrokenFileNames(const wxString& charset); |
d36c9347 | 210 | wxConvBrokenFileNames(const wxConvBrokenFileNames& conv) |
2e2cf78d VZ |
211 | : wxMBConv(), |
212 | m_conv(conv.m_conv ? conv.m_conv->Clone() : NULL) | |
d36c9347 VZ |
213 | { |
214 | } | |
5576edf8 RR |
215 | virtual ~wxConvBrokenFileNames() { delete m_conv; } |
216 | ||
eec47cc6 VZ |
217 | virtual size_t MB2WC(wchar_t *out, const char *in, size_t outLen) const |
218 | { | |
219 | return m_conv->MB2WC(out, in, outLen); | |
220 | } | |
221 | ||
222 | virtual size_t WC2MB(char *out, const wchar_t *in, size_t outLen) const | |
223 | { | |
224 | return m_conv->WC2MB(out, in, outLen); | |
225 | } | |
5576edf8 | 226 | |
7ef3ab50 | 227 | virtual size_t GetMBNulLen() const |
eec47cc6 | 228 | { |
22886fb3 | 229 | // cast needed to call a private function |
7ef3ab50 | 230 | return m_conv->GetMBNulLen(); |
eec47cc6 VZ |
231 | } |
232 | ||
ba98e032 VS |
233 | #if wxUSE_UNICODE_UTF8 |
234 | virtual bool IsUTF8() const { return m_conv->IsUTF8(); } | |
235 | #endif | |
236 | ||
d36c9347 VZ |
237 | virtual wxMBConv *Clone() const { return new wxConvBrokenFileNames(*this); } |
238 | ||
7ef3ab50 | 239 | private: |
5576edf8 RR |
240 | // the conversion object we forward to |
241 | wxMBConv *m_conv; | |
d36c9347 VZ |
242 | |
243 | DECLARE_NO_ASSIGN_CLASS(wxConvBrokenFileNames) | |
5576edf8 RR |
244 | }; |
245 | ||
eec47cc6 | 246 | #endif // __UNIX__ |
5576edf8 | 247 | |
e90c1d2a | 248 | // ---------------------------------------------------------------------------- |
6001e347 | 249 | // wxMBConvUTF7 (for conversion using UTF7 encoding) |
e90c1d2a | 250 | // ---------------------------------------------------------------------------- |
6001e347 | 251 | |
bddd7a8d | 252 | class WXDLLIMPEXP_BASE wxMBConvUTF7 : public wxMBConv |
6001e347 RR |
253 | { |
254 | public: | |
9d653e81 VZ |
255 | wxMBConvUTF7() { } |
256 | ||
257 | // compiler-generated copy ctor, assignment operator and dtor are ok | |
258 | // (assuming it's ok to copy the shift state -- not really sure about it) | |
259 | ||
260 | virtual size_t ToWChar(wchar_t *dst, size_t dstLen, | |
261 | const char *src, size_t srcLen = wxNO_LEN) const; | |
262 | virtual size_t FromWChar(char *dst, size_t dstLen, | |
263 | const wchar_t *src, size_t srcLen = wxNO_LEN) const; | |
d36c9347 VZ |
264 | |
265 | virtual wxMBConv *Clone() const { return new wxMBConvUTF7; } | |
9d653e81 VZ |
266 | |
267 | private: | |
268 | // UTF-7 decoder/encoder may be in direct mode or in shifted mode after a | |
269 | // '+' (and until the '-' or any other non-base64 character) | |
1bc82105 | 270 | struct StateMode |
9d653e81 | 271 | { |
1bc82105 VZ |
272 | enum Mode |
273 | { | |
274 | Direct, // pass through state | |
275 | Shifted // after a '+' (and before '-') | |
276 | }; | |
9d653e81 VZ |
277 | }; |
278 | ||
279 | // the current decoder state: this is only used by ToWChar() if srcLen | |
280 | // parameter is not wxNO_LEN, when working on the entire NUL-terminated | |
281 | // strings we neither update nor use the state | |
1bc82105 | 282 | class DecoderState : StateMode |
9d653e81 VZ |
283 | { |
284 | private: | |
285 | // current state: this one is private as we want to enforce the use of | |
286 | // ToDirect/ToShifted() methods below | |
287 | Mode mode; | |
288 | ||
289 | public: | |
290 | // the initial state is direct | |
291 | DecoderState() { mode = Direct; } | |
292 | ||
293 | // switch to/from shifted mode | |
294 | void ToDirect() { mode = Direct; } | |
295 | void ToShifted() { mode = Shifted; accum = bit = 0; isLSB = false; } | |
296 | ||
297 | bool IsDirect() const { return mode == Direct; } | |
298 | bool IsShifted() const { return mode == Shifted; } | |
299 | ||
300 | ||
301 | // these variables are only used in shifted mode | |
302 | ||
303 | unsigned int accum; // accumulator of the bit we've already got | |
304 | unsigned int bit; // the number of bits consumed mod 8 | |
305 | unsigned char msb; // the high byte of UTF-16 word | |
306 | bool isLSB; // whether we're decoding LSB or MSB of UTF-16 word | |
307 | }; | |
308 | ||
309 | DecoderState m_stateDecoder; | |
310 | ||
311 | ||
312 | // encoder state is simpler as we always receive entire Unicode characters | |
313 | // on input | |
1bc82105 | 314 | class EncoderState : StateMode |
9d653e81 VZ |
315 | { |
316 | private: | |
317 | Mode mode; | |
318 | ||
319 | public: | |
320 | EncoderState() { mode = Direct; } | |
321 | ||
322 | void ToDirect() { mode = Direct; } | |
323 | void ToShifted() { mode = Shifted; accum = bit = 0; } | |
324 | ||
325 | bool IsDirect() const { return mode == Direct; } | |
326 | bool IsShifted() const { return mode == Shifted; } | |
327 | ||
328 | unsigned int accum; | |
329 | unsigned int bit; | |
330 | }; | |
331 | ||
332 | EncoderState m_stateEncoder; | |
6001e347 RR |
333 | }; |
334 | ||
e90c1d2a | 335 | // ---------------------------------------------------------------------------- |
6001e347 | 336 | // wxMBConvUTF8 (for conversion using UTF8 encoding) |
e90c1d2a | 337 | // ---------------------------------------------------------------------------- |
6001e347 | 338 | |
0286d08d VZ |
339 | // this is the real UTF-8 conversion class, it has to be called "strict UTF-8" |
340 | // for compatibility reasons: the wxMBConvUTF8 class below also supports lossy | |
341 | // conversions if it is created with non default options | |
342 | class WXDLLIMPEXP_BASE wxMBConvStrictUTF8 : public wxMBConv | |
343 | { | |
344 | public: | |
345 | // compiler-generated default ctor and other methods are ok | |
346 | ||
347 | virtual size_t ToWChar(wchar_t *dst, size_t dstLen, | |
348 | const char *src, size_t srcLen = wxNO_LEN) const; | |
349 | virtual size_t FromWChar(char *dst, size_t dstLen, | |
350 | const wchar_t *src, size_t srcLen = wxNO_LEN) const; | |
351 | ||
352 | virtual wxMBConv *Clone() const { return new wxMBConvStrictUTF8(); } | |
353 | ||
354 | #if wxUSE_UNICODE_UTF8 | |
355 | // NB: other mapping modes are not, strictly speaking, UTF-8, so we can't | |
356 | // take the shortcut in that case | |
357 | virtual bool IsUTF8() const { return true; } | |
358 | #endif | |
359 | }; | |
360 | ||
361 | class WXDLLIMPEXP_BASE wxMBConvUTF8 : public wxMBConvStrictUTF8 | |
6001e347 RR |
362 | { |
363 | public: | |
d36c9347 VZ |
364 | enum |
365 | { | |
ea8ce907 RR |
366 | MAP_INVALID_UTF8_NOT = 0, |
367 | MAP_INVALID_UTF8_TO_PUA = 1, | |
368 | MAP_INVALID_UTF8_TO_OCTAL = 2 | |
369 | }; | |
370 | ||
371 | wxMBConvUTF8(int options = MAP_INVALID_UTF8_NOT) : m_options(options) { } | |
d16d0917 VZ |
372 | |
373 | virtual size_t ToWChar(wchar_t *dst, size_t dstLen, | |
374 | const char *src, size_t srcLen = wxNO_LEN) const; | |
375 | virtual size_t FromWChar(char *dst, size_t dstLen, | |
376 | const wchar_t *src, size_t srcLen = wxNO_LEN) const; | |
eec47cc6 | 377 | |
d36c9347 VZ |
378 | virtual wxMBConv *Clone() const { return new wxMBConvUTF8(m_options); } |
379 | ||
111d9948 VS |
380 | #if wxUSE_UNICODE_UTF8 |
381 | // NB: other mapping modes are not, strictly speaking, UTF-8, so we can't | |
382 | // take the shortcut in that case | |
383 | virtual bool IsUTF8() const { return m_options == MAP_INVALID_UTF8_NOT; } | |
384 | #endif | |
385 | ||
ea8ce907 RR |
386 | private: |
387 | int m_options; | |
6001e347 RR |
388 | }; |
389 | ||
eec47cc6 VZ |
390 | // ---------------------------------------------------------------------------- |
391 | // wxMBConvUTF16Base: for both LE and BE variants | |
392 | // ---------------------------------------------------------------------------- | |
393 | ||
394 | class WXDLLIMPEXP_BASE wxMBConvUTF16Base : public wxMBConv | |
395 | { | |
7ef3ab50 | 396 | public: |
467e0479 VZ |
397 | enum { BYTES_PER_CHAR = 2 }; |
398 | ||
399 | virtual size_t GetMBNulLen() const { return BYTES_PER_CHAR; } | |
400 | ||
401 | protected: | |
402 | // return the length of the buffer using srcLen if it's not wxNO_LEN and | |
403 | // computing the length ourselves if it is; also checks that the length is | |
404 | // even if specified as we need an entire number of UTF-16 characters and | |
405 | // returns wxNO_LEN which indicates error if it is odd | |
406 | static size_t GetLength(const char *src, size_t srcLen); | |
eec47cc6 VZ |
407 | }; |
408 | ||
e90c1d2a | 409 | // ---------------------------------------------------------------------------- |
c91830cb VZ |
410 | // wxMBConvUTF16LE (for conversion using UTF16 Little Endian encoding) |
411 | // ---------------------------------------------------------------------------- | |
412 | ||
eec47cc6 | 413 | class WXDLLIMPEXP_BASE wxMBConvUTF16LE : public wxMBConvUTF16Base |
c91830cb VZ |
414 | { |
415 | public: | |
467e0479 VZ |
416 | virtual size_t ToWChar(wchar_t *dst, size_t dstLen, |
417 | const char *src, size_t srcLen = wxNO_LEN) const; | |
418 | virtual size_t FromWChar(char *dst, size_t dstLen, | |
419 | const wchar_t *src, size_t srcLen = wxNO_LEN) const; | |
d36c9347 | 420 | virtual wxMBConv *Clone() const { return new wxMBConvUTF16LE; } |
c91830cb VZ |
421 | }; |
422 | ||
423 | // ---------------------------------------------------------------------------- | |
424 | // wxMBConvUTF16BE (for conversion using UTF16 Big Endian encoding) | |
425 | // ---------------------------------------------------------------------------- | |
426 | ||
eec47cc6 | 427 | class WXDLLIMPEXP_BASE wxMBConvUTF16BE : public wxMBConvUTF16Base |
c91830cb VZ |
428 | { |
429 | public: | |
467e0479 VZ |
430 | virtual size_t ToWChar(wchar_t *dst, size_t dstLen, |
431 | const char *src, size_t srcLen = wxNO_LEN) const; | |
432 | virtual size_t FromWChar(char *dst, size_t dstLen, | |
433 | const wchar_t *src, size_t srcLen = wxNO_LEN) const; | |
d36c9347 | 434 | virtual wxMBConv *Clone() const { return new wxMBConvUTF16BE; } |
c91830cb VZ |
435 | }; |
436 | ||
eec47cc6 VZ |
437 | // ---------------------------------------------------------------------------- |
438 | // wxMBConvUTF32Base: base class for both LE and BE variants | |
439 | // ---------------------------------------------------------------------------- | |
440 | ||
441 | class WXDLLIMPEXP_BASE wxMBConvUTF32Base : public wxMBConv | |
442 | { | |
7ef3ab50 | 443 | public: |
467e0479 VZ |
444 | enum { BYTES_PER_CHAR = 4 }; |
445 | ||
446 | virtual size_t GetMBNulLen() const { return BYTES_PER_CHAR; } | |
447 | ||
448 | protected: | |
449 | // this is similar to wxMBConvUTF16Base method with the same name except | |
450 | // that, of course, it verifies that length is divisible by 4 if given and | |
451 | // not by 2 | |
452 | static size_t GetLength(const char *src, size_t srcLen); | |
eec47cc6 VZ |
453 | }; |
454 | ||
c91830cb | 455 | // ---------------------------------------------------------------------------- |
8b9e1f43 | 456 | // wxMBConvUTF32LE (for conversion using UTF32 Little Endian encoding) |
c91830cb VZ |
457 | // ---------------------------------------------------------------------------- |
458 | ||
eec47cc6 | 459 | class WXDLLIMPEXP_BASE wxMBConvUTF32LE : public wxMBConvUTF32Base |
c91830cb VZ |
460 | { |
461 | public: | |
467e0479 VZ |
462 | virtual size_t ToWChar(wchar_t *dst, size_t dstLen, |
463 | const char *src, size_t srcLen = wxNO_LEN) const; | |
464 | virtual size_t FromWChar(char *dst, size_t dstLen, | |
465 | const wchar_t *src, size_t srcLen = wxNO_LEN) const; | |
d36c9347 | 466 | virtual wxMBConv *Clone() const { return new wxMBConvUTF32LE; } |
c91830cb VZ |
467 | }; |
468 | ||
469 | // ---------------------------------------------------------------------------- | |
8b9e1f43 | 470 | // wxMBConvUTF32BE (for conversion using UTF32 Big Endian encoding) |
c91830cb VZ |
471 | // ---------------------------------------------------------------------------- |
472 | ||
eec47cc6 | 473 | class WXDLLIMPEXP_BASE wxMBConvUTF32BE : public wxMBConvUTF32Base |
c91830cb VZ |
474 | { |
475 | public: | |
467e0479 VZ |
476 | virtual size_t ToWChar(wchar_t *dst, size_t dstLen, |
477 | const char *src, size_t srcLen = wxNO_LEN) const; | |
478 | virtual size_t FromWChar(char *dst, size_t dstLen, | |
479 | const wchar_t *src, size_t srcLen = wxNO_LEN) const; | |
d36c9347 | 480 | virtual wxMBConv *Clone() const { return new wxMBConvUTF32BE; } |
c91830cb VZ |
481 | }; |
482 | ||
483 | // ---------------------------------------------------------------------------- | |
e90c1d2a VZ |
484 | // wxCSConv (for conversion based on loadable char sets) |
485 | // ---------------------------------------------------------------------------- | |
6001e347 | 486 | |
8b04d4c4 VZ |
487 | #include "wx/fontenc.h" |
488 | ||
bddd7a8d | 489 | class WXDLLIMPEXP_BASE wxCSConv : public wxMBConv |
6001e347 | 490 | { |
6001e347 | 491 | public: |
e95354ec VZ |
492 | // we can be created either from charset name or from an encoding constant |
493 | // but we can't have both at once | |
86501081 | 494 | wxCSConv(const wxString& charset); |
8b04d4c4 | 495 | wxCSConv(wxFontEncoding encoding); |
e95354ec | 496 | |
54380f29 | 497 | wxCSConv(const wxCSConv& conv); |
e90c1d2a VZ |
498 | virtual ~wxCSConv(); |
499 | ||
54380f29 | 500 | wxCSConv& operator=(const wxCSConv& conv); |
2b5f62a0 | 501 | |
1c714a5d VZ |
502 | virtual size_t ToWChar(wchar_t *dst, size_t dstLen, |
503 | const char *src, size_t srcLen = wxNO_LEN) const; | |
504 | virtual size_t FromWChar(char *dst, size_t dstLen, | |
505 | const wchar_t *src, size_t srcLen = wxNO_LEN) const; | |
7ef3ab50 | 506 | virtual size_t GetMBNulLen() const; |
1c714a5d | 507 | |
ba98e032 VS |
508 | #if wxUSE_UNICODE_UTF8 |
509 | virtual bool IsUTF8() const; | |
510 | #endif | |
511 | ||
d36c9347 | 512 | virtual wxMBConv *Clone() const { return new wxCSConv(*this); } |
e90c1d2a | 513 | |
d36c9347 | 514 | void Clear(); |
65e50848 | 515 | |
a08a37d0 | 516 | // return true if the conversion could be initialized successfully |
0f0298b1 | 517 | bool IsOk() const; |
0f0298b1 | 518 | |
e90c1d2a | 519 | private: |
8b04d4c4 VZ |
520 | // common part of all ctors |
521 | void Init(); | |
522 | ||
e95354ec VZ |
523 | // creates m_convReal if necessary |
524 | void CreateConvIfNeeded() const; | |
525 | ||
526 | // do create m_convReal (unconditionally) | |
527 | wxMBConv *DoCreate() const; | |
528 | ||
bda3d86a | 529 | // set the name (may be only called when m_name == NULL), makes copy of |
a08a37d0 | 530 | // the charset string |
86501081 | 531 | void SetName(const char *charset); |
e90c1d2a | 532 | |
e95354ec | 533 | |
a08a37d0 VZ |
534 | // m_name may be NULL in which case m_encoding should be used |
535 | // | |
dccce9ea VZ |
536 | // note that we can't use wxString here because of compilation |
537 | // dependencies: we're included from wx/string.h | |
86501081 | 538 | char *m_name; |
a08a37d0 VZ |
539 | |
540 | // may be wxFONTENCODING_SYSTEM in which case m_name is used | |
541 | // | |
542 | // if m_name is NULL, then we should use the default system encoding | |
8b04d4c4 | 543 | wxFontEncoding m_encoding; |
e95354ec VZ |
544 | |
545 | // use CreateConvIfNeeded() before accessing m_convReal! | |
546 | wxMBConv *m_convReal; | |
e90c1d2a | 547 | bool m_deferred; |
6001e347 RR |
548 | }; |
549 | ||
c3c1a9a9 | 550 | |
f5a1953b VZ |
551 | // ---------------------------------------------------------------------------- |
552 | // declare predefined conversion objects | |
553 | // ---------------------------------------------------------------------------- | |
d5c8817c | 554 | |
1e50d914 VS |
555 | // Note: this macro is an implementation detail (see the comment in |
556 | // strconv.cpp). The wxGet_XXX() and wxGet_XXXPtr() functions shouldn't be | |
557 | // used by user code and neither should XXXPtr, use the wxConvXXX macro | |
558 | // instead. | |
559 | #define WX_DECLARE_GLOBAL_CONV(klass, name) \ | |
560 | extern WXDLLIMPEXP_DATA_BASE(klass*) name##Ptr; \ | |
092ee46f | 561 | extern WXDLLIMPEXP_BASE klass* wxGet_##name##Ptr(); \ |
1e50d914 VS |
562 | inline klass& wxGet_##name() \ |
563 | { \ | |
564 | if ( !name##Ptr ) \ | |
565 | name##Ptr = wxGet_##name##Ptr(); \ | |
566 | return *name##Ptr; \ | |
567 | } | |
568 | ||
569 | ||
f5a1953b VZ |
570 | // conversion to be used with all standard functions affected by locale, e.g. |
571 | // strtol(), strftime(), ... | |
1e50d914 VS |
572 | WX_DECLARE_GLOBAL_CONV(wxMBConv, wxConvLibc) |
573 | #define wxConvLibc wxGet_wxConvLibc() | |
f5a1953b VZ |
574 | |
575 | // conversion ISO-8859-1/UTF-7/UTF-8 <-> wchar_t | |
1e50d914 VS |
576 | WX_DECLARE_GLOBAL_CONV(wxCSConv, wxConvISO8859_1) |
577 | #define wxConvISO8859_1 wxGet_wxConvISO8859_1() | |
578 | ||
0286d08d | 579 | WX_DECLARE_GLOBAL_CONV(wxMBConvStrictUTF8, wxConvUTF8) |
1e50d914 VS |
580 | #define wxConvUTF8 wxGet_wxConvUTF8() |
581 | ||
582 | WX_DECLARE_GLOBAL_CONV(wxMBConvUTF7, wxConvUTF7) | |
583 | #define wxConvUTF7 wxGet_wxConvUTF7() | |
f5a1953b VZ |
584 | |
585 | // conversion used for the file names on the systems where they're not Unicode | |
586 | // (basically anything except Windows) | |
587 | // | |
588 | // this is used by all file functions, can be changed by the application | |
589 | // | |
590 | // by default UTF-8 under Mac OS X and wxConvLibc elsewhere (but it's not used | |
591 | // under Windows normally) | |
592 | extern WXDLLIMPEXP_DATA_BASE(wxMBConv *) wxConvFileName; | |
593 | ||
594 | // backwards compatible define | |
595 | #define wxConvFile (*wxConvFileName) | |
596 | ||
597 | // the current conversion object, may be set to any conversion, is used by | |
598 | // default in a couple of places inside wx (initially same as wxConvLibc) | |
16cba29d | 599 | extern WXDLLIMPEXP_DATA_BASE(wxMBConv *) wxConvCurrent; |
6001e347 | 600 | |
0e052272 | 601 | // the conversion corresponding to the current locale |
1e50d914 VS |
602 | WX_DECLARE_GLOBAL_CONV(wxCSConv, wxConvLocal) |
603 | #define wxConvLocal wxGet_wxConvLocal() | |
f5a1953b | 604 | |
d5bef0a3 VZ |
605 | // the conversion corresponding to the encoding of the standard UI elements |
606 | // | |
607 | // by default this is the same as wxConvLocal but may be changed if the program | |
608 | // needs to use a fixed encoding | |
609 | extern WXDLLIMPEXP_DATA_BASE(wxMBConv *) wxConvUI; | |
610 | ||
1e50d914 VS |
611 | #undef WX_DECLARE_GLOBAL_CONV |
612 | ||
e95354ec VZ |
613 | // ---------------------------------------------------------------------------- |
614 | // endianness-dependent conversions | |
615 | // ---------------------------------------------------------------------------- | |
616 | ||
617 | #ifdef WORDS_BIGENDIAN | |
618 | typedef wxMBConvUTF16BE wxMBConvUTF16; | |
619 | typedef wxMBConvUTF32BE wxMBConvUTF32; | |
620 | #else | |
621 | typedef wxMBConvUTF16LE wxMBConvUTF16; | |
622 | typedef wxMBConvUTF32LE wxMBConvUTF32; | |
623 | #endif | |
624 | ||
e90c1d2a | 625 | // ---------------------------------------------------------------------------- |
6001e347 | 626 | // filename conversion macros |
e90c1d2a | 627 | // ---------------------------------------------------------------------------- |
6001e347 | 628 | |
bc4b4779 | 629 | // filenames are multibyte on Unix and widechar on Windows |
80df4d31 | 630 | #if wxMBFILES && wxUSE_UNICODE |
f5a1953b | 631 | #define wxFNCONV(name) wxConvFileName->cWX2MB(name) |
e90c1d2a | 632 | #define wxFNSTRINGCAST wxMBSTRINGCAST |
d5c8817c SC |
633 | #else |
634 | #if defined( __WXOSX__ ) && wxMBFILES | |
f5a1953b | 635 | #define wxFNCONV(name) wxConvFileName->cWC2MB( wxConvLocal.cWX2WC(name) ) |
6001e347 | 636 | #else |
e90c1d2a | 637 | #define wxFNCONV(name) name |
d5c8817c | 638 | #endif |
e90c1d2a | 639 | #define wxFNSTRINGCAST WXSTRINGCAST |
6001e347 RR |
640 | #endif |
641 | ||
f5a1953b | 642 | #else // !wxUSE_WCHAR_T |
6001e347 | 643 | |
e90c1d2a | 644 | // ---------------------------------------------------------------------------- |
6001e347 | 645 | // stand-ins in absence of wchar_t |
e90c1d2a | 646 | // ---------------------------------------------------------------------------- |
6001e347 | 647 | |
bddd7a8d | 648 | class WXDLLIMPEXP_BASE wxMBConv |
6001e347 RR |
649 | { |
650 | public: | |
e90c1d2a VZ |
651 | const char* cMB2WX(const char *psz) const { return psz; } |
652 | const char* cWX2MB(const char *psz) const { return psz; } | |
6001e347 | 653 | }; |
e90c1d2a | 654 | |
bde4baac VZ |
655 | #define wxConvFile wxConvLocal |
656 | ||
16cba29d | 657 | extern WXDLLIMPEXP_DATA_BASE(wxMBConv) wxConvLibc, |
8b04d4c4 VZ |
658 | wxConvLocal, |
659 | wxConvISO8859_1, | |
660 | wxConvUTF8; | |
16cba29d | 661 | extern WXDLLIMPEXP_DATA_BASE(wxMBConv *) wxConvCurrent; |
6001e347 RR |
662 | |
663 | #define wxFNCONV(name) name | |
e90c1d2a | 664 | #define wxFNSTRINGCAST WXSTRINGCAST |
6001e347 RR |
665 | |
666 | #endif | |
667 | // wxUSE_WCHAR_T | |
668 | ||
e90c1d2a VZ |
669 | // ---------------------------------------------------------------------------- |
670 | // macros for the most common conversions | |
671 | // ---------------------------------------------------------------------------- | |
672 | ||
673 | #if wxUSE_UNICODE | |
674 | #define wxConvertWX2MB(s) wxConvCurrent->cWX2MB(s) | |
675 | #define wxConvertMB2WX(s) wxConvCurrent->cMB2WX(s) | |
69c928ef VZ |
676 | |
677 | // these functions should be used when the conversions really, really have | |
678 | // to succeed (usually because we pass their results to a standard C | |
679 | // function which would crash if we passed NULL to it), so these functions | |
680 | // always return a valid pointer if their argument is non-NULL | |
681 | ||
682 | // this function safety is achieved by trying wxConvLibc first, wxConvUTF8 | |
683 | // next if it fails and, finally, wxConvISO8859_1 which always succeeds | |
684 | extern WXDLLIMPEXP_BASE wxWCharBuffer wxSafeConvertMB2WX(const char *s); | |
685 | ||
686 | // this function uses wxConvLibc and wxConvUTF8(MAP_INVALID_UTF8_TO_OCTAL) | |
687 | // if it fails | |
688 | extern WXDLLIMPEXP_BASE wxCharBuffer wxSafeConvertWX2MB(const wchar_t *ws); | |
e90c1d2a VZ |
689 | #else // ANSI |
690 | // no conversions to do | |
691 | #define wxConvertWX2MB(s) (s) | |
692 | #define wxConvertMB2WX(s) (s) | |
69c928ef VZ |
693 | #define wxSafeConvertMB2WX(s) (s) |
694 | #define wxSafeConvertWX2MB(s) (s) | |
e90c1d2a VZ |
695 | #endif // Unicode/ANSI |
696 | ||
d36c9347 | 697 | #endif // _WX_STRCONV_H_ |
6001e347 | 698 |