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