include/wx/wxcrtbase.h

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