]> git.saurik.com Git - wxWidgets.git/blame_incremental - include/wx/wxcrtbase.h
projects / wxWidgets.git / blame_incremental
? search:
summary | shortlog | log | commit | commitdiff | tree
blob | blame (non-incremental) | history | HEAD
Remove SetPageTitle and GetPageTitle and make GetCurrentTitle actually return the...
[wxWidgets.git] / include / wx / wxcrtbase.h
... / ...
CommitLineData
1/*
2 * Name: wx/wxcrtbase.h
3 * Purpose: Type-safe ANSI and Unicode builds compatible wrappers for
4 * CRT functions
5 * Author: Joel Farley, Ove Kaaven
6 * Modified by: Vadim Zeitlin, Robert Roebling, Ron Lee
7 * Created: 1998/06/12
8 * RCS-ID: $Id$
9 * Copyright: (c) 1998-2006 wxWidgets dev team
10 * Licence: wxWindows licence
11 */
12
13/* THIS IS A C FILE, DON'T USE C++ FEATURES (IN PARTICULAR COMMENTS) IN IT */
14
15#ifndef _WX_WXCRTBASE_H_
16#define _WX_WXCRTBASE_H_
17
18/* -------------------------------------------------------------------------
19 headers and missing declarations
20 ------------------------------------------------------------------------- */
21
22#include "wx/chartype.h"
23
24/*
25 Standard headers we need here.
26
27 NB: don't include any wxWidgets headers here because almost all of them
28 include this one!
29
30 NB2: User code should include wx/crt.h instead of including this
31 header directly.
32
33 */
34
35#if !defined(__WXPALMOS5__)
36#include <stdio.h>
37#include <string.h>
38#include <ctype.h>
39#if defined(__WXPALMOS__)
40 #include <wchar.h>
41#else
42 #include <wctype.h>
43#endif
44#include <time.h>
45#endif
46
47#if defined(__WINDOWS__) && !defined(__WXWINCE__)
48 #include <io.h>
49#endif
50
51#if defined(HAVE_STRTOK_R) && defined(__DARWIN__) && defined(_MSL_USING_MW_C_HEADERS) && _MSL_USING_MW_C_HEADERS
52 char *strtok_r(char *, const char *, char **);
53#endif
54
55/*
56 Using -std=c++{98,0x} option with mingw32 disables most of standard
57 library extensions, so we can't rely on the presence of common non-ANSI
58 functions, define a special symbol to test for this. Notice that this
59 doesn't need to be done for g++ under Linux where _GNU_SOURCE (which is
60 defined by default) still makes all common extensions available even in
61 ANSI mode.
62 */
63#if defined(__MINGW32__) && defined(__STRICT_ANSI__)
64 #define __WX_STRICT_ANSI_GCC__
65#endif
66
67/*
68 a few compilers don't have the (non standard but common) isascii function,
69 define it ourselves for them
70 */
71#ifndef isascii
72 #if defined(__MWERKS__) || defined(__WX_STRICT_ANSI_GCC__)
73 #define wxNEED_ISASCII
74 #elif defined(_WIN32_WCE)
75 #if _WIN32_WCE <= 211
76 #define wxNEED_ISASCII
77 #endif
78 #endif
79#endif /* isascii */
80
81#ifdef wxNEED_ISASCII
82 inline int isascii(int c) { return (unsigned)c < 0x80; }
83#endif
84
85#ifdef _WIN32_WCE
86 #if _WIN32_WCE <= 211
87 #define isspace(c) ((c) == wxT(' ') || (c) == wxT('\t'))
88 #endif
89#endif /* _WIN32_WCE */
90
91/* string.h functions */
92#ifndef strdup
93 #if defined(__MWERKS__) && !defined(__MACH__) && (__MSL__ < 0x00008000)
94 #define wxNEED_STRDUP
95 #elif defined(__WXWINCE__)
96 #if _WIN32_WCE <= 211
97 #define wxNEED_STRDUP
98 #endif
99 #endif
100#endif /* strdup */
101
102#ifdef wxNEED_STRDUP
103 WXDLLIMPEXP_BASE char *strdup(const char* s);
104#endif
105
106/* missing functions in some WinCE versions */
107#ifdef _WIN32_WCE
108#if (_WIN32_WCE < 300)
109WXDLLIMPEXP_BASE void *calloc( size_t num, size_t size );
110#endif
111#endif /* _WIN32_WCE */
112
113
114#if defined(__MWERKS__)
115 /* Metrowerks only has wide char support for OS X >= 10.3 */
116 #if !defined(__DARWIN__) || \
117 (MAC_OS_X_VERSION_MAX_ALLOWED >= MAC_OS_X_VERSION_10_3)
118 #define wxHAVE_MWERKS_UNICODE
119 #endif
120
121 #ifdef wxHAVE_MWERKS_UNICODE
122 #define HAVE_WPRINTF 1
123 #define HAVE_WCSRTOMBS 1
124 #define HAVE_VSWPRINTF 1
125 #endif
126#endif /* __MWERKS__ */
127
128
129/* -------------------------------------------------------------------------
130 UTF-8 locale handling
131 ------------------------------------------------------------------------- */
132
133#ifdef __cplusplus
134 #if wxUSE_UNICODE_UTF8
135 /* flag indicating whether the current locale uses UTF-8 or not; must be
136 updated every time the locale is changed! */
137 #if wxUSE_UTF8_LOCALE_ONLY
138 #define wxLocaleIsUtf8 true
139 #else
140 extern WXDLLIMPEXP_BASE bool wxLocaleIsUtf8;
141 #endif
142 /* function used to update the flag: */
143 extern WXDLLIMPEXP_BASE void wxUpdateLocaleIsUtf8();
144 #else /* !wxUSE_UNICODE_UTF8 */
145 inline void wxUpdateLocaleIsUtf8() {}
146 #endif /* wxUSE_UNICODE_UTF8/!wxUSE_UNICODE_UTF8 */
147#endif /* __cplusplus */
148
149
150/* -------------------------------------------------------------------------
151 string.h
152 ------------------------------------------------------------------------- */
153
154#define wxCRT_StrcatA strcat
155#define wxCRT_StrchrA strchr
156#define wxCRT_StrcmpA strcmp
157#define wxCRT_StrcpyA strcpy
158#define wxCRT_StrcspnA strcspn
159#define wxCRT_StrlenA strlen
160#define wxCRT_StrncatA strncat
161#define wxCRT_StrncmpA strncmp
162#define wxCRT_StrncpyA strncpy
163#define wxCRT_StrpbrkA strpbrk
164#define wxCRT_StrrchrA strrchr
165#define wxCRT_StrspnA strspn
166#define wxCRT_StrstrA strstr
167
168#define wxCRT_StrcatW wcscat
169#define wxCRT_StrchrW wcschr
170#define wxCRT_StrcmpW wcscmp
171#define wxCRT_StrcpyW wcscpy
172#define wxCRT_StrcspnW wcscspn
173#define wxCRT_StrncatW wcsncat
174#define wxCRT_StrncmpW wcsncmp
175#define wxCRT_StrncpyW wcsncpy
176#define wxCRT_StrpbrkW wcspbrk
177#define wxCRT_StrrchrW wcsrchr
178#define wxCRT_StrspnW wcsspn
179#define wxCRT_StrstrW wcsstr
180
181/* these functions are not defined under CE, at least in VC8 CRT */
182#if !defined(__WXWINCE__) && !defined(__WXPALMOS__)
183 #define wxCRT_StrcollA strcoll
184 #define wxCRT_StrxfrmA strxfrm
185
186 #define wxCRT_StrcollW wcscoll
187 #define wxCRT_StrxfrmW wcsxfrm
188#endif /* __WXWINCE__ */
189
190/* Almost all compiler have strdup(), but not quite all: CodeWarrior under
191 Mac and VC++ for Windows CE don't provide it. Another special case is gcc in
192 strict ANSI mode: normally it doesn't provide strdup() but MinGW does
193 provide it under MSVC-compatible name so test for it before checking
194 __WX_STRICT_ANSI_GCC__. */
195#if (defined(__VISUALC__) && __VISUALC__ >= 1400) || \
196 defined(__MINGW32__)
197 #define wxCRT_StrdupA _strdup
198#elif !((defined(__MWERKS__) && defined(__WXMAC__)) || \
199 defined(__WXWINCE__) || \
200 defined(__WX_STRICT_ANSI_GCC__))
201 #define wxCRT_StrdupA strdup
202#endif
203
204/* most Windows compilers provide _wcsdup() */
205#if defined(__WINDOWS__) && \
206 !(defined(__CYGWIN__) || defined(__WX_STRICT_ANSI_GCC__))
207 #define wxCRT_StrdupW _wcsdup
208#elif defined(HAVE_WCSDUP)
209 #define wxCRT_StrdupW wcsdup
210#endif
211
212#ifdef wxHAVE_TCHAR_SUPPORT
213 /* we surely have wchar_t if we have TCHAR have wcslen() */
214 #ifndef HAVE_WCSLEN
215 #define HAVE_WCSLEN
216 #endif
217#endif /* wxHAVE_TCHAR_SUPPORT */
218
219#ifdef HAVE_WCSLEN
220 #define wxCRT_StrlenW wcslen
221#endif
222
223#define wxCRT_StrtodA strtod
224#define wxCRT_StrtolA strtol
225#define wxCRT_StrtoulA strtoul
226#define wxCRT_StrtodW wcstod
227#define wxCRT_StrtolW wcstol
228#define wxCRT_StrtoulW wcstoul
229
230#ifdef __VISUALC__
231 #if __VISUALC__ >= 1300 && !defined(__WXWINCE__)
232 #define wxCRT_StrtollA _strtoi64
233 #define wxCRT_StrtoullA _strtoui64
234 #define wxCRT_StrtollW _wcstoi64
235 #define wxCRT_StrtoullW _wcstoui64
236 #endif /* VC++ 7+ */
237#else
238 #ifdef HAVE_STRTOULL
239 #define wxCRT_StrtollA strtoll
240 #define wxCRT_StrtoullA strtoull
241 #endif /* HAVE_STRTOULL */
242 #ifdef HAVE_WCSTOULL
243 /* assume that we have wcstoull(), which is also C99, too */
244 #define wxCRT_StrtollW wcstoll
245 #define wxCRT_StrtoullW wcstoull
246 #endif /* HAVE_WCSTOULL */
247#endif
248
249/*
250 Only VC8 and later provide strnlen() and wcsnlen() functions under Windows
251 and it's also only available starting from Windows CE 6.0 only in CE build.
252 */
253#if wxCHECK_VISUALC_VERSION(8) && (!defined(_WIN32_WCE) || (_WIN32_WCE >= 0x600))
254 #ifndef HAVE_STRNLEN
255 #define HAVE_STRNLEN
256 #endif
257 #ifndef HAVE_WCSNLEN
258 #define HAVE_WCSNLEN
259 #endif
260#endif
261
262#ifdef HAVE_STRNLEN
263 #define wxCRT_StrnlenA strnlen
264#endif
265
266#ifdef HAVE_WCSNLEN
267 #define wxCRT_StrnlenW wcsnlen
268#endif
269
270/* define wxCRT_StricmpA/W and wxCRT_StrnicmpA/W for various compilers */
271
272#if defined(__BORLANDC__) || defined(__WATCOMC__) || \
273 defined(__VISAGECPP__) || \
274 defined(__EMX__) || defined(__DJGPP__)
275 #define wxCRT_StricmpA stricmp
276 #define wxCRT_StrnicmpA strnicmp
277#elif defined(__WXPALMOS__)
278 /* FIXME: There is no equivalent to strnicmp in the Palm OS API. This
279 * quick hack should do until one can be written.
280 */
281 #define wxCRT_StricmpA StrCaselessCompare
282 #define wxCRT_StrnicmpA StrNCaselessCompare
283#elif defined(__SYMANTEC__) || defined(__VISUALC__) || \
284 (defined(__MWERKS__) && defined(__INTEL__))
285 #define wxCRT_StricmpA _stricmp
286 #define wxCRT_StrnicmpA _strnicmp
287#elif defined(__UNIX__) || (defined(__GNUWIN32__) && !defined(__WX_STRICT_ANSI_GCC__))
288 #define wxCRT_StricmpA strcasecmp
289 #define wxCRT_StrnicmpA strncasecmp
290/* #else -- use wxWidgets implementation */
291#endif
292
293#ifdef __VISUALC__
294 #define wxCRT_StricmpW _wcsicmp
295 #define wxCRT_StrnicmpW _wcsnicmp
296#elif defined(__UNIX__)
297 #ifdef HAVE_WCSCASECMP
298 #define wxCRT_StricmpW wcscasecmp
299 #endif
300 #ifdef HAVE_WCSNCASECMP
301 #define wxCRT_StrnicmpW wcsncasecmp
302 #endif
303/* #else -- use wxWidgets implementation */
304#endif
305
306#ifdef HAVE_STRTOK_R
307 #define wxCRT_StrtokA(str, sep, last) strtok_r(str, sep, last)
308#endif
309/* FIXME-UTF8: detect and use wcstok() if available for wxCRT_StrtokW */
310
311/* these are extern "C" because they are used by regex lib: */
312#ifdef __cplusplus
313extern "C" {
314#endif
315
316#ifndef wxCRT_StrlenW
317WXDLLIMPEXP_BASE size_t wxCRT_StrlenW(const wchar_t *s);
318#endif
319
320#ifndef wxCRT_StrncmpW
321WXDLLIMPEXP_BASE int wxCRT_StrncmpW(const wchar_t *s1, const wchar_t *s2, size_t n);
322#endif
323
324#ifdef __cplusplus
325}
326#endif
327
328/* FIXME-UTF8: remove this once we are Unicode only */
329#if wxUSE_UNICODE
330 #define wxCRT_StrlenNative wxCRT_StrlenW
331 #define wxCRT_StrncmpNative wxCRT_StrncmpW
332 #define wxCRT_ToupperNative wxCRT_ToupperW
333 #define wxCRT_TolowerNative wxCRT_TolowerW
334#else
335 #define wxCRT_StrlenNative wxCRT_StrlenA
336 #define wxCRT_StrncmpNative wxCRT_StrncmpA
337 #define wxCRT_ToupperNative toupper
338 #define wxCRT_TolowerNative tolower
339#endif
340
341#ifndef wxCRT_StrcatW
342WXDLLIMPEXP_BASE wchar_t *wxCRT_StrcatW(wchar_t *dest, const wchar_t *src);
343#endif
344
345#ifndef wxCRT_StrchrW
346WXDLLIMPEXP_BASE const wchar_t *wxCRT_StrchrW(const wchar_t *s, wchar_t c);
347#endif
348
349#ifndef wxCRT_StrcmpW
350WXDLLIMPEXP_BASE int wxCRT_StrcmpW(const wchar_t *s1, const wchar_t *s2);
351#endif
352
353#ifndef wxCRT_StrcollW
354WXDLLIMPEXP_BASE int wxCRT_StrcollW(const wchar_t *s1, const wchar_t *s2);
355#endif
356
357#ifndef wxCRT_StrcpyW
358WXDLLIMPEXP_BASE wchar_t *wxCRT_StrcpyW(wchar_t *dest, const wchar_t *src);
359#endif
360
361#ifndef wxCRT_StrcspnW
362WXDLLIMPEXP_BASE size_t wxCRT_StrcspnW(const wchar_t *s, const wchar_t *reject);
363#endif
364
365#ifndef wxCRT_StrncatW
366WXDLLIMPEXP_BASE wchar_t *wxCRT_StrncatW(wchar_t *dest, const wchar_t *src, size_t n);
367#endif
368
369#ifndef wxCRT_StrncpyW
370WXDLLIMPEXP_BASE wchar_t *wxCRT_StrncpyW(wchar_t *dest, const wchar_t *src, size_t n);
371#endif
372
373#ifndef wxCRT_StrpbrkW
374WXDLLIMPEXP_BASE const wchar_t *wxCRT_StrpbrkW(const wchar_t *s, const wchar_t *accept);
375#endif
376
377#ifndef wxCRT_StrrchrW
378WXDLLIMPEXP_BASE const wchar_t *wxCRT_StrrchrW(const wchar_t *s, wchar_t c);
379#endif
380
381#ifndef wxCRT_StrspnW
382WXDLLIMPEXP_BASE size_t wxCRT_StrspnW(const wchar_t *s, const wchar_t *accept);
383#endif
384
385#ifndef wxCRT_StrstrW
386WXDLLIMPEXP_BASE const wchar_t *wxCRT_StrstrW(const wchar_t *haystack, const wchar_t *needle);
387#endif
388
389#ifndef wxCRT_StrtodW
390WXDLLIMPEXP_BASE double wxCRT_StrtodW(const wchar_t *nptr, wchar_t **endptr);
391#endif
392
393#ifndef wxCRT_StrtolW
394WXDLLIMPEXP_BASE long int wxCRT_StrtolW(const wchar_t *nptr, wchar_t **endptr, int base);
395#endif
396
397#ifndef wxCRT_StrtoulW
398WXDLLIMPEXP_BASE unsigned long int wxCRT_StrtoulW(const wchar_t *nptr, wchar_t **endptr, int base);
399#endif
400
401#ifndef wxCRT_StrxfrmW
402WXDLLIMPEXP_BASE size_t wxCRT_StrxfrmW(wchar_t *dest, const wchar_t *src, size_t n);
403#endif
404
405#ifndef wxCRT_StrdupA
406WXDLLIMPEXP_BASE char *wxCRT_StrdupA(const char *psz);
407#endif
408
409#ifndef wxCRT_StrdupW
410WXDLLIMPEXP_BASE wchar_t *wxCRT_StrdupW(const wchar_t *pwz);
411#endif
412
413#ifndef wxCRT_StricmpA
414WXDLLIMPEXP_BASE int wxCRT_StricmpA(const char *psz1, const char *psz2);
415#endif
416
417#ifndef wxCRT_StricmpW
418WXDLLIMPEXP_BASE int wxCRT_StricmpW(const wchar_t *psz1, const wchar_t *psz2);
419#endif
420
421#ifndef wxCRT_StrnicmpA
422WXDLLIMPEXP_BASE int wxCRT_StrnicmpA(const char *psz1, const char *psz2, size_t len);
423#endif
424
425#ifndef wxCRT_StrnicmpW
426WXDLLIMPEXP_BASE int wxCRT_StrnicmpW(const wchar_t *psz1, const wchar_t *psz2, size_t len);
427#endif
428
429#ifndef wxCRT_StrtokA
430WXDLLIMPEXP_BASE char *wxCRT_StrtokA(char *psz, const char *delim, char **save_ptr);
431#endif
432
433#ifndef wxCRT_StrtokW
434WXDLLIMPEXP_BASE wchar_t *wxCRT_StrtokW(wchar_t *psz, const wchar_t *delim, wchar_t **save_ptr);
435#endif
436
437/* supply strtoll and strtoull, if needed */
438#ifdef wxLongLong_t
439 #ifndef wxCRT_StrtollA
440 WXDLLIMPEXP_BASE wxLongLong_t wxCRT_StrtollA(const char* nptr,
441 char** endptr,
442 int base);
443 WXDLLIMPEXP_BASE wxULongLong_t wxCRT_StrtoullA(const char* nptr,
444 char** endptr,
445 int base);
446 #endif
447 #ifndef wxCRT_StrtollW
448 WXDLLIMPEXP_BASE wxLongLong_t wxCRT_StrtollW(const wchar_t* nptr,
449 wchar_t** endptr,
450 int base);
451 WXDLLIMPEXP_BASE wxULongLong_t wxCRT_StrtoullW(const wchar_t* nptr,
452 wchar_t** endptr,
453 int base);
454 #endif
455#endif /* wxLongLong_t */
456
457
458/* -------------------------------------------------------------------------
459 stdio.h
460 ------------------------------------------------------------------------- */
461
462#if defined(__UNIX__) || defined(__WXMAC__) || defined(__WXPALMOS__)
463 #define wxMBFILES 1
464#else
465 #define wxMBFILES 0
466#endif
467
468
469/* these functions are only needed in the form used for filenames (i.e. char*
470 on Unix, wchar_t* on Windows), so we don't need to use A/W suffix: */
471#if wxMBFILES || !wxUSE_UNICODE /* ANSI filenames */
472
473 #define wxCRT_Fopen fopen
474 #define wxCRT_Freopen freopen
475 #define wxCRT_Remove remove
476 #define wxCRT_Rename rename
477
478#else /* Unicode filenames */
479 /* special case: these functions are missing under Win9x with Unicows so we
480 have to implement them ourselves */
481 #if wxUSE_UNICODE_MSLU || defined(__WX_STRICT_ANSI_GCC__)
482 WXDLLIMPEXP_BASE FILE* wxMSLU__wfopen(const wchar_t *name, const wchar_t *mode);
483 WXDLLIMPEXP_BASE FILE* wxMSLU__wfreopen(const wchar_t *name, const wchar_t *mode, FILE *stream);
484 WXDLLIMPEXP_BASE int wxMSLU__wrename(const wchar_t *oldname, const wchar_t *newname);
485 WXDLLIMPEXP_BASE int wxMSLU__wremove(const wchar_t *name);
486 #define wxCRT_Fopen wxMSLU__wfopen
487 #define wxCRT_Freopen wxMSLU__wfreopen
488 #define wxCRT_Remove wxMSLU__wremove
489 #define wxCRT_Rename wxMSLU__wrename
490 #else
491 /* WinCE CRT doesn't provide these functions so use our own */
492 #ifdef __WXWINCE__
493 WXDLLIMPEXP_BASE int wxCRT_Rename(const wchar_t *src,
494 const wchar_t *dst);
495 WXDLLIMPEXP_BASE int wxCRT_Remove(const wchar_t *path);
496 #else
497 #define wxCRT_Rename _wrename
498 #define wxCRT_Remove _wremove
499 #endif
500 #define wxCRT_Fopen _wfopen
501 #define wxCRT_Freopen _wfreopen
502 #endif
503
504#endif /* wxMBFILES/!wxMBFILES */
505
506#define wxCRT_PutsA puts
507#define wxCRT_FputsA fputs
508#define wxCRT_FgetsA fgets
509#define wxCRT_FputcA fputc
510#define wxCRT_FgetcA fgetc
511#define wxCRT_UngetcA ungetc
512
513#ifdef wxHAVE_TCHAR_SUPPORT
514 #define wxCRT_PutsW _putws
515 #define wxCRT_FputsW fputws
516 #define wxCRT_FputcW fputwc
517#endif
518#ifdef HAVE_FPUTWS
519 #define wxCRT_FputsW fputws
520#endif
521#ifdef HAVE_PUTWS
522 #define wxCRT_PutsW putws
523#endif
524#ifdef HAVE_FPUTWC
525 #define wxCRT_FputcW fputwc
526#endif
527#define wxCRT_FgetsW fgetws
528
529#ifndef wxCRT_PutsW
530WXDLLIMPEXP_BASE int wxCRT_PutsW(const wchar_t *ws);
531#endif
532
533#ifndef wxCRT_FputsW
534WXDLLIMPEXP_BASE int wxCRT_FputsW(const wchar_t *ch, FILE *stream);
535#endif
536
537#ifndef wxCRT_FputcW
538WXDLLIMPEXP_BASE int wxCRT_FputcW(wchar_t wc, FILE *stream);
539#endif
540
541/*
542 NB: tmpnam() is unsafe and thus is not wrapped!
543 Use other wxWidgets facilities instead:
544 wxFileName::CreateTempFileName, wxTempFile, or wxTempFileOutputStream
545*/
546#define wxTmpnam(x) wxTmpnam_is_insecure_use_wxTempFile_instead
547
548/* FIXME-CE: provide our own perror() using ::GetLastError() */
549#ifndef __WXWINCE__
550
551#define wxCRT_PerrorA perror
552#ifdef wxHAVE_TCHAR_SUPPORT
553 #define wxCRT_PerrorW _wperror
554#endif
555
556#endif /* !__WXWINCE__ */
557
558/* -------------------------------------------------------------------------
559 stdlib.h
560 ------------------------------------------------------------------------- */
561
562/* there are no env vars at all under CE, so no _tgetenv neither */
563#ifdef __WXWINCE__
564 /* can't define as inline function as this is a C file... */
565 #define wxCRT_GetenvA(name) (name, NULL)
566 #define wxCRT_GetenvW(name) (name, NULL)
567#else
568 #define wxCRT_GetenvA getenv
569 #ifdef _tgetenv
570 #define wxCRT_GetenvW _wgetenv
571 #endif
572#endif
573
574#ifndef wxCRT_GetenvW
575WXDLLIMPEXP_BASE wchar_t * wxCRT_GetenvW(const wchar_t *name);
576#endif
577
578
579#define wxCRT_SystemA system
580/* mingw32 doesn't provide _tsystem() or _wsystem(): */
581#if defined(_tsystem)
582 #define wxCRT_SystemW _wsystem
583#endif
584
585#define wxCRT_AtofA atof
586#define wxCRT_AtoiA atoi
587#define wxCRT_AtolA atol
588
589#if defined(__MWERKS__)
590 #if defined(__MSL__)
591 #define wxCRT_AtofW watof
592 #define wxCRT_AtoiW watoi
593 #define wxCRT_AtolW watol
594 /* else: use ANSI versions */
595 #endif
596#elif defined(wxHAVE_TCHAR_SUPPORT) && !defined(__WX_STRICT_ANSI_GCC__)
597 #define wxCRT_AtoiW _wtoi
598 #define wxCRT_AtolW _wtol
599 /* _wtof doesn't exist */
600#else
601#ifndef __VMS
602 #define wxCRT_AtofW(s) wcstod(s, NULL)
603#endif
604 #define wxCRT_AtolW(s) wcstol(s, NULL, 10)
605 /* wcstoi doesn't exist */
606#endif
607
608/*
609 There are 2 unrelated problems with these functions under Mac:
610 a) Metrowerks MSL CRT implements them strictly in C99 sense and
611 doesn't support (very common) extension of allowing to call
612 mbstowcs(NULL, ...) which makes it pretty useless as you can't
613 know the size of the needed buffer
614 b) OS X <= 10.2 declares and even defined these functions but
615 doesn't really implement them -- they always return an error
616
617 So use our own replacements in both cases.
618 */
619#if defined(__MWERKS__) && defined(__MSL__)
620 #define wxNEED_WX_MBSTOWCS
621#endif
622#if defined(__WXPALMOS__)
623 #define wxNEED_WX_MBSTOWCS
624#endif
625
626#ifdef __DARWIN__
627 #if !defined(__WXOSX_IPHONE__) && MAC_OS_X_VERSION_MAX_ALLOWED <= MAC_OS_X_VERSION_10_2
628 #define wxNEED_WX_MBSTOWCS
629 #endif
630#endif
631
632#ifdef wxNEED_WX_MBSTOWCS
633 /* even though they are defined and "implemented", they are bad and just
634 stubs so we need our own - we need these even in ANSI builds!! */
635 WXDLLIMPEXP_BASE size_t wxMbstowcs(wchar_t *, const char *, size_t);
636 WXDLLIMPEXP_BASE size_t wxWcstombs(char *, const wchar_t *, size_t);
637#else
638 #define wxMbstowcs mbstowcs
639 #define wxWcstombs wcstombs
640#endif
641
642
643
644/* -------------------------------------------------------------------------
645 time.h
646 ------------------------------------------------------------------------- */
647
648#define wxCRT_StrftimeA strftime
649#ifdef __SGI__
650 /*
651 IRIX provides not one but two versions of wcsftime(): XPG4 one which
652 uses "const char*" for the third parameter and so can't be used and the
653 correct, XPG5, one. Unfortunately we can't just define _XOPEN_SOURCE
654 high enough to get XPG5 version as this undefines other symbols which
655 make other functions we use unavailable (see <standards.h> for gory
656 details). So just declare the XPG5 version ourselves, we're extremely
657 unlikely to ever be compiled on a system without it. But if we ever do,
658 a configure test would need to be added for it (and _MIPS_SYMBOL_PRESENT
659 should be used to check for its presence during run-time, i.e. it would
660 probably be simpler to just always use our own wxCRT_StrftimeW() below
661 if it does ever become a problem).
662 */
663#ifdef __cplusplus
664 extern "C"
665#endif
666 size_t
667 _xpg5_wcsftime(wchar_t *, size_t, const wchar_t *, const struct tm * );
668 #define wxCRT_StrftimeW _xpg5_wcsftime
669#else
670 /*
671 Assume it's always available under non-Unix systems with the
672 exception of Palm OS, this does seem to be the case for now. And
673 under Unix we trust configure to detect it (except for SGI special
674 case above).
675 */
676 #if defined(HAVE_WCSFTIME) || \
677 !(defined(__UNIX__) || defined(__WXPALMOS__))
678 #define wxCRT_StrftimeW wcsftime
679 #endif /* ! __WXPALMOS__ */
680#endif
681
682#ifndef wxCRT_StrftimeW
683WXDLLIMPEXP_BASE size_t wxCRT_StrftimeW(wchar_t *s, size_t max,
684 const wchar_t *fmt,
685 const struct tm *tm);
686#endif
687
688
689
690/* -------------------------------------------------------------------------
691 ctype.h
692 ------------------------------------------------------------------------- */
693
694#ifdef __WATCOMC__
695 #define WXWCHAR_T_CAST(c) (wint_t)(c)
696#else
697 #define WXWCHAR_T_CAST(c) c
698#endif
699
700#define wxCRT_IsalnumW(c) iswalnum(WXWCHAR_T_CAST(c))
701#define wxCRT_IsalphaW(c) iswalpha(WXWCHAR_T_CAST(c))
702#define wxCRT_IscntrlW(c) iswcntrl(WXWCHAR_T_CAST(c))
703#define wxCRT_IsdigitW(c) iswdigit(WXWCHAR_T_CAST(c))
704#define wxCRT_IsgraphW(c) iswgraph(WXWCHAR_T_CAST(c))
705#define wxCRT_IslowerW(c) iswlower(WXWCHAR_T_CAST(c))
706#define wxCRT_IsprintW(c) iswprint(WXWCHAR_T_CAST(c))
707#define wxCRT_IspunctW(c) iswpunct(WXWCHAR_T_CAST(c))
708#define wxCRT_IsspaceW(c) iswspace(WXWCHAR_T_CAST(c))
709#define wxCRT_IsupperW(c) iswupper(WXWCHAR_T_CAST(c))
710#define wxCRT_IsxdigitW(c) iswxdigit(WXWCHAR_T_CAST(c))
711
712#ifdef __GLIBC__
713 #if defined(__GLIBC__) && (__GLIBC__ == 2) && (__GLIBC_MINOR__ == 0)
714 /* /usr/include/wctype.h incorrectly declares translations */
715 /* tables which provokes tons of compile-time warnings -- try */
716 /* to correct this */
717 #define wxCRT_TolowerW(wc) towctrans((wc), (wctrans_t)__ctype_tolower)
718 #define wxCRT_ToupperW(wc) towctrans((wc), (wctrans_t)__ctype_toupper)
719 #else /* !glibc 2.0 */
720 #define wxCRT_TolowerW towlower
721 #define wxCRT_ToupperW towupper
722 #endif
723#else /* !__GLIBC__ */
724 /* There is a bug in VC6 C RTL: toxxx() functions dosn't do anything
725 with signed chars < 0, so "fix" it here. */
726 #define wxCRT_TolowerW(c) towlower((wxUChar)(wxChar)(c))
727 #define wxCRT_ToupperW(c) towupper((wxUChar)(wxChar)(c))
728#endif /* __GLIBC__/!__GLIBC__ */
729
730
731
732
733
734/* -------------------------------------------------------------------------
735 wx wrappers for CRT functions in both char* and wchar_t* versions
736 ------------------------------------------------------------------------- */
737
738#ifdef __cplusplus
739
740/* NB: this belongs to wxcrt.h and not this header, but it makes life easier
741 * for buffer.h and stringimpl.h (both of which must be included before
742 * string.h, which is required by wxcrt.h) to have them here: */
743
744/* safe version of strlen() (returns 0 if passed NULL pointer) */
745inline size_t wxStrlen(const char *s) { return s ? wxCRT_StrlenA(s) : 0; }
746inline size_t wxStrlen(const wchar_t *s) { return s ? wxCRT_StrlenW(s) : 0; }
747#ifndef wxWCHAR_T_IS_WXCHAR16
748 WXDLLIMPEXP_BASE size_t wxStrlen(const wxChar16 *s );
749#endif
750#ifndef wxWCHAR_T_IS_WXCHAR32
751 WXDLLIMPEXP_BASE size_t wxStrlen(const wxChar32 *s );
752#endif
753#define wxWcslen wxCRT_StrlenW
754
755#define wxStrdupA wxCRT_StrdupA
756#define wxStrdupW wxCRT_StrdupW
757inline char* wxStrdup(const char *s) { return wxCRT_StrdupA(s); }
758inline wchar_t* wxStrdup(const wchar_t *s) { return wxCRT_StrdupW(s); }
759#ifndef wxWCHAR_T_IS_WXCHAR16
760 WXDLLIMPEXP_BASE wxChar16* wxStrdup(const wxChar16* s);
761#endif
762#ifndef wxWCHAR_T_IS_WXCHAR32
763 WXDLLIMPEXP_BASE wxChar32* wxStrdup(const wxChar32* s);
764#endif
765
766#endif /* __cplusplus */
767
768#endif /* _WX_WXCRTBASE_H_ */
wxWidgets (Impactor)