1 ///////////////////////////////////////////////////////////////////////////////
3 // Purpose: Type-safe ANSI and Unicode builds compatible wrappers for
5 // Author: Joel Farley, Ove Kåven
6 // Modified by: Vadim Zeitlin, Robert Roebling, Ron Lee, Vaclav Slavik
9 // Copyright: (c) 1998-2006 wxWidgets dev team
10 // Licence: wxWindows licence
11 ///////////////////////////////////////////////////////////////////////////////
16 // NB: User code should include wx/crt.h instead of including this
19 #include "wx/wxcrtbase.h"
20 #include "wx/string.h"
22 // ============================================================================
24 // ============================================================================
26 /* checks whether the passed in pointer is NULL and if the string is empty */
27 inline bool wxIsEmpty(const char *s
) { return !s
|| !*s
; }
28 inline bool wxIsEmpty(const wchar_t *s
) { return !s
|| !*s
; }
29 inline bool wxIsEmpty(const wxCharBuffer
& s
) { return wxIsEmpty(s
.data()); }
30 inline bool wxIsEmpty(const wxWCharBuffer
& s
) { return wxIsEmpty(s
.data()); }
31 inline bool wxIsEmpty(const wxString
& s
) { return s
.empty(); }
32 inline bool wxIsEmpty(const wxCStrData
& s
) { return s
.AsString().empty(); }
35 // FIXME-UTF8: get rid of this, it's ANSI only anyway
36 WXDLLIMPEXP_BASE
bool wxOKlibc(); /* for internal use */
39 /* multibyte to wide char conversion functions and macros */
42 /* multibyte<->widechar conversion */
43 WXDLLIMPEXP_BASE
size_t wxMB2WC(wchar_t *buf
, const char *psz
, size_t n
);
44 WXDLLIMPEXP_BASE
size_t wxWC2MB(char *buf
, const wchar_t *psz
, size_t n
);
47 #define wxMB2WX wxMB2WC
48 #define wxWX2MB wxWC2MB
49 #define wxWC2WX wxStrncpy
50 #define wxWX2WC wxStrncpy
52 #define wxMB2WX wxStrncpy
53 #define wxWX2MB wxStrncpy
54 #define wxWC2WX wxWC2MB
55 #define wxWX2WC wxMB2WC
57 #else /* !wxUSE_UNICODE */
58 /* No wxUSE_WCHAR_T: we have to do something (JACS) */
59 #define wxMB2WC wxStrncpy
60 #define wxWC2MB wxStrncpy
61 #define wxMB2WX wxStrncpy
62 #define wxWX2MB wxStrncpy
63 #define wxWC2WX wxWC2MB
64 #define wxWX2WC wxMB2WC
68 // RN: We could do the usual tricky compiler detection here,
69 // and use their variant (such as wmemchr, etc.). The problem
70 // is that these functions are quite rare, even though they are
71 // part of the current POSIX standard. In addition, most compilers
72 // (including even MSC) inline them just like we do right in their
76 #include <string.h> //for mem funcs
78 //implement our own wmem variants
79 inline wxChar
* wxTmemchr(const wxChar
* s
, wxChar c
, size_t l
)
81 for(;l
&& *s
!= c
;--l
, ++s
) {}
88 inline int wxTmemcmp(const wxChar
* sz1
, const wxChar
* sz2
, size_t len
)
90 for(; *sz1
== *sz2
&& len
; --len
, ++sz1
, ++sz2
) {}
93 return *sz1
< *sz2
? -1 : *sz1
> *sz2
;
98 inline wxChar
* wxTmemcpy(wxChar
* szOut
, const wxChar
* szIn
, size_t len
)
100 return (wxChar
*) memcpy(szOut
, szIn
, len
* sizeof(wxChar
));
103 inline wxChar
* wxTmemmove(wxChar
* szOut
, const wxChar
* szIn
, size_t len
)
105 return (wxChar
*) memmove(szOut
, szIn
, len
* sizeof(wxChar
));
108 inline wxChar
* wxTmemset(wxChar
* szOut
, const wxChar cIn
, size_t len
)
110 wxChar
* szRet
= szOut
;
118 // and trivial wrappers for char* versions:
119 inline char* wxTmemchr(const char* s
, char c
, size_t len
)
120 { return (char*)memchr(s
, c
, len
); }
121 inline int wxTmemcmp(const char* sz1
, const char* sz2
, size_t len
)
122 { return memcmp(sz1
, sz2
, len
); }
123 inline char* wxTmemcpy(char* szOut
, const char* szIn
, size_t len
)
124 { return (char*)memcpy(szOut
, szIn
, len
); }
125 inline char* wxTmemmove(char* szOut
, const char* szIn
, size_t len
)
126 { return (char*)memmove(szOut
, szIn
, len
); }
127 inline char* wxTmemset(char* szOut
, const char cIn
, size_t len
)
128 { return (char*)memset(szOut
, cIn
, len
); }
130 #else /* !wxUSE_UNICODE */
131 #define wxTmemchr memchr
132 #define wxTmemcmp memcmp
133 #define wxTmemcpy memcpy
134 #define wxTmemmove memmove
135 #define wxTmemset memset
136 #endif /* wxUSE_UNICODE/!wxUSE_UNICODE */
140 // ============================================================================
141 // wx wrappers for CRT functions in both char* and wchar_t* versions
142 // ============================================================================
144 // A few notes on implementation of these wrappers:
146 // We need both char* and wchar_t* versions of functions like wxStrlen() for
147 // compatibility with both ANSI and Unicode builds.
149 // This makes passing wxString or c_str()/mb_str()/wc_str() result to them
150 // ambiguous, so we need to provide overrides for that as well (in cases where
153 // We can do this without problems for some functions (wxStrlen()), but in some
154 // cases, we can't stay compatible with both ANSI and Unicode builds, e.g. for
155 // wxStrcpy(const wxString&), which can only return either char* or wchar_t*.
156 // In these cases, we preserve ANSI build compatibility by returning char*.
158 // ----------------------------------------------------------------------------
160 // ----------------------------------------------------------------------------
162 // NB: we can't provide const wchar_t* (= wxChar*) overload, because calling
163 // wxSetlocale(category, NULL) -- which is a common thing to do --would be
165 WXDLLIMPEXP_BASE
char* wxSetlocale(int category
, const char *locale
);
166 inline char* wxSetlocale(int category
, const wxCharBuffer
& locale
)
167 { return wxSetlocale(category
, locale
.data()); }
168 inline char* wxSetlocale(int category
, const wxString
& locale
)
169 { return wxSetlocale(category
, locale
.mb_str()); }
170 inline char* wxSetlocale(int category
, const wxCStrData
& locale
)
171 { return wxSetlocale(category
, locale
.AsCharBuf()); }
173 // ----------------------------------------------------------------------------
175 // ----------------------------------------------------------------------------
177 /* safe version of strlen() (returns 0 if passed NULL pointer) */
178 // NB: these are defined in wxcrtbase.h, see the comment there
179 // inline size_t wxStrlen(const char *s) { return s ? strlen(s) : 0; }
180 // inline size_t wxStrlen(const wchar_t *s) { return s ? wxCRT_Strlen_(s) : 0; }
181 inline size_t wxStrlen(const wxCharBuffer
& s
) { return wxStrlen(s
.data()); }
182 inline size_t wxStrlen(const wxWCharBuffer
& s
) { return wxStrlen(s
.data()); }
183 inline size_t wxStrlen(const wxString
& s
) { return s
.length(); }
184 inline size_t wxStrlen(const wxCStrData
& s
) { return s
.AsString().length(); }
186 // NB: these are defined in wxcrtbase.h, see the comment there
187 // inline char* wxStrdup(const char *s) { return wxStrdupA(s); }
188 // inline wchar_t* wxStrdup(const wchar_t *s) { return wxStrdupW(s); }
189 inline char* wxStrdup(const wxCharBuffer
& s
) { return wxStrdup(s
.data()); }
190 inline wchar_t* wxStrdup(const wxWCharBuffer
& s
) { return wxStrdup(s
.data()); }
191 inline char* wxStrdup(const wxString
& s
) { return wxStrdup(s
.mb_str()); }
192 inline char* wxStrdup(const wxCStrData
& s
) { return wxStrdup(s
.AsCharBuf()); }
194 inline char *wxStrcpy(char *dest
, const char *src
)
195 { return wxCRT_StrcpyA(dest
, src
); }
196 inline wchar_t *wxStrcpy(wchar_t *dest
, const wchar_t *src
)
197 { return wxCRT_StrcpyW(dest
, src
); }
198 inline char *wxStrcpy(char *dest
, const wxString
& src
)
199 { return wxCRT_StrcpyA(dest
, src
.mb_str()); }
200 inline char *wxStrcpy(char *dest
, const wxCStrData
& src
)
201 { return wxCRT_StrcpyA(dest
, src
.AsCharBuf()); }
202 inline char *wxStrcpy(char *dest
, const wxCharBuffer
& src
)
203 { return wxCRT_StrcpyA(dest
, src
.data()); }
204 inline wchar_t *wxStrcpy(wchar_t *dest
, const wxString
& src
)
205 { return wxCRT_StrcpyW(dest
, src
.wc_str()); }
206 inline wchar_t *wxStrcpy(wchar_t *dest
, const wxCStrData
& src
)
207 { return wxCRT_StrcpyW(dest
, src
.AsWCharBuf()); }
208 inline wchar_t *wxStrcpy(wchar_t *dest
, const wxWCharBuffer
& src
)
209 { return wxCRT_StrcpyW(dest
, src
.data()); }
210 inline char *wxStrcpy(char *dest
, const wchar_t *src
)
211 { return wxCRT_StrcpyA(dest
, wxConvLibc
.cWC2MB(src
)); }
212 inline wchar_t *wxStrcpy(wchar_t *dest
, const char *src
)
213 { return wxCRT_StrcpyW(dest
, wxConvLibc
.cMB2WC(src
)); }
215 inline char *wxStrncpy(char *dest
, const char *src
, size_t n
)
216 { return wxCRT_StrncpyA(dest
, src
, n
); }
217 inline wchar_t *wxStrncpy(wchar_t *dest
, const wchar_t *src
, size_t n
)
218 { return wxCRT_StrncpyW(dest
, src
, n
); }
219 inline char *wxStrncpy(char *dest
, const wxString
& src
, size_t n
)
220 { return wxCRT_StrncpyA(dest
, src
.mb_str(), n
); }
221 inline char *wxStrncpy(char *dest
, const wxCStrData
& src
, size_t n
)
222 { return wxCRT_StrncpyA(dest
, src
.AsCharBuf(), n
); }
223 inline char *wxStrncpy(char *dest
, const wxCharBuffer
& src
, size_t n
)
224 { return wxCRT_StrncpyA(dest
, src
.data(), n
); }
225 inline wchar_t *wxStrncpy(wchar_t *dest
, const wxString
& src
, size_t n
)
226 { return wxCRT_StrncpyW(dest
, src
.wc_str(), n
); }
227 inline wchar_t *wxStrncpy(wchar_t *dest
, const wxCStrData
& src
, size_t n
)
228 { return wxCRT_StrncpyW(dest
, src
.AsWCharBuf(), n
); }
229 inline wchar_t *wxStrncpy(wchar_t *dest
, const wxWCharBuffer
& src
, size_t n
)
230 { return wxCRT_StrncpyW(dest
, src
.data(), n
); }
231 inline char *wxStrncpy(char *dest
, const wchar_t *src
, size_t n
)
232 { return wxCRT_StrncpyA(dest
, wxConvLibc
.cWC2MB(src
), n
); }
233 inline wchar_t *wxStrncpy(wchar_t *dest
, const char *src
, size_t n
)
234 { return wxCRT_StrncpyW(dest
, wxConvLibc
.cMB2WC(src
), n
); }
236 inline char *wxStrcat(char *dest
, const char *src
)
237 { return wxCRT_StrcatA(dest
, src
); }
238 inline wchar_t *wxStrcat(wchar_t *dest
, const wchar_t *src
)
239 { return wxCRT_StrcatW(dest
, src
); }
240 inline char *wxStrcat(char *dest
, const wxString
& src
)
241 { return wxCRT_StrcatA(dest
, src
.mb_str()); }
242 inline char *wxStrcat(char *dest
, const wxCStrData
& src
)
243 { return wxCRT_StrcatA(dest
, src
.AsCharBuf()); }
244 inline char *wxStrcat(char *dest
, const wxCharBuffer
& src
)
245 { return wxCRT_StrcatA(dest
, src
.data()); }
246 inline wchar_t *wxStrcat(wchar_t *dest
, const wxString
& src
)
247 { return wxCRT_StrcatW(dest
, src
.wc_str()); }
248 inline wchar_t *wxStrcat(wchar_t *dest
, const wxCStrData
& src
)
249 { return wxCRT_StrcatW(dest
, src
.AsWCharBuf()); }
250 inline wchar_t *wxStrcat(wchar_t *dest
, const wxWCharBuffer
& src
)
251 { return wxCRT_StrcatW(dest
, src
.data()); }
252 inline char *wxStrcat(char *dest
, const wchar_t *src
)
253 { return wxCRT_StrcatA(dest
, wxConvLibc
.cWC2MB(src
)); }
254 inline wchar_t *wxStrcat(wchar_t *dest
, const char *src
)
255 { return wxCRT_StrcatW(dest
, wxConvLibc
.cMB2WC(src
)); }
257 inline char *wxStrncat(char *dest
, const char *src
, size_t n
)
258 { return wxCRT_StrncatA(dest
, src
, n
); }
259 inline wchar_t *wxStrncat(wchar_t *dest
, const wchar_t *src
, size_t n
)
260 { return wxCRT_StrncatW(dest
, src
, n
); }
261 inline char *wxStrncat(char *dest
, const wxString
& src
, size_t n
)
262 { return wxCRT_StrncatA(dest
, src
.mb_str(), n
); }
263 inline char *wxStrncat(char *dest
, const wxCStrData
& src
, size_t n
)
264 { return wxCRT_StrncatA(dest
, src
.AsCharBuf(), n
); }
265 inline char *wxStrncat(char *dest
, const wxCharBuffer
& src
, size_t n
)
266 { return wxCRT_StrncatA(dest
, src
.data(), n
); }
267 inline wchar_t *wxStrncat(wchar_t *dest
, const wxString
& src
, size_t n
)
268 { return wxCRT_StrncatW(dest
, src
.wc_str(), n
); }
269 inline wchar_t *wxStrncat(wchar_t *dest
, const wxCStrData
& src
, size_t n
)
270 { return wxCRT_StrncatW(dest
, src
.AsWCharBuf(), n
); }
271 inline wchar_t *wxStrncat(wchar_t *dest
, const wxWCharBuffer
& src
, size_t n
)
272 { return wxCRT_StrncatW(dest
, src
.data(), n
); }
273 inline char *wxStrncat(char *dest
, const wchar_t *src
, size_t n
)
274 { return wxCRT_StrncatA(dest
, wxConvLibc
.cWC2MB(src
), n
); }
275 inline wchar_t *wxStrncat(wchar_t *dest
, const char *src
, size_t n
)
276 { return wxCRT_StrncatW(dest
, wxConvLibc
.cMB2WC(src
), n
); }
279 #define WX_STR_DECL(name, T1, T2) name(T1 s1, T2 s2)
280 #define WX_STR_CALL(func, a1, a2) func(a1, a2)
282 // This macro defines string function for all possible variants of arguments,
283 // except for those taking wxString or wxCStrData as second argument.
285 // rettype - return type
286 // name - name of the (overloaded) function to define
287 // crtA - function to call for char* versions (takes two arguments)
288 // crtW - ditto for wchar_t* function
289 // forString - function to call when the *first* argument is wxString;
290 // the second argument can be any string type, so this is
291 // typically a template
292 #define WX_STR_FUNC_NO_INVERT(rettype, name, crtA, crtW, forString) \
293 inline rettype WX_STR_DECL(name, const char *, const char *) \
294 { return WX_STR_CALL(crtA, s1, s2); } \
295 inline rettype WX_STR_DECL(name, const char *, const wchar_t *) \
296 { return WX_STR_CALL(forString, wxString(s1), wxString(s2)); } \
297 inline rettype WX_STR_DECL(name, const char *, const wxCharBuffer&) \
298 { return WX_STR_CALL(crtA, s1, s2.data()); } \
299 inline rettype WX_STR_DECL(name, const char *, const wxWCharBuffer&) \
300 { return WX_STR_CALL(forString, wxString(s1), s2.data()); } \
302 inline rettype WX_STR_DECL(name, const wchar_t *, const wchar_t *) \
303 { return WX_STR_CALL(crtW, s1, s2); } \
304 inline rettype WX_STR_DECL(name, const wchar_t *, const char *) \
305 { return WX_STR_CALL(forString, wxString(s1), wxString(s2)); } \
306 inline rettype WX_STR_DECL(name, const wchar_t *, const wxWCharBuffer&) \
307 { return WX_STR_CALL(crtW, s1, s2.data()); } \
308 inline rettype WX_STR_DECL(name, const wchar_t *, const wxCharBuffer&) \
309 { return WX_STR_CALL(forString, wxString(s1), s2.data()); } \
311 inline rettype WX_STR_DECL(name, const wxCharBuffer&, const char *) \
312 { return WX_STR_CALL(crtA, s1.data(), s2); } \
313 inline rettype WX_STR_DECL(name, const wxCharBuffer&, const wchar_t *) \
314 { return WX_STR_CALL(forString, wxString(s1), wxString(s2)); } \
315 inline rettype WX_STR_DECL(name, const wxCharBuffer&, const wxCharBuffer&)\
316 { return WX_STR_CALL(crtA, s1.data(), s2.data()); } \
317 inline int WX_STR_DECL(name, const wxCharBuffer&, const wxWCharBuffer&) \
318 { return WX_STR_CALL(forString, wxString(s1), wxString(s2)); } \
320 inline rettype WX_STR_DECL(name, const wxWCharBuffer&, const wchar_t *) \
321 { return WX_STR_CALL(crtW, s1.data(), s2); } \
322 inline rettype WX_STR_DECL(name, const wxWCharBuffer&, const char *) \
323 { return WX_STR_CALL(forString, wxString(s1), wxString(s2)); } \
324 inline int WX_STR_DECL(name, const wxWCharBuffer&, const wxWCharBuffer&) \
325 { return WX_STR_CALL(crtW, s1.data(), s2.data()); } \
326 inline int WX_STR_DECL(name, const wxWCharBuffer&, const wxCharBuffer&) \
327 { return WX_STR_CALL(forString, wxString(s1), wxString(s2)); } \
329 inline rettype WX_STR_DECL(name, const wxString&, const char*) \
330 { return WX_STR_CALL(forString, s1, s2); } \
331 inline rettype WX_STR_DECL(name, const wxString&, const wchar_t*) \
332 { return WX_STR_CALL(forString, s1, s2); } \
333 inline rettype WX_STR_DECL(name, const wxString&, const wxCharBuffer&) \
334 { return WX_STR_CALL(forString, s1, s2); } \
335 inline rettype WX_STR_DECL(name, const wxString&, const wxWCharBuffer&) \
336 { return WX_STR_CALL(forString, s1, s2); } \
337 inline rettype WX_STR_DECL(name, const wxString&, const wxString&) \
338 { return WX_STR_CALL(forString, s1, s2); } \
339 inline rettype WX_STR_DECL(name, const wxString&, const wxCStrData&) \
340 { return WX_STR_CALL(forString, s1, s2); } \
342 inline rettype WX_STR_DECL(name, const wxCStrData&, const char*) \
343 { return WX_STR_CALL(forString, s1.AsString(), s2); } \
344 inline rettype WX_STR_DECL(name, const wxCStrData&, const wchar_t*) \
345 { return WX_STR_CALL(forString, s1.AsString(), s2); } \
346 inline rettype WX_STR_DECL(name, const wxCStrData&, const wxCharBuffer&) \
347 { return WX_STR_CALL(forString, s1.AsString(), s2); } \
348 inline rettype WX_STR_DECL(name, const wxCStrData&, const wxWCharBuffer&) \
349 { return WX_STR_CALL(forString, s1.AsString(), s2); } \
350 inline rettype WX_STR_DECL(name, const wxCStrData&, const wxString&) \
351 { return WX_STR_CALL(forString, s1.AsString(), s2); } \
352 inline rettype WX_STR_DECL(name, const wxCStrData&, const wxCStrData&) \
353 { return WX_STR_CALL(forString, s1.AsString(), s2); }
355 // This defines strcmp-like function, i.e. one returning the result of
356 // comparison; see WX_STR_FUNC_NO_INVERT for explanation of the arguments
357 #define WX_STRCMP_FUNC(name, crtA, crtW, forString) \
358 WX_STR_FUNC_NO_INVERT(int, name, crtA, crtW, forString) \
360 inline int WX_STR_DECL(name, const char *, const wxCStrData&) \
361 { return -WX_STR_CALL(forString, s2.AsString(), s1); } \
362 inline int WX_STR_DECL(name, const char *, const wxString&) \
363 { return -WX_STR_CALL(forString, s2, s1); } \
365 inline int WX_STR_DECL(name, const wchar_t *, const wxCStrData&) \
366 { return -WX_STR_CALL(forString, s2.AsString(), s1); } \
367 inline int WX_STR_DECL(name, const wchar_t *, const wxString&) \
368 { return -WX_STR_CALL(forString, s2, s1); } \
370 inline int WX_STR_DECL(name, const wxCharBuffer&, const wxCStrData&) \
371 { return -WX_STR_CALL(forString, s2.AsString(), s1.data()); } \
372 inline int WX_STR_DECL(name, const wxCharBuffer&, const wxString&) \
373 { return -WX_STR_CALL(forString, s2, s1.data()); } \
375 inline int WX_STR_DECL(name, const wxWCharBuffer&, const wxCStrData&) \
376 { return -WX_STR_CALL(forString, s2.AsString(), s1.data()); } \
377 inline int WX_STR_DECL(name, const wxWCharBuffer&, const wxString&) \
378 { return -WX_STR_CALL(forString, s2, s1.data()); }
381 // This defines a string function that is *not* strcmp-like, i.e. doesn't
382 // return the result of comparison and so if the second argument is a string,
383 // it has to be converted to char* or wchar_t*
384 #define WX_STR_FUNC(rettype, name, crtA, crtW, forString) \
385 WX_STR_FUNC_NO_INVERT(rettype, name, crtA, crtW, forString) \
387 inline rettype WX_STR_DECL(name, const char *, const wxCStrData&) \
388 { return WX_STR_CALL(crtA, s1, s2.AsCharBuf()); } \
389 inline rettype WX_STR_DECL(name, const char *, const wxString&) \
390 { return WX_STR_CALL(crtA, s1, s2.mb_str()); } \
392 inline rettype WX_STR_DECL(name, const wchar_t *, const wxCStrData&) \
393 { return WX_STR_CALL(crtW, s1, s2.AsWCharBuf()); } \
394 inline rettype WX_STR_DECL(name, const wchar_t *, const wxString&) \
395 { return WX_STR_CALL(crtW, s1, s2.wc_str()); } \
397 inline rettype WX_STR_DECL(name, const wxCharBuffer&, const wxCStrData&) \
398 { return WX_STR_CALL(crtA, s1.data(), s2.AsCharBuf()); } \
399 inline rettype WX_STR_DECL(name, const wxCharBuffer&, const wxString&) \
400 { return WX_STR_CALL(crtA, s1.data(), s2.mb_str()); } \
402 inline rettype WX_STR_DECL(name, const wxWCharBuffer&, const wxCStrData&) \
403 { return WX_STR_CALL(crtW, s1.data(), s2.AsWCharBuf()); } \
404 inline rettype WX_STR_DECL(name, const wxWCharBuffer&, const wxString&) \
405 { return WX_STR_CALL(crtW, s1.data(), s2.wc_str()); }
408 inline int wxStrcmp_String(const wxString
& s1
, const T
& s2
)
409 { return s1
.compare(s2
); }
410 WX_STRCMP_FUNC(wxStrcmp
, wxCRT_StrcmpA
, wxCRT_StrcmpW
, wxStrcmp_String
)
413 inline int wxStricmp_String(const wxString
& s1
, const T
& s2
)
414 { return s1
.CmpNoCase(s2
); }
415 WX_STRCMP_FUNC(wxStricmp
, wxCRT_StricmpA
, wxCRT_StricmpW
, wxStricmp_String
)
418 inline int wxStrcoll_String(const wxString
& s1
, const T
& s2
)
421 // NB: strcoll() doesn't work correctly on UTF-8 strings, so we have to use
422 // wc_str() even if wxUSE_UNICODE_UTF8:
423 return wxStrcoll(s1
.wc_str(), s2
);
425 return wxStrcoll(s1
.mb_str(), s2
);
428 WX_STRCMP_FUNC(wxStrcoll
, wxCRT_StrcollA
, wxCRT_StrcollW
, wxStrcoll_String
)
431 inline int wxStrspn_String(const wxString
& s1
, const T
& s2
)
433 size_t pos
= s1
.find_first_not_of(s2
);
434 return (pos
== wxString::npos
) ? s1
.length() : pos
;
436 WX_STR_FUNC(size_t, wxStrspn
, wxCRT_StrspnA
, wxCRT_StrspnW
, wxStrspn_String
)
439 inline int wxStrcspn_String(const wxString
& s1
, const T
& s2
)
441 size_t pos
= s1
.find_first_of(s2
);
442 return (pos
== wxString::npos
) ? s1
.length() : pos
;
444 WX_STR_FUNC(size_t, wxStrcspn
, wxCRT_StrcspnA
, wxCRT_StrcspnW
, wxStrcspn_String
)
448 #define WX_STR_DECL(name, T1, T2) name(T1 s1, T2 s2, size_t n)
449 #define WX_STR_CALL(func, a1, a2) func(a1, a2, n)
452 inline int wxStrncmp_String(const wxString
& s1
, const T
& s2
, size_t n
)
453 { return s1
.compare(0, n
, s2
, 0, n
); }
454 WX_STRCMP_FUNC(wxStrncmp
, wxCRT_StrncmpA
, wxCRT_StrncmpW
, wxStrncmp_String
)
457 inline int wxStrnicmp_String(const wxString
& s1
, const T
& s2
, size_t n
)
458 { return s1
.substr(0, n
).CmpNoCase(wxString(s2
).substr(0, n
)); }
459 WX_STRCMP_FUNC(wxStrnicmp
, wxCRT_StrnicmpA
, wxCRT_StrnicmpW
, wxStrnicmp_String
)
463 #undef WX_STRCMP_FUNC
465 #undef WX_STR_FUNC_NO_INVERT
467 inline size_t wxStrxfrm(char *dest
, const char *src
, size_t n
)
468 { return wxCRT_StrxfrmA(dest
, src
, n
); }
469 inline size_t wxStrxfrm(wchar_t *dest
, const wchar_t *src
, size_t n
)
470 { return wxCRT_StrxfrmW(dest
, src
, n
); }
472 inline size_t wxStrxfrm(T
*dest
, const wxCharTypeBuffer
<T
>& src
, size_t n
)
473 { return wxStrxfrm(dest
, src
.data(), n
); }
474 inline size_t wxStrxfrm(char *dest
, const wxString
& src
, size_t n
)
475 { return wxCRT_StrxfrmA(dest
, src
.mb_str(), n
); }
476 inline size_t wxStrxfrm(wchar_t *dest
, const wxString
& src
, size_t n
)
477 { return wxCRT_StrxfrmW(dest
, src
.wc_str(), n
); }
478 inline size_t wxStrxfrm(char *dest
, const wxCStrData
& src
, size_t n
)
479 { return wxCRT_StrxfrmA(dest
, src
.AsCharBuf(), n
); }
480 inline size_t wxStrxfrm(wchar_t *dest
, const wxCStrData
& src
, size_t n
)
481 { return wxCRT_StrxfrmW(dest
, src
.AsWCharBuf(), n
); }
483 inline char *wxStrtok(char *str
, const char *delim
, char **saveptr
)
484 { return wxCRT_StrtokA(str
, delim
, saveptr
); }
485 inline wchar_t *wxStrtok(wchar_t *str
, const wchar_t *delim
, wchar_t **saveptr
)
486 { return wxCRT_StrtokW(str
, delim
, saveptr
); }
488 inline T
*wxStrtok(T
*str
, const wxCharTypeBuffer
<T
>& delim
, T
**saveptr
)
489 { return wxStrtok(str
, delim
.data(), saveptr
); }
490 inline char *wxStrtok(char *str
, const wxCStrData
& delim
, char **saveptr
)
491 { return wxCRT_StrtokA(str
, delim
.AsCharBuf(), saveptr
); }
492 inline wchar_t *wxStrtok(wchar_t *str
, const wxCStrData
& delim
, wchar_t **saveptr
)
493 { return wxCRT_StrtokW(str
, delim
.AsWCharBuf(), saveptr
); }
494 inline char *wxStrtok(char *str
, const wxString
& delim
, char **saveptr
)
495 { return wxCRT_StrtokA(str
, delim
.mb_str(), saveptr
); }
496 inline wchar_t *wxStrtok(wchar_t *str
, const wxString
& delim
, wchar_t **saveptr
)
497 { return wxCRT_StrtokW(str
, delim
.wc_str(), saveptr
); }
499 inline const char *wxStrstr(const char *haystack
, const char *needle
)
500 { return wxCRT_StrstrA(haystack
, needle
); }
501 inline const wchar_t *wxStrstr(const wchar_t *haystack
, const wchar_t *needle
)
502 { return wxCRT_StrstrW(haystack
, needle
); }
503 inline const char *wxStrstr(const char *haystack
, const wxString
& needle
)
504 { return wxCRT_StrstrA(haystack
, needle
.mb_str()); }
505 inline const wchar_t *wxStrstr(const wchar_t *haystack
, const wxString
& needle
)
506 { return wxCRT_StrstrW(haystack
, needle
.wc_str()); }
507 // these functions return char* pointer into the non-temporary conversion buffer
508 // used by c_str()'s implicit conversion to char*, for ANSI build compatibility
509 inline const char *wxStrstr(const wxString
& haystack
, const wxString
& needle
)
510 { return wxCRT_StrstrA(haystack
.c_str(), needle
.mb_str()); }
511 inline const char *wxStrstr(const wxCStrData
& haystack
, const wxString
& needle
)
512 { return wxCRT_StrstrA(haystack
, needle
.mb_str()); }
513 inline const char *wxStrstr(const wxCStrData
& haystack
, const wxCStrData
& needle
)
514 { return wxCRT_StrstrA(haystack
, needle
.AsCharBuf()); }
515 // if 'needle' is char/wchar_t, then the same is probably wanted as return value
516 inline const char *wxStrstr(const wxString
& haystack
, const char *needle
)
517 { return wxCRT_StrstrA(haystack
.c_str(), needle
); }
518 inline const char *wxStrstr(const wxCStrData
& haystack
, const char *needle
)
519 { return wxCRT_StrstrA(haystack
, needle
); }
520 inline const wchar_t *wxStrstr(const wxString
& haystack
, const wchar_t *needle
)
521 { return wxCRT_StrstrW(haystack
.c_str(), needle
); }
522 inline const wchar_t *wxStrstr(const wxCStrData
& haystack
, const wchar_t *needle
)
523 { return wxCRT_StrstrW(haystack
, needle
); }
525 inline const char *wxStrchr(const char *s
, char c
)
526 { return wxCRT_StrchrA(s
, c
); }
527 inline const wchar_t *wxStrchr(const wchar_t *s
, wchar_t c
)
528 { return wxCRT_StrchrW(s
, c
); }
529 inline const char *wxStrrchr(const char *s
, char c
)
530 { return wxCRT_StrrchrA(s
, c
); }
531 inline const wchar_t *wxStrrchr(const wchar_t *s
, wchar_t c
)
532 { return wxCRT_StrrchrW(s
, c
); }
534 inline const T
* wxStrchr(const wxCharTypeBuffer
<T
>& s
, T c
)
535 { return wxStrchr(s
.data(), c
); }
537 inline const T
* wxStrrchr(const wxCharTypeBuffer
<T
>& s
, T c
)
538 { return wxStrrchr(s
.data(), c
); }
539 // these functions return char* pointer into the non-temporary conversion buffer
540 // used by c_str()'s implicit conversion to char*, for ANSI build compatibility
541 inline const char* wxStrchr(const wxString
& s
, char c
)
542 { return wxCRT_StrchrA((const char*)s
.c_str(), c
); }
543 inline const char* wxStrrchr(const wxString
& s
, char c
)
544 { return wxCRT_StrrchrA((const char*)s
.c_str(), c
); }
545 inline const char* wxStrchr(const wxCStrData
& s
, char c
)
546 { return wxCRT_StrchrA((const char*)s
.AsCharBuf(), c
); }
547 inline const char* wxStrrchr(const wxCStrData
& s
, char c
)
548 { return wxCRT_StrrchrA((const char*)s
.AsCharBuf(), c
); }
550 inline const char *wxStrpbrk(const char *s
, const char *accept
)
551 { return wxCRT_StrpbrkA(s
, accept
); }
552 inline const wchar_t *wxStrpbrk(const wchar_t *s
, const wchar_t *accept
)
553 { return wxCRT_StrpbrkW(s
, accept
); }
554 inline const char *wxStrpbrk(const char *s
, const wxCharBuffer
& accept
)
555 { return wxCRT_StrpbrkA(s
, accept
.data()); }
556 inline const char *wxStrpbrk(const char *s
, const wxString
& accept
)
557 { return wxCRT_StrpbrkA(s
, accept
.mb_str()); }
558 inline const char *wxStrpbrk(const char *s
, const wxCStrData
& accept
)
559 { return wxCRT_StrpbrkA(s
, accept
.AsCharBuf()); }
560 inline const wchar_t *wxStrpbrk(const wchar_t *s
, const wxWCharBuffer
& accept
)
561 { return wxCRT_StrpbrkW(s
, accept
.data()); }
562 inline const wchar_t *wxStrpbrk(const wchar_t *s
, const wxString
& accept
)
563 { return wxCRT_StrpbrkW(s
, accept
.wc_str()); }
564 inline const wchar_t *wxStrpbrk(const wchar_t *s
, const wxCStrData
& accept
)
565 { return wxCRT_StrpbrkW(s
, accept
.AsWCharBuf()); }
566 inline const char *wxStrpbrk(const wxString
& s
, const wxString
& accept
)
567 { return wxCRT_StrpbrkA(s
.c_str(), accept
.mb_str()); }
568 inline const char *wxStrpbrk(const wxCStrData
& s
, const wxString
& accept
)
569 { return wxCRT_StrpbrkA(s
.AsChar(), accept
.mb_str()); }
572 /* inlined non-const versions */
573 inline char *wxStrstr(char *haystack
, const char *needle
)
574 { return (char *)wxStrstr((const char *)haystack
, needle
); }
575 inline wchar_t *wxStrstr(wchar_t *haystack
, const wchar_t *needle
)
576 { return (wchar_t *)wxStrstr((const wchar_t *)haystack
, needle
); }
577 inline char *wxStrstr(char *haystack
, const wxString
& needle
)
578 { return (char *)wxStrstr((const char *)haystack
, needle
); }
579 inline wchar_t *wxStrstr(wchar_t *haystack
, const wxString
& needle
)
580 { return (wchar_t *)wxStrstr((const wchar_t *)haystack
, needle
); }
582 inline char * wxStrchr(char *s
, char c
)
583 { return (char *)wxStrchr((const char *)s
, c
); }
584 inline char * wxStrrchr(char *s
, char c
)
585 { return (char *)wxStrrchr((const char *)s
, c
); }
586 inline wchar_t * wxStrchr(wchar_t *s
, wchar_t c
)
587 { return (wchar_t *)wxStrchr((const wchar_t *)s
, c
); }
588 inline wchar_t * wxStrrchr(wchar_t *s
, wchar_t c
)
589 { return (wchar_t *)wxStrrchr((const wchar_t *)s
, c
); }
591 inline char * wxStrpbrk(char *s
, const char *accept
)
592 { return (char *)wxStrpbrk((const char *)s
, accept
); }
593 inline wchar_t * wxStrpbrk(wchar_t *s
, const wchar_t *accept
)
594 { return (wchar_t *)wxStrpbrk((const wchar_t *)s
, accept
); }
595 inline char * wxStrpbrk(char *s
, const wxString
& accept
)
596 { return (char *)wxStrpbrk((const char *)s
, accept
); }
597 inline wchar_t * wxStrpbrk(wchar_t *s
, const wxString
& accept
)
598 { return (wchar_t *)wxStrpbrk((const wchar_t *)s
, accept
); }
601 // ----------------------------------------------------------------------------
603 // ----------------------------------------------------------------------------
605 // NB: using fn_str() for mode is a hack to get the same type (char*/wchar_t*)
606 // as needed, the conversion itself doesn't matter, it's ASCII
607 inline FILE *wxFopen(const wxString
& path
, const wxString
& mode
)
608 { return wxCRT_Fopen(path
.fn_str(), mode
.fn_str()); }
609 inline FILE *wxFreopen(const wxString
& path
, const wxString
& mode
, FILE *stream
)
610 { return wxCRT_Freopen(path
.fn_str(), mode
.fn_str(), stream
); }
611 inline int wxRemove(const wxString
& path
)
612 { return wxCRT_Remove(path
.fn_str()); }
613 inline int wxRename(const wxString
& oldpath
, const wxString
& newpath
)
614 { return wxCRT_Rename(oldpath
.fn_str(), newpath
.fn_str()); }
616 // NB: we don't provide wxString/wxCStrData versions of wxTmpnam, because 's'
618 inline char *wxTmpnam(char *s
)
619 { return wxCRT_TmpnamA(s
); }
620 inline wchar_t *wxTmpnam(wchar_t *s
)
621 { return wxCRT_TmpnamW(s
); }
623 extern WXDLLIMPEXP_BASE
int wxPuts(const wxString
& s
);
624 extern WXDLLIMPEXP_BASE
int wxFputs(const wxString
& s
, FILE *stream
);
625 extern WXDLLIMPEXP_BASE
void wxPerror(const wxString
& s
);
627 extern WXDLLIMPEXP_BASE
int wxFputc(const wxUniChar
& c
, FILE *stream
);
629 #define wxPutc(c, stream) wxFputc(c, stream)
630 #define wxPutchar(c) wxFputc(c, stdout)
631 #define wxFputchar(c) wxPutchar(c)
633 // NB: We only provide ANSI version of fgets() because fgetws() interprets the
634 // stream according to current locale, which is rarely what is desired.
635 inline char *wxFgets(char *s
, int size
, FILE *stream
)
636 { return wxCRT_FgetsA(s
, size
, stream
); }
637 // This version calls ANSI version and converts the string using wxConvLibc
638 extern WXDLLIMPEXP_BASE
wchar_t *wxFgets(wchar_t *s
, int size
, FILE *stream
);
640 #define wxGets(s) wxGets_is_insecure_and_dangerous_use_wxFgets_instead
642 // NB: We only provide ANSI versions of this for the same reasons as in the
643 // case of wxFgets() above
644 inline int wxFgetc(FILE *stream
) { return wxCRT_FgetcA(stream
); }
645 inline int wxUngetc(int c
, FILE *stream
) { return wxCRT_UngetcA(c
, stream
); }
647 #define wxGetc(stream) wxFgetc(stream)
648 #define wxGetchar() wxFgetc(stdin)
649 #define wxFgetchar() wxGetchar()
651 // ----------------------------------------------------------------------------
652 // stdlib.h functions
653 // ----------------------------------------------------------------------------
656 inline int wxAtoi(const wxString
& str
) { return wxCRT_AtoiW(str
.wc_str()); }
658 inline int wxAtoi(const wxString
& str
) { return wxCRT_AtoiA(str
.mb_str()); }
662 inline long wxAtol(const wxString
& str
) { return wxCRT_AtolW(str
.wc_str()); }
664 inline long wxAtol(const wxString
& str
) { return wxCRT_AtolA(str
.mb_str()); }
668 inline double wxAtof(const wxString
& str
) { return wxCRT_AtofW(str
.wc_str()); }
670 inline double wxAtof(const wxString
& str
) { return wxCRT_AtofA(str
.mb_str()); }
673 inline double wxStrtod(const char *nptr
, char **endptr
)
674 { return wxCRT_StrtodA(nptr
, endptr
); }
675 inline double wxStrtod(const wchar_t *nptr
, wchar_t **endptr
)
676 { return wxCRT_StrtodW(nptr
, endptr
); }
678 inline double wxStrtod(const wxCharTypeBuffer
<T
>& nptr
, T
**endptr
)
679 { return wxStrtod(nptr
.data(), endptr
); }
681 // We implement wxStrto*() like this so that the code compiles when NULL is
682 // passed in - - if we had just char** and wchar_t** overloads for 'endptr', it
683 // would be ambiguous. The solution is to use a template so that endptr can be
684 // any type: when NULL constant is used, the type will be int and we can handle
685 // that case specially. Otherwise, we infer the type that 'nptr' should be
686 // converted to from the type of 'endptr'. We need wxStrtoxCharType<T> template
687 // to make the code compile even for T=int (that's the case when it's not going
688 // to be ever used, but it still has to compile).
689 template<typename T
> struct wxStrtoxCharType
{};
690 template<> struct wxStrtoxCharType
<char**>
691 { typedef const char* Type
; };
692 template<> struct wxStrtoxCharType
<wchar_t**>
693 { typedef const wchar_t* Type
; };
694 template<> struct wxStrtoxCharType
<int>
695 { typedef const char* Type
; /* this one is never used */ };
698 inline double wxStrtod(const wxString
& nptr
, T endptr
)
702 // when we don't care about endptr, use the string representation that
703 // doesn't require any conversion (it doesn't matter for this function
704 // even if its UTF-8):
705 return wxStrtod(nptr
.wx_str(), (wxStringCharType
**)NULL
);
709 // note that it is important to use c_str() here and not mb_str() or
710 // wc_str(), because we store the pointer into (possibly converted)
711 // buffer in endptr and so it must be valid even when wxStrtod() returns
712 return wxStrtod((typename wxStrtoxCharType
<T
>::Type
)nptr
.c_str(), endptr
);
716 inline double wxStrtod(const wxCStrData
& nptr
, T endptr
)
717 { return wxStrtod(nptr
.AsString(), endptr
); }
720 #define WX_STRTOX_FUNC(rettype, name, implA, implW) \
721 /* see wxStrtod() above for explanation of this code: */ \
722 inline rettype name(const char *nptr, char **endptr, int base) \
723 { return implA(nptr, endptr, base); } \
724 inline rettype name(const wchar_t *nptr, wchar_t **endptr, int base) \
725 { return implW(nptr, endptr, base); } \
726 template<typename T> \
727 inline rettype name(const wxCharTypeBuffer<T>& nptr, T **endptr, int base)\
728 { return name(nptr.data(), endptr); } \
729 template<typename T> \
730 inline rettype name(const wxString& nptr, T endptr, int base) \
733 return name(nptr.wx_str(), (wxStringCharType**)NULL, base); \
735 return name((typename wxStrtoxCharType<T>::Type)nptr.c_str(), \
738 template<typename T> \
739 inline rettype name(const wxCStrData& nptr, T endptr, int base) \
740 { return name(nptr.AsString(), endptr, base); }
742 WX_STRTOX_FUNC(long, wxStrtol
, wxCRT_StrtolA
, wxCRT_StrtolW
)
743 WX_STRTOX_FUNC(unsigned long, wxStrtoul
, wxCRT_StrtoulA
, wxCRT_StrtoulW
)
744 WX_STRTOX_FUNC(wxLongLong_t
, wxStrtoll
, wxCRT_StrtollA
, wxCRT_StrtollW
)
745 WX_STRTOX_FUNC(wxULongLong_t
, wxStrtoull
, wxCRT_StrtoullA
, wxCRT_StrtoullW
)
747 #undef WX_STRTOX_FUNC
750 // mingw32 doesn't provide _tsystem() even though it provides other stdlib.h
751 // functions in their wide versions
753 inline int wxSystem(const wxString
& str
) { return wxCRT_SystemW(str
.wc_str()); }
755 inline int wxSystem(const wxString
& str
) { return wxCRT_SystemA(str
.mb_str()); }
758 inline char* wxGetenv(const char *name
) { return wxCRT_GetenvA(name
); }
759 inline wchar_t* wxGetenv(const wchar_t *name
) { return wxCRT_GetenvW(name
); }
760 inline char* wxGetenv(const wxString
& name
) { return wxCRT_GetenvA(name
.mb_str()); }
761 inline char* wxGetenv(const wxCStrData
& name
) { return wxCRT_GetenvA(name
.AsCharBuf()); }
762 inline char* wxGetenv(const wxCharBuffer
& name
) { return wxCRT_GetenvA(name
.data()); }
763 inline wchar_t* wxGetenv(const wxWCharBuffer
& name
) { return wxCRT_GetenvW(name
.data()); }
766 // ----------------------------------------------------------------------------
768 // ----------------------------------------------------------------------------
770 inline size_t wxStrftime(char *s
, size_t max
,
771 const wxString
& format
, const struct tm
*tm
)
772 { return wxCRT_StrftimeA(s
, max
, format
.mb_str(), tm
); }
774 inline size_t wxStrftime(wchar_t *s
, size_t max
,
775 const wxString
& format
, const struct tm
*tm
)
776 { return wxCRT_StrftimeW(s
, max
, format
.wc_str(), tm
); }
778 // NB: we can't provide both char* and wchar_t* versions for obvious reasons
779 // and returning wxString wouldn't work either (it would be immediately
780 // destroyed and if assigned to char*/wchar_t*, the pointer would be
781 // invalid), so we only keep ASCII version, because the returned value
782 // is always ASCII anyway
783 #define wxAsctime asctime
784 #define wxCtime ctime
787 // ----------------------------------------------------------------------------
789 // ----------------------------------------------------------------------------
791 // FIXME-UTF8: we'd be better off implementing these ourselves, as the CRT
792 // version is locale-dependent
793 // FIXME-UTF8: should we return bool from these instead of int?
794 // FIXME-UTF8: these don't work when EOF is passed in because of wxUniChar,
795 // is this OK or not?
797 inline int wxIsalnum(const wxUniChar
& c
) { return wxCRT_IsalnumW(c
); }
798 inline int wxIsalpha(const wxUniChar
& c
) { return wxCRT_IsalphaW(c
); }
799 inline int wxIscntrl(const wxUniChar
& c
) { return wxCRT_IscntrlW(c
); }
800 inline int wxIsdigit(const wxUniChar
& c
) { return wxCRT_IsdigitW(c
); }
801 inline int wxIsgraph(const wxUniChar
& c
) { return wxCRT_IsgraphW(c
); }
802 inline int wxIslower(const wxUniChar
& c
) { return wxCRT_IslowerW(c
); }
803 inline int wxIsprint(const wxUniChar
& c
) { return wxCRT_IsprintW(c
); }
804 inline int wxIspunct(const wxUniChar
& c
) { return wxCRT_IspunctW(c
); }
805 inline int wxIsspace(const wxUniChar
& c
) { return wxCRT_IsspaceW(c
); }
806 inline int wxIsupper(const wxUniChar
& c
) { return wxCRT_IsupperW(c
); }
807 inline int wxIsxdigit(const wxUniChar
& c
) { return wxCRT_IsxdigitW(c
); }
809 inline wxUniChar
wxTolower(const wxUniChar
& c
) { return wxCRT_TolowerW(c
); }
810 inline wxUniChar
wxToupper(const wxUniChar
& c
) { return wxCRT_ToupperW(c
); }
812 #if WXWIN_COMPATIBILITY_2_8
813 // we had goofed and defined wxIsctrl() instead of (correct) wxIscntrl() in the
814 // initial versions of this header -- now it is too late to remove it so
815 // although we fixed the function/macro name above, still provide the
816 // backwards-compatible synonym.
817 wxDEPRECATED( inline int wxIsctrl(const wxUniChar
& c
) );
818 inline int wxIsctrl(const wxUniChar
& c
) { return wxIscntrl(c
); }
819 #endif // WXWIN_COMPATIBILITY_2_8
821 #endif /* _WX_WXCRT_H_ */