include/wx/wxchar.h

   1 /*
   2  * Name:        wx/wxchar.h
   3  * Purpose:     Declarations common to wx char/wchar_t usage (wide chars)
   4  * Author:      Joel Farley, Ove Kåven
   5  * Modified by: Vadim Zeitlin, Robert Roebling, Ron Lee
   6  * Created:     1998/06/12
   7  * RCS-ID:      $Id$
   8  * Copyright:   (c) 1998-2002 Joel Farley, Ove Kåven, Robert Roebling, Ron Lee
   9  * Licence:     wxWindows licence
  10  */
  11
  12 /* THIS IS A C FILE, DON'T USE C++ FEATURES (IN PARTICULAR COMMENTS) IN IT */
  13
  14 #ifndef _WX_WXCHAR_H_
  15 #define _WX_WXCHAR_H_
  16
  17 #if defined(__GNUG__) && !defined(NO_GCC_PRAGMA)
  18     #pragma interface "wxchar.h"
  19 #endif
  20
  21 #include "wx/defs.h"        /* for wxUSE_UNICODE */
  22
  23 #if defined(HAVE_STRTOK_R) && defined(__DARWIN__) && defined(_MSL_USING_MW_C_HEADERS) && _MSL_USING_MW_C_HEADERS
  24     char        *strtok_r(char *, const char *, char **);
  25 #endif
  26
  27 /* check whether we have wchar_t and which size it is if we do */
  28 #if !defined(wxUSE_WCHAR_T)
  29     #if defined(__UNIX__)
  30         #if defined(HAVE_WCSTR_H) || defined(HAVE_WCHAR_H) || defined(__FreeBSD__) || defined(__DARWIN__)
  31             #define wxUSE_WCHAR_T 1
  32         #else
  33             #define wxUSE_WCHAR_T 0
  34         #endif
  35     #elif defined(__GNUWIN32__) && !defined(__MINGW32__)
  36         #define wxUSE_WCHAR_T 0
  37     #elif defined(__WATCOMC__)
  38         #define wxUSE_WCHAR_T 0
  39     #elif defined(__VISAGECPP__) && (__IBMCPP__ < 400)
  40         #define wxUSE_WCHAR_T 0
  41     #else
  42         /* add additional compiler checks if this fails */
  43         #define wxUSE_WCHAR_T 1
  44     #endif
  45 #endif /* !defined(wxUSE_WCHAR_T) */
  46
  47 /* Unicode support requires wchar_t */
  48 #if wxUSE_UNICODE && !wxUSE_WCHAR_T
  49     #error "wchar_t must be available in Unicode build"
  50 #endif /* Unicode */
  51
  52 /*
  53     Standard headers we need here.
  54
  55     NB: don't include any wxWidgets headers here because almost of them include
  56         this one!
  57  */
  58
  59 /* Required for wxPrintf() etc */
  60 #include <stdarg.h>
  61
  62 /* Almost all compiler have strdup(), but not quite all: CodeWarrior under Mac */
  63 /* and VC++ for Windows CE don't provide it */
  64 #if !(defined(__MWERKS__) && defined(__WXMAC__)) && !defined(__WXWINCE__)
  65     /* use #define, not inline wrapper, as it is tested with #ifndef below */
  66     #define wxStrdupA strdup
  67 #endif
  68
  69 /*
  70    non Unix compilers which do have wchar.h (but not tchar.h which is included
  71    below and which includes wchar.h anyhow).
  72
  73    Actually MinGW has tchar.h, but it does not include wchar.h
  74  */
  75 #if defined(__MWERKS__) || defined(__VISAGECPP__) || defined(__MINGW32__) || defined(__WATCOMC__)
  76     #ifndef HAVE_WCHAR_H
  77         #define HAVE_WCHAR_H
  78     #endif
  79 #endif
  80 #if defined(__MWERKS__) && !defined(__MACH__)
  81     #ifndef HAVE_WCSLEN
  82         #define HAVE_WCSLEN
  83     #endif
  84 #endif
  85
  86 #if wxUSE_WCHAR_T
  87     #ifdef HAVE_WCHAR_H
  88         /* the current (as of Nov 2002) version of cygwin has a bug in its */
  89         /* wchar.h -- there is no extern "C" around the declarations in it and */
  90         /* this results in linking errors later; also, at least on some */
  91         /* Cygwin versions, wchar.h requires sys/types.h */
  92         #ifdef __CYGWIN__
  93             #include <sys/types.h>
  94             #ifdef __cplusplus
  95                 extern "C" {
  96             #endif
  97         #endif /* Cygwin */
  98
  99         #include <wchar.h>
 100
 101         #if defined(__CYGWIN__) && defined(__cplusplus)
 102             }
 103         #endif /* Cygwin and C++ */
 104
 105     #elif defined(HAVE_WCSTR_H)
 106         /* old compilers have relevant declarations here */
 107         #include <wcstr.h>
 108     #elif defined(__FreeBSD__) || defined(__DARWIN__) || defined(__EMX__)
 109         /* include stdlib.h for wchar_t */
 110         #include <stdlib.h>
 111     #endif /* HAVE_WCHAR_H */
 112 #endif /* wxUSE_WCHAR_T */
 113
 114 /* ---------------------------------------------------------------------------- */
 115 /* define wxHAVE_TCHAR_SUPPORT for the compilers which support the TCHAR type */
 116 /* mapped to either char or wchar_t depending on the ASCII/Unicode mode and have */
 117 /* the function mapping _tfoo() -> foo() or wfoo() */
 118 /* ---------------------------------------------------------------------------- */
 119
 120 /* VC++ and BC++ starting with 5.2 have TCHAR support */
 121 #ifdef __VISUALC__
 122     #define wxHAVE_TCHAR_SUPPORT
 123 #elif defined(__BORLANDC__) && (__BORLANDC__ >= 0x520)
 124     #define wxHAVE_TCHAR_SUPPORT
 125     #include <ctype.h>
 126 #elif defined(__WATCOMC__)
 127     #define wxHAVE_TCHAR_SUPPORT
 128 #elif defined(__DMC__)
 129     #define wxHAVE_TCHAR_SUPPORT
 130 #elif defined(__MINGW32__) && wxCHECK_W32API_VERSION( 1, 0 ) && !defined(__WXPALMOS__)
 131     #define wxHAVE_TCHAR_SUPPORT
 132     #include <stddef.h>
 133     #include <string.h>
 134     #include <ctype.h>
 135 #elif 0 && defined(__VISAGECPP__) && (__IBMCPP__ >= 400)
 136     /* VZ: the old VisualAge definitions were completely wrong and had no */
 137     /*     chance at all to work in Unicode build anyhow so let's pretend that */
 138     /*     VisualAge does _not_ support TCHAR for the moment (as indicated by */
 139     /*     "0 &&" above) until someone really has time to delve into Unicode */
 140     /*     issues under OS/2 */
 141
 142     /* VisualAge 4.0+ supports TCHAR */
 143     #define wxHAVE_TCHAR_SUPPORT
 144 #endif /* compilers with (good) TCHAR support */
 145
 146 #ifdef __MWERKS__
 147     #define HAVE_WPRINTF
 148 #endif
 149
 150 #ifdef wxHAVE_TCHAR_SUPPORT
 151     /* get TCHAR definition if we've got it */
 152     #include <tchar.h>
 153
 154     /* we surely do have wchar_t if we have TCHAR */
 155     #ifndef wxUSE_WCHAR_T
 156         #define wxUSE_WCHAR_T 1
 157     #endif /* !defined(wxUSE_WCHAR_T) */
 158
 159     /* and we also do have wcslen() */
 160     #ifndef HAVE_WCSLEN
 161         #define HAVE_WCSLEN
 162     #endif
 163 #endif /* wxHAVE_TCHAR_SUPPORT */
 164
 165 /* ---------------------------------------------------------------------------- */
 166 /* define wxChar type */
 167 /* ---------------------------------------------------------------------------- */
 168
 169 /* TODO: define wxCharInt to be equal to either int or wint_t? */
 170
 171 #if !wxUSE_UNICODE
 172     typedef char wxChar;
 173     typedef signed char wxSChar;
 174     typedef unsigned char wxUChar;
 175 #else /* Unicode */
 176     /* VZ: note that VC++ defines _T[SU]CHAR simply as wchar_t and not as */
 177     /*     signed/unsigned version of it which (a) makes sense to me (unlike */
 178     /*     char wchar_t is always unsigned) and (b) was how the previous */
 179     /*     definitions worked so keep it like this */
 180
 181     /* GNU libc has __WCHAR_TYPE__ which requires special treatment, see */
 182     /* comment below */
 183     #if !defined(__WCHAR_TYPE__) || \
 184         (!defined(__GNUC__) || wxCHECK_GCC_VERSION(2, 96))
 185         /* standard case */
 186         typedef wchar_t wxChar;
 187         typedef wchar_t wxSChar;
 188         typedef wchar_t wxUChar;
 189     #else /* __WCHAR_TYPE__ and gcc < 2.96 */
 190         /* VS: wxWidgets used to define wxChar as __WCHAR_TYPE__ here. However, */
 191         /*     this doesn't work with new GCC 3.x compilers because wchar_t is */
 192         /*     C++'s builtin type in the new standard. OTOH, old compilers (GCC */
 193         /*     2.x) won't accept new definition of wx{S,U}Char, therefore we */
 194         /*     have to define wxChar conditionally depending on detected */
 195         /*     compiler & compiler version. */
 196         /*     with old definition of wxChar. */
 197         typedef __WCHAR_TYPE__ wxChar;
 198         typedef __WCHAR_TYPE__ wxSChar;
 199         typedef __WCHAR_TYPE__ wxUChar;
 200     #endif /* __WCHAR_TYPE__ */
 201 #endif /* ASCII/Unicode */
 202
 203 /* ---------------------------------------------------------------------------- */
 204 /* define _T() and related macros */
 205 /* ---------------------------------------------------------------------------- */
 206
 207 /* BSD systems define _T() to be something different in ctype.h, override it */
 208 #if defined(__FreeBSD__) || defined(__DARWIN__)
 209     #include <ctype.h>
 210     #undef _T
 211 #endif
 212
 213 /* could already be defined by tchar.h (it's quasi standard) */
 214 #ifndef _T
 215     #if !wxUSE_UNICODE
 216         #define _T(x) x
 217     #else /* Unicode */
 218         #define _T(x) L ## x
 219     #endif /* ASCII/Unicode */
 220 #endif /* !defined(_T) */
 221
 222 /* although global macros with such names are normally bad, we want to have */
 223 /* another name for _T() which should be used to avoid confusion between _T() */
 224 /* and _() in wxWidgets sources */
 225 #define wxT(x)       _T(x)
 226
 227 /* Unicode-friendly __FILE__, __DATE__ and __TIME__ analogs */
 228 #ifndef __TFILE__
 229     #define __XFILE__(x) wxT(x)
 230     #define __TFILE__ __XFILE__(__FILE__)
 231 #endif
 232
 233 #ifndef __TDATE__
 234     #define __XDATE__(x) wxT(x)
 235     #define __TDATE__ __XDATE__(__DATE__)
 236 #endif
 237
 238 #ifndef __TTIME__
 239     #define __XTIME__(x) wxT(x)
 240     #define __TTIME__ __XTIME__(__TIME__)
 241 #endif
 242
 243 /*
 244     define wxFoo() function for each standard foo() function whose signature
 245     (exceptionally including the return type) includes any mention of char:
 246     wxFoo() is going to be a Unicode-friendly version of foo(), i.e. will have
 247     the same signature but with char replaced by wxChar which allows us to use
 248     it in Unicode build as well
 249  */
 250
 251 #ifdef wxHAVE_TCHAR_SUPPORT
 252     #include <ctype.h>
 253
 254     #if defined(__WATCOMC__) && defined(UNICODE)
 255       #define WXWCHAR_T_CAST(c) (wint_t)(c)
 256     #else
 257       #define WXWCHAR_T_CAST(c) c
 258     #endif
 259
 260     /* ctype.h functions */
 261     #define  wxIsalnum(c)   _istalnum(WXWCHAR_T_CAST(c))
 262     #define  wxIsalpha(c)   _istalpha(WXWCHAR_T_CAST(c))
 263     #define  wxIscntrl(c)   _istcntrl(WXWCHAR_T_CAST(c))
 264     #define  wxIsdigit(c)   _istdigit(WXWCHAR_T_CAST(c))
 265     #define  wxIsgraph(c)   _istgraph(WXWCHAR_T_CAST(c))
 266     #define  wxIslower(c)   _istlower(WXWCHAR_T_CAST(c))
 267     #define  wxIsprint(c)   _istprint(WXWCHAR_T_CAST(c))
 268     #define  wxIspunct(c)   _istpunct(WXWCHAR_T_CAST(c))
 269     #define  wxIsspace(c)   _istspace(WXWCHAR_T_CAST(c))
 270     #define  wxIsupper(c)   _istupper(WXWCHAR_T_CAST(c))
 271     #define  wxIsxdigit(c)  _istxdigit(WXWCHAR_T_CAST(c))
 272
 273     /*
 274        There is a bug in VC6 C RTL: toxxx() functions dosn't do anything with
 275        signed chars < 0, so "fix" it here.
 276      */
 277     #define  wxTolower(c) _totlower((wxUChar)(c))
 278     #define  wxToupper(c) _totupper((wxUChar)(c))
 279
 280     /* locale.h functons */
 281     #define  wxSetlocale _tsetlocale
 282
 283     /* string.h functions */
 284     #define  wxStrcat    _tcscat
 285     #define  wxStrchr    _tcschr
 286     #define  wxStrcmp    _tcscmp
 287     #define  wxStrcoll   _tcscoll
 288     #define  wxStrcpy    _tcscpy
 289     #define  wxStrcspn   _tcscspn
 290     #define  wxStrdupW   _wcsdup        /* notice the 'W'! */
 291     #define  wxStrftime  _tcsftime
 292     #define  wxStricmp   _tcsicmp
 293     #define  wxStrnicmp  _tcsnicmp
 294     #define  wxStrlen_   _tcslen        /* used in wxStrlen inline function */
 295     #define  wxStrncat   _tcsncat
 296     #define  wxStrncmp   _tcsncmp
 297     #define  wxStrncpy   _tcsncpy
 298     #define  wxStrpbrk   _tcspbrk
 299     #define  wxStrrchr   _tcsrchr
 300     #define  wxStrspn    _tcsspn
 301     #define  wxStrstr    _tcsstr
 302     #define  wxStrtod    _tcstod
 303     #define  wxStrtol    _tcstol
 304     #define  wxStrtoul   _tcstoul
 305     #define  wxStrxfrm   _tcsxfrm
 306
 307     /* stdio.h functions */
 308     #define  wxFgetc     _fgettc
 309     #define  wxFgetchar  _fgettchar
 310     #define  wxFgets     _fgetts
 311     #if wxUSE_UNICODE_MSLU
 312         #define  wxFopen    wxMSLU__tfopen
 313     #else
 314         #define  wxFopen     _tfopen
 315     #endif
 316     #define  wxFputc     _fputtc
 317     #define  wxFputchar  _fputtchar
 318     #define  wxFprintf   _ftprintf
 319     #define  wxFputs     _fputts
 320     #define  wxFreopen   _tfreopen
 321     #define  wxFscanf    _ftscanf
 322     #define  wxGetc      _gettc
 323     #define  wxGetchar   _gettchar
 324     #define  wxGets      _getts
 325     #define  wxPerror    _tperror
 326     #define  wxPrintf    _tprintf
 327     #define  wxPutc(c,f) _puttc(WXWCHAR_T_CAST(c),f)
 328     #define  wxPutchar   _puttchar
 329     #define  wxPuts      _putts
 330     #define  wxScanf     _tscanf
 331     #if defined(__DMC__)
 332         #if wxUSE_UNICODE
 333             /* Digital Mars adds count to _stprintf (C99) so prototype conversion see wxchar.cpp */
 334             int wxSprintf (wchar_t * __RESTRICT s, const wchar_t * __RESTRICT format, ... ) ;
 335         #else
 336             /* and there is a bug in D Mars tchar.h prior to 8.39.4n, so define as sprintf */
 337             #define wxSprintf sprintf
 338         #endif
 339     #else
 340         #define  wxSprintf   _stprintf
 341     #endif
 342
 343     #define  wxSscanf    _stscanf
 344     #define  wxTmpnam    _ttmpnam
 345     #define  wxUngetc    _tungetc
 346     #define  wxVfprintf  _vftprintf
 347     #define  wxVprintf   _vtprintf
 348     #define  wxVsscanf   _vstscanf
 349     #define  wxVsprintf  _vstprintf
 350
 351     /* special case: not all TCHAR-aware compilers have those */
 352     #if defined(__VISUALC__) || \
 353             (defined(__BORLANDC__) && __BORLANDC__ >= 0x540)
 354         #define wxVsnprintf_    _vsntprintf
 355         #define wxSnprintf_     _sntprintf
 356     #endif
 357
 358     /* special case: these functions are missing under Win9x with Unicows so we */
 359     /* have to implement them ourselves */
 360     #if wxUSE_UNICODE_MSLU
 361         #define  wxRemove    wxMSLU__tremove
 362         #define  wxRename    wxMSLU__trename
 363     #else
 364         #ifdef __WXWINCE__
 365             /* carefully: wxRemove() must return 0 on success while DeleteFile()
 366                returns 0 on error, so don't just define one as the other */
 367             inline int wxRemove(const wxChar *path)
 368             {
 369                 return ::DeleteFile(path) == 0;
 370             }
 371         #else
 372             #define  wxRemove    _tremove
 373             #define  wxRename    _trename
 374         #endif
 375     #endif
 376
 377     /* stdlib.h functions */
 378     #define  wxAtoi      _ttoi
 379     #define  wxAtol      _ttol
 380     /* #define  wxAtof   _tttof -- notice that there is no such thing (why?) */
 381     /* there are no env vars at all under CE, so no _tgetenv neither */
 382     #ifdef __WXWINCE__
 383         /* can't define as inline function as this is a C file... */
 384         #define wxGetenv(name)  ((wxChar *)NULL)
 385     #else
 386         #define  wxGetenv    _tgetenv
 387     #endif
 388     #define  wxSystem    _tsystem
 389
 390     /* time.h functions */
 391     #define  wxAsctime   _tasctime
 392     #define  wxCtime     _tctime
 393
 394     #define wxMbstowcs mbstowcs
 395     #define wxWcstombs wcstombs
 396 #else /* !TCHAR-aware compilers */
 397
 398     #if !defined(__MWERKS__) && defined(__DARWIN__) && ( MAC_OS_X_VERSION_MAX_ALLOWED <= MAC_OS_X_VERSION_10_2 )
 399         /* even though they are defined and "implemented", they are bad and just
 400            stubs so we need our own - we need these even in ANSI builds!! */
 401         WXDLLIMPEXP_BASE size_t wxMbstowcs (wchar_t *, const char *, size_t);
 402         WXDLLIMPEXP_BASE size_t wxWcstombs (char *, const wchar_t *, size_t);
 403     #else
 404         #define wxMbstowcs mbstowcs
 405         #define wxWcstombs wcstombs
 406     #endif
 407
 408     /* No UNICODE in the c library except wchar_t typedef on mac OSX 10.2 and less - roll our own */
 409     #if !defined(__MWERKS__) && wxUSE_UNICODE && defined(__DARWIN__) && ( MAC_OS_X_VERSION_MAX_ALLOWED <= MAC_OS_X_VERSION_10_2 )
 410
 411         /* we need everything! */
 412         #define wxNEED_WX_STRING_H
 413         #define wxNEED_WX_CTYPE_H
 414
 415         #define  wxFgetchar(c)  wxFgetc(c, stdin)
 416         #define  wxFputc     wxPutc
 417         #define  wxFputchar(c)  wxPutc(c, stdout)
 418         #define  wxGetc      wxFgetc
 419         #define  wxGetchar(c)   wxFgetc(c, stdin)
 420
 421         #include <stdio.h>
 422
 423         #define wxNEED_FGETC
 424         #define wxNEED_FGETS
 425         #define wxNEED_GETS
 426         #define wxNEED_UNGETC
 427
 428         #define wxNEED_FPUTS
 429         #define wxNEED_PUTS
 430         #define wxNEED_PUTC
 431
 432         int wxFputs(const wxChar *ch, FILE *stream);
 433         int wxPuts(const wxChar *ws);
 434         int wxPutc(wxChar ch, FILE *stream);
 435
 436         #ifdef __cplusplus
 437         extern "C" {
 438         #endif
 439             WXDLLIMPEXP_BASE size_t   wxStrlen_(const wxChar *s);
 440         #ifdef __cplusplus
 441         }
 442         #endif
 443
 444         #define wxPutchar(wch) wxPutc(wch, stdout)
 445
 446         #define wxNEED_PRINTF_CONVERSION
 447         #define wxNEED_WX_STDIO_H
 448         #define wxNEED_WX_STDLIB_H
 449         #define wxNEED_WX_TIME_H
 450
 451     #elif wxUSE_UNICODE
 452         #include <wctype.h>
 453
 454         /* this is probably glibc-specific */
 455         #if defined(__WCHAR_TYPE__) && !defined(__MWERKS__)
 456             /* ctype.h functions (wctype.h) */
 457             #define  wxIsalnum   iswalnum
 458             #define  wxIsalpha   iswalpha
 459             #define  wxIscntrl   iswcntrl
 460             #define  wxIsdigit   iswdigit
 461             #define  wxIsgraph   iswgraph
 462             #define  wxIslower   iswlower
 463             #define  wxIsprint   iswprint
 464             #define  wxIspunct   iswpunct
 465             #define  wxIsspace   iswspace
 466             #define  wxIsupper   iswupper
 467             #define  wxIsxdigit  iswxdigit
 468
 469             #if defined(__GLIBC__) && (__GLIBC__ == 2) && (__GLIBC_MINOR__ == 0)
 470                 /* /usr/include/wctype.h incorrectly declares translations */
 471                 /* tables which provokes tons of compile-time warnings -- try */
 472                 /* to correct this */
 473                 #define  wxTolower(wc)   towctrans((wc), (wctrans_t)__ctype_tolower)
 474                 #define  wxToupper(wc)   towctrans((wc), (wctrans_t)__ctype_toupper)
 475             #else /* !glibc 2.0 */
 476                 #define  wxTolower   towlower
 477                 #define  wxToupper   towupper
 478             #endif /* gcc/!gcc */
 479
 480             /* string.h functions (wchar.h) */
 481             #define  wxStrcat    wcscat
 482             #define  wxStrchr    wcschr
 483             #define  wxStrcmp    wcscmp
 484             #define  wxStrcoll   wcscoll
 485             #define  wxStrcpy    wcscpy
 486             #define  wxStrcspn   wcscspn
 487             #define  wxStrlen_   wxWcslen /* wxStrlen_() is used in wxStrlen() */
 488             #define  wxStrncat   wcsncat
 489             #define  wxStrncmp   wcsncmp
 490             #define  wxStrncpy   wcsncpy
 491             #define  wxStrpbrk   wcspbrk
 492             #define  wxStrrchr   wcsrchr
 493             #define  wxStrspn    wcsspn
 494             #define  wxStrstr    wcsstr
 495             #define  wxStrtod    wcstod
 496             #define  wxStrtol    wcstol
 497             #define  wxStrtoul   wcstoul
 498             #define  wxStrxfrm   wcsxfrm
 499
 500             #define  wxFgetc     fgetwc
 501             #define  wxFgetchar  fgetwchar
 502             #define  wxFgets     fgetws
 503             #define  wxFputc     fputwc
 504             #define  wxFputchar  fputwchar
 505             #define  wxGetc      getwc
 506             #define  wxGetchar   getwchar
 507             #define  wxGets      getws
 508             #define  wxUngetc    ungetwc
 509
 510             #ifdef HAVE_FPUTWS
 511                 #define wxFputs     fputws
 512             #else
 513                 #define wxNEED_FPUTS
 514                 #include <stdio.h>
 515                 int wxFputs(const wxChar *ch, FILE *stream);
 516             #endif
 517
 518             #ifdef HAVE_WPUTC
 519                 #define wxPutc      wputc
 520             #else
 521                 #define wxNEED_PUTC
 522                 #include <stdio.h>
 523                 int wxPutc(wxChar ch, FILE *stream);
 524             #endif
 525
 526             #ifdef HAVE_WPUTCHAR
 527                 #define wxPutchar   wputchar
 528             #else
 529                 #define wxPutchar(wch) wxPutc(wch, stdout)
 530             #endif
 531
 532             #ifdef HAVE_PUTWS
 533                 #define wxPuts      putws
 534             #else
 535                 #define wxNEED_PUTS
 536                 int wxPuts(const wxChar *ws);
 537             #endif
 538
 539             /* we need %s to %ls conversion for printf and scanf etc */
 540             #define wxNEED_PRINTF_CONVERSION
 541
 542             /* glibc doesn't have wide char equivalents of the other stuff so */
 543             /* use our own versions */
 544             #define wxNEED_WX_STDIO_H
 545             #define wxNEED_WX_STDLIB_H
 546             #define wxNEED_WX_TIME_H
 547         #elif defined(__MWERKS__) && ( defined(__MSL__) || defined(__MACH__) )
 548             /* ctype.h functions (wctype.h) */
 549             #define  wxIsalnum   iswalnum
 550             #define  wxIsalpha   iswalpha
 551             #define  wxIscntrl   iswcntrl
 552             #define  wxIsdigit   iswdigit
 553             #define  wxIsgraph   iswgraph
 554             #define  wxIslower   iswlower
 555             #define  wxIsprint   iswprint
 556             #define  wxIspunct   iswpunct
 557             #define  wxIsspace   iswspace
 558             #define  wxIsupper   iswupper
 559             #define  wxIsxdigit  iswxdigit
 560             #define  wxTolower   towlower
 561             #define  wxToupper   towupper
 562
 563             /* string.h functions (wchar.h) */
 564             #define  wxStrcat    wcscat
 565             #define  wxStrchr    wcschr
 566             #define  wxStrcmp    wcscmp
 567             #define  wxStrcoll   wcscoll
 568             #define  wxStrcpy    wcscpy
 569             #define  wxStrcspn   wcscspn
 570             #define  wxStrlen_   wxWcslen /* wxStrlen_() is used in wxStrlen() */
 571             #define  wxStrncat   wcsncat
 572             #define  wxStrncmp   wcsncmp
 573             #define  wxStrncpy   wcsncpy
 574             #define  wxStrpbrk   wcspbrk
 575             #define  wxStrrchr   wcsrchr
 576             #define  wxStrspn    wcsspn
 577             #define  wxStrstr    wcsstr
 578             #define  wxStrtod    wcstod
 579             #define  wxStrtol    wcstol
 580             #define  wxStrtoul   wcstoul
 581             #define  wxStrxfrm   wcsxfrm
 582
 583             #define  wxFgetc     fgetwc
 584             #define  wxFgetchar  fgetwchar
 585             #define  wxFgets     fgetws
 586             #define  wxFputc     fputwc
 587             #define  wxFputchar  fputwchar
 588             #define  wxGetc      getwc
 589             #define  wxGetchar   getwchar
 590             #define  wxGets      getws
 591             #define  wxUngetc    ungetwc
 592
 593             #define wxNEED_PRINTF_CONVERSION
 594
 595             #define  wxPutc      putwc
 596             #define  wxPutchar   putwchar
 597             #define  wxFputs     fputws
 598
 599             /* stdio.h functions */
 600
 601             #define wxNEED_WX_STDIO_H
 602
 603             /* stdlib.h functions */
 604             #ifdef __MACH__
 605             #define wxNEED_WX_STDLIB_H
 606             #else
 607             #define  wxAtof      watof
 608             #define  wxAtoi      watoi
 609             #define  wxAtol      watol
 610             #define  wxGetenv(a)    ((wxChar*)NULL)
 611             #define  wxSystem(a)    ((int)NULL)
 612             #endif
 613             /* time.h functions */
 614             #define  wxAsctime   wasciitime
 615             #define  wxCtime     wctime
 616             /* #define  wxStrftime  wcsftime */
 617
 618             #define wxNEED_WX_TIME_H
 619         #else /* !metrowerks for apple */
 620             #error  "Please define wide character functions for your environment"
 621         #endif
 622     #else /* ASCII */
 623         #include <ctype.h>
 624         #include <string.h>
 625
 626         /* ctype.h functions */
 627         #define  wxIsalnum   isalnum
 628         #define  wxIsalpha   isalpha
 629         #define  wxIscntrl   iscntrl
 630         #define  wxIsdigit   isdigit
 631         #define  wxIsgraph   isgraph
 632         #define  wxIslower   islower
 633         #define  wxIsprint   isprint
 634         #define  wxIspunct   ispunct
 635         #define  wxIsspace   isspace
 636         #define  wxIsupper   isupper
 637         #define  wxIsxdigit  isxdigit
 638         #define  wxTolower   tolower
 639         #define  wxToupper   toupper
 640
 641          /* locale.h functons */
 642         #define  wxSetlocale setlocale
 643
 644          /* string.h functions */
 645         #define  wxStrcat    strcat
 646         #define  wxStrchr    strchr
 647         #define  wxStrcmp    strcmp
 648         #define  wxStrcoll   strcoll
 649         #define  wxStrcpy    strcpy
 650         #define  wxStrcspn   strcspn
 651
 652         /* wxStricmp and wxStrnicmp are defined below */
 653         #define  wxStrlen_   strlen /* used in wxStrlen inline function */
 654         #define  wxStrncat   strncat
 655         #define  wxStrncmp   strncmp
 656         #define  wxStrncpy   strncpy
 657         #define  wxStrpbrk   strpbrk
 658         #define  wxStrrchr   strrchr
 659         #define  wxStrspn    strspn
 660         #define  wxStrstr    strstr
 661         #define  wxStrtod    strtod
 662         #ifdef HAVE_STRTOK_R
 663             #define  wxStrtok(str, sep, last)    strtok_r(str, sep, last)
 664         #endif
 665         #define  wxStrtol    strtol
 666         #define  wxStrtoul   strtoul
 667         #define  wxStrxfrm   strxfrm
 668
 669         /* stdio.h functions */
 670         #define  wxFopen     fopen
 671         #define  wxFreopen   freopen
 672         #define  wxRemove    remove
 673         #define  wxRename    rename
 674
 675         #define  wxPerror    perror
 676         #define  wxTmpnam    tmpnam
 677
 678         #define  wxFgetc     fgetc
 679         #define  wxFgetchar  fgetchar
 680         #define  wxFgets     fgets
 681         #define  wxFputc     fputc
 682         #define  wxFputs     fputs
 683         #define  wxFputchar  fputchar
 684         #define  wxFprintf   fprintf
 685         #define  wxFscanf    fscanf
 686         #define  wxGetc      getc
 687         #define  wxGetchar   getchar
 688         #define  wxGets      gets
 689         #define  wxPrintf    printf
 690         #define  wxPutc      putc
 691         #define  wxPutchar   putchar
 692         #define  wxPuts      puts
 693         #define  wxScanf     scanf
 694         #define  wxSprintf   sprintf
 695         #define  wxSscanf    sscanf
 696         #define  wxUngetc    ungetc
 697         #define  wxVfprintf  vfprintf
 698         #define  wxVprintf   vprintf
 699         #define  wxVsscanf   vsscanf
 700         #define  wxVsprintf  vsprintf
 701
 702         /* stdlib.h functions */
 703         #define  wxAtof      atof
 704         #define  wxAtoi      atoi
 705         #define  wxAtol      atol
 706         #define  wxGetenv    getenv
 707         #define  wxSystem    system
 708
 709         /* time.h functions */
 710         #define  wxAsctime   asctime
 711         #define  wxCtime     ctime
 712         #define  wxStrftime  strftime
 713     #endif /* Unicode/ASCII */
 714 #endif /* TCHAR-aware compilers/the others */
 715
 716 /*
 717     various special cases
 718  */
 719
 720 /* define wxStricmp and wxStrnicmp for various compilers */
 721
 722 /* note that in Unicode mode we definitely are going to need our own version */
 723 #if !defined(wxStricmp) && !wxUSE_UNICODE
 724     #if defined(__BORLANDC__) || defined(__WATCOMC__) || \
 725             defined(__SALFORDC__) || defined(__VISAGECPP__) || \
 726             defined(__EMX__) || defined(__DJGPP__)
 727         #define wxStricmp stricmp
 728         #define wxStrnicmp strnicmp
 729     #elif defined(__WXPALMOS__)
 730         /* FIXME: There is no equivalent to strnicmp in the Palm OS API.  This
 731          * quick hack should do until one can be written.
 732          */
 733         #define wxStricmp StrCaselessCompare
 734         #define wxStrnicmp strnicmp
 735     #elif defined(__SYMANTEC__) || defined(__VISUALC__) || \
 736             (defined(__MWERKS__) && defined(__INTEL__))
 737         #define wxStricmp _stricmp
 738         #define wxStrnicmp _strnicmp
 739     #elif defined(__UNIX__) || defined(__GNUWIN32__)
 740         #define wxStricmp strcasecmp
 741         #define wxStrnicmp strncasecmp
 742     /* #else -- use wxWidgets implementation */
 743     #endif
 744 #endif /* !defined(wxStricmp) */
 745
 746 /* define wxWcslen() which should be always available if wxUSE_WCHAR_T == 1 (as */
 747 /* it's used in wx/buffer.h -- and also might be used just below by wxStrlen() */
 748 /* when wxStrlen_() is #define'd as wxWcslen so do it before defining wxStrlen) */
 749 #if wxUSE_WCHAR_T
 750     #ifdef HAVE_WCSLEN
 751         #define wxWcslen wcslen
 752     #else
 753         WXDLLIMPEXP_BASE size_t wxWcslen(const wchar_t *s);
 754     #endif
 755 #endif /* wxUSE_WCHAR_T */
 756
 757 #ifdef __cplusplus
 758 /* checks whether the passed in pointer is NULL and if the string is empty */
 759 inline bool wxIsEmpty(const wxChar *p) { return !p || !*p; }
 760
 761 /* safe version of strlen() (returns 0 if passed NULL pointer) */
 762 inline size_t wxStrlen(const wxChar *psz) { return psz ? wxStrlen_(psz) : 0; }
 763 #endif
 764
 765 /*
 766     each of strdup() and wcsdup() may or may not be available but we need both
 767     of them anyhow for wx/buffer.h so we define the missing one(s) in
 768     wxchar.cpp and so we should always have both wxStrdupA and wxStrdupW
 769     defined -- if this is somehow not the case in some situations, please
 770     correct that and not the lines here
 771  */
 772 #if wxUSE_UNICODE
 773     #define wxStrdup wxStrdupW
 774 #else
 775     #define wxStrdup wxStrdupA
 776 #endif
 777
 778 #ifdef __cplusplus
 779 WXDLLIMPEXP_BASE bool wxOKlibc(); /* for internal use */
 780 #endif
 781
 782 /* printf() family saga */
 783
 784 /*
 785    For some systems vsnprintf() exists in the system libraries but not in the
 786    headers, so we need to declare it ourselves to be able to use it.
 787  */
 788 #if defined(HAVE_VSNPRINTF) && !defined(HAVE_VSNPRINTF_DECL)
 789 #ifdef __cplusplus
 790     extern "C"
 791 #else
 792     extern
 793 #endif
 794     int vsnprintf(char *str, size_t size, const char *format, va_list ap);
 795 #endif /* !HAVE_VSNPRINTF_DECL */
 796
 797 /*
 798    First of all, we always want to define safe snprintf() function to be used
 799    instead of sprintf(). Some compilers already have it (or rather vsnprintf()
 800    which we really need...), otherwise we implement it using our own printf()
 801    code.
 802
 803    We define function with a trailing underscore here because the real one is a
 804    wrapper around it as explained below
 805  */
 806 #ifndef wxVsnprintf_
 807     #if wxUSE_UNICODE
 808         #if defined(__MWERKS__)
 809             #define HAVE_WCSRTOMBS 1
 810             #define HAVE_VSWPRINTF 1
 811         #endif
 812         #if defined(__WATCOMC__)
 813             #define wxVsnprintf_    _vsnwprintf
 814             #define wxSnprintf_     _snwprintf
 815         #endif
 816         #if defined(HAVE__VSNWPRINTF)
 817             #define wxVsnprintf_    _vsnwprintf
 818         /* MinGW?MSVCRT has the wrong vswprintf */
 819         #elif defined(HAVE_VSWPRINTF) && !defined(__MINGW32__)
 820             #define wxVsnprintf_    vswprintf
 821         #endif
 822     #else /* ASCII */
 823         /* all versions of CodeWarrior supported by wxWidgets apparently have */
 824         /* vsnprintf() */
 825         #if defined(HAVE_VSNPRINTF) || defined(__MWERKS__) || defined(__WATCOMC__)
 826             /* assume we have snprintf() too if we have vsnprintf() */
 827             #define wxVsnprintf_    vsnprintf
 828             #define wxSnprintf_     snprintf
 829         #endif
 830     #endif
 831 #endif /* wxVsnprintf_ not defined yet */
 832
 833 #ifndef wxSnprintf_
 834     /* no [v]snprintf(), cook our own */
 835     WXDLLIMPEXP_BASE int wxSnprintf_(wxChar *buf, size_t len, const wxChar *format,
 836                                 ...) ATTRIBUTE_PRINTF_3;
 837 #endif
 838 #ifndef wxVsnprintf_
 839     WXDLLIMPEXP_BASE int wxVsnprintf_(wxChar *buf, size_t len, const wxChar *format,
 840                                  va_list argptr);
 841 #endif
 842
 843 /*
 844    In Unicode mode we need to have all standard functions such as wprintf() and
 845    so on but not all systems have them so use our own implementations in this
 846    case.
 847  */
 848 #if wxUSE_UNICODE && !defined(wxHAVE_TCHAR_SUPPORT) && !defined(HAVE_WPRINTF)
 849     #define wxNEED_WPRINTF
 850 #endif
 851
 852 /*
 853    More Unicode complications: although both ANSI C and C++ define a number of
 854    wide character functions such as wprintf(), not all environments have them.
 855    Worse, those which do have different behaviours: under Windows, %s format
 856    specifier changes its meaning in Unicode build and expects a Unicode string
 857    while under Unix/POSIX it still means an ASCII string even for wprintf() and
 858    %ls has to be used for wide strings.
 859
 860    We choose to always emulate Windows behaviour as more useful for us so even
 861    if we have wprintf() we still must wrap it in a non trivial wxPrintf().
 862
 863 */
 864
 865 #if defined(wxNEED_PRINTF_CONVERSION) || defined(wxNEED_WPRINTF)
 866     /*
 867         we need to implement all wide character printf and scanf functions
 868         either because we don't have them at all or because they don't have the
 869         semantics we need
 870      */
 871
 872     #include <stdio.h>  /* for FILE */
 873
 874     int wxScanf( const wxChar *format, ... ) ATTRIBUTE_PRINTF_1;
 875     int wxSscanf( const wxChar *str, const wxChar *format, ... ) ATTRIBUTE_PRINTF_2;
 876     int wxFscanf( FILE *stream, const wxChar *format, ... ) ATTRIBUTE_PRINTF_2;
 877     int wxVsscanf( const wxChar *str, const wxChar *format, va_list ap );
 878     int wxPrintf( const wxChar *format, ... ) ATTRIBUTE_PRINTF_1;
 879     int wxSprintf( wxChar *str, const wxChar *format, ... ) ATTRIBUTE_PRINTF_2;
 880     int wxFprintf( FILE *stream, const wxChar *format, ... ) ATTRIBUTE_PRINTF_2;
 881     int wxVfprintf( FILE *stream, const wxChar *format, va_list ap );
 882     int wxVprintf( const wxChar *format, va_list ap );
 883     int wxVsprintf( wxChar *str, const wxChar *format, va_list ap );
 884 #endif /* wxNEED_PRINTF_CONVERSION */
 885
 886 /* these 2 can be simply mapped to the versions with underscore at the end */
 887 /* if we don't have to do the conversion */
 888 /*
 889    However, if we don't have any vswprintf() at all we don't need to redefine
 890    anything as our own wxVsnprintf_() already behaves as needed.
 891 */
 892 #if defined(wxNEED_PRINTF_CONVERSION) && defined(wxVsnprintf_)
 893     int wxSnprintf( wxChar *str, size_t size, const wxChar *format, ... ) ATTRIBUTE_PRINTF_3;
 894     int wxVsnprintf( wxChar *str, size_t size, const wxChar *format, va_list ap );
 895 #else
 896     #define wxSnprintf wxSnprintf_
 897     #define wxVsnprintf wxVsnprintf_
 898 #endif
 899
 900 /*
 901     various functions which might not be available in libc and for which we
 902     provide our own replacements in wxchar.cpp
 903  */
 904
 905 /* ctype.h functions */
 906
 907 /* RN: Used only under OSX <= 10.2 currently */
 908 #ifdef wxNEED_WX_CTYPE_H
 909     WXDLLIMPEXP_BASE int wxIsalnum(wxChar ch);
 910     WXDLLIMPEXP_BASE int wxIsalpha(wxChar ch);
 911     WXDLLIMPEXP_BASE int wxIscntrl(wxChar ch);
 912     WXDLLIMPEXP_BASE int wxIsdigit(wxChar ch);
 913     WXDLLIMPEXP_BASE int wxIsgraph(wxChar ch);
 914     WXDLLIMPEXP_BASE int wxIslower(wxChar ch);
 915     WXDLLIMPEXP_BASE int wxIsprint(wxChar ch);
 916     WXDLLIMPEXP_BASE int wxIspunct(wxChar ch);
 917     WXDLLIMPEXP_BASE int wxIsspace(wxChar ch);
 918     WXDLLIMPEXP_BASE int wxIsupper(wxChar ch);
 919     WXDLLIMPEXP_BASE int wxIsxdigit(wxChar ch);
 920     WXDLLIMPEXP_BASE int wxTolower(wxChar ch);
 921     WXDLLIMPEXP_BASE int wxToupper(wxChar ch);
 922 #endif /* wxNEED_WX_CTYPE_H */
 923
 924 /* under VC++ 6.0 isspace() returns 1 for 8 bit chars which completely breaks */
 925 /* the file parsing -- this may be true for 5.0 as well, update #ifdef then */
 926 #if defined(__VISUALC__) && (__VISUALC__ >= 1200) && !wxUSE_UNICODE
 927     #undef wxIsspace
 928     #define wxIsspace(c) ((((unsigned)c) < 128) && isspace(c))
 929 #endif /* VC++ */
 930
 931 /*
 932    a few compilers don't have the (non standard but common) isascii function,
 933    define it ourselves for them
 934  */
 935 #ifndef isascii
 936     #if defined(__MWERKS__)
 937         #define wxNEED_ISASCII
 938     #elif defined(_WIN32_WCE)
 939         #if _WIN32_WCE <= 211
 940             #define wxNEED_ISASCII
 941         #endif
 942     #endif
 943 #endif /* isascii */
 944
 945 #ifdef wxNEED_ISASCII
 946     inline int isascii(int c) { return (unsigned)c < 0x80; }
 947 #endif
 948
 949 #ifdef _WIN32_WCE
 950     #if _WIN32_WCE <= 211
 951         #define isspace(c) ((c) == _T(' ') || (c) == _T('\t'))
 952     #endif
 953 #endif /* _WIN32_WCE */
 954
 955 /*
 956    we had goofed and defined wxIsctrl() instead of (correct) wxIscntrl() in the
 957    initial versions of this header -- now it is too late to remove it so
 958    although we fixed the function/macro name above, still provide the
 959    backwards-compatible synonym.
 960  */
 961 #define wxIsctrl wxIscntrl
 962
 963 /* string.h functions */
 964 #ifndef strdup
 965     #if defined(__MWERKS__) && !defined(__MACH__) && (__MSL__ < 0x00008000)
 966         #define wxNEED_STRDUP
 967     #elif defined(__WXWINCE__)
 968         #if _WIN32_WCE <= 211
 969             #define wxNEED_STRDUP
 970         #endif
 971     #endif
 972 #endif /* strdup */
 973
 974 #ifdef wxNEED_STRDUP
 975     WXDLLIMPEXP_BASE char *strdup(const char* s);
 976 #endif
 977
 978 /* RN: Used only under OSX <= 10.2 currently
 979    The __cplusplus ifdefs are messy, but they are required to build
 980    the regex library, since c does not support function overloading
 981 */
 982 #ifdef wxNEED_WX_STRING_H
 983 # ifdef __cplusplus
 984     extern "C" {
 985 # endif
 986         WXDLLIMPEXP_BASE wxChar * wxStrcat(wxChar *dest, const wxChar *src);
 987         WXDLLIMPEXP_BASE const wxChar * wxStrchr(const wxChar *s, wxChar c);
 988         WXDLLIMPEXP_BASE int      wxStrcmp(const wxChar *s1, const wxChar *s2);
 989         WXDLLIMPEXP_BASE int      wxStrcoll(const wxChar *s1, const wxChar *s2);
 990         WXDLLIMPEXP_BASE wxChar * wxStrcpy(wxChar *dest, const wxChar *src);
 991         WXDLLIMPEXP_BASE size_t   wxStrcspn(const wxChar *s, const wxChar *reject);
 992         WXDLLIMPEXP_BASE wxChar * wxStrncat(wxChar *dest, const wxChar *src, size_t n);
 993         WXDLLIMPEXP_BASE int      wxStrncmp(const wxChar *s1, const wxChar *s2, size_t n);
 994         WXDLLIMPEXP_BASE wxChar * wxStrncpy(wxChar *dest, const wxChar *src, size_t n);
 995         WXDLLIMPEXP_BASE const wxChar * wxStrpbrk(const wxChar *s, const wxChar *accept);
 996         WXDLLIMPEXP_BASE const wxChar * wxStrrchr(const wxChar *s, wxChar c);
 997         WXDLLIMPEXP_BASE size_t   wxStrspn(const wxChar *s, const wxChar *accept);
 998         WXDLLIMPEXP_BASE const wxChar * wxStrstr(const wxChar *haystack, const wxChar *needle);
 999 # ifdef __cplusplus
1000     }
1001 # endif
1002
1003     /* These functions use C++, so we can't c extern them */
1004     WXDLLIMPEXP_BASE double   wxStrtod(const wxChar *nptr, wxChar **endptr);
1005     WXDLLIMPEXP_BASE long int wxStrtol(const wxChar *nptr, wxChar **endptr, int base);
1006     WXDLLIMPEXP_BASE unsigned long int wxStrtoul(const wxChar *nptr, wxChar **endptr, int base);
1007     WXDLLIMPEXP_BASE size_t   wxStrxfrm(wxChar *dest, const wxChar *src, size_t n);
1008
1009     /* inlined versions */
1010     #ifdef __cplusplus
1011         inline wxChar * wxStrchr(wxChar *s, wxChar c)
1012             { return (wxChar *)wxStrchr((const wxChar *)s, c); }
1013         inline wxChar * wxStrpbrk(wxChar *s, const wxChar *accept)
1014             { return (wxChar *)wxStrpbrk((const wxChar *)s, accept); }
1015         inline wxChar * wxStrrchr(wxChar *s, wxChar c)
1016             { return (wxChar *)wxStrrchr((const wxChar *)s, c); }
1017         inline wxChar *wxStrstr(wxChar *haystack, const wxChar *needle)
1018             { return (wxChar *)wxStrstr((const wxChar *)haystack, needle); }
1019     #endif
1020
1021 #endif /* wxNEED_WX_STRING_H */
1022
1023 #ifndef wxStrdupA
1024 WXDLLIMPEXP_BASE char *wxStrdupA(const char *psz);
1025 #endif
1026
1027 #ifndef wxStrdupW
1028 WXDLLIMPEXP_BASE wchar_t *wxStrdupW(const wchar_t *pwz);
1029 #endif
1030
1031 #ifndef wxStricmp
1032 WXDLLIMPEXP_BASE int wxStricmp(const wxChar *psz1, const wxChar *psz2);
1033 #endif
1034
1035 #ifndef wxStrnicmp
1036 WXDLLIMPEXP_BASE int wxStrnicmp(const wxChar *psz1, const wxChar *psz2, size_t len);
1037 #endif
1038
1039 #ifndef wxStrtok
1040 WXDLLIMPEXP_BASE wxChar * wxStrtok(wxChar *psz, const wxChar *delim, wxChar **save_ptr);
1041 #endif
1042
1043 #ifdef __cplusplus
1044 #ifndef wxSetlocale
1045 class WXDLLIMPEXP_BASE wxWCharBuffer;
1046 WXDLLIMPEXP_BASE wxWCharBuffer wxSetlocale(int category, const wxChar *locale);
1047 #endif
1048 #endif
1049
1050 /* stdio.h functions */
1051 #ifdef wxNEED_WX_STDIO_H
1052     #include <stdio.h>
1053     WXDLLIMPEXP_BASE FILE *   wxFopen(const wxChar *path, const wxChar *mode);
1054     WXDLLIMPEXP_BASE FILE *   wxFreopen(const wxChar *path, const wxChar *mode, FILE *stream);
1055     WXDLLIMPEXP_BASE int      wxRemove(const wxChar *path);
1056     WXDLLIMPEXP_BASE int      wxRename(const wxChar *oldpath, const wxChar *newpath);
1057
1058     /* *printf() family is handled separately */
1059 #endif /* wxNEED_WX_STDIO_H */
1060
1061
1062 /* stdlib.h functions */
1063 #ifndef wxAtof
1064 WXDLLIMPEXP_BASE double   wxAtof(const wxChar *psz);
1065 #endif
1066
1067 #ifdef wxNEED_WX_STDLIB_H
1068 WXDLLIMPEXP_BASE int      wxAtoi(const wxChar *psz);
1069 WXDLLIMPEXP_BASE long     wxAtol(const wxChar *psz);
1070 WXDLLIMPEXP_BASE wxChar * wxGetenv(const wxChar *name);
1071 WXDLLIMPEXP_BASE int      wxSystem(const wxChar *psz);
1072 #endif
1073
1074
1075 /* time.h functions */
1076 #ifdef wxNEED_WX_TIME_H
1077 #if defined(__MWERKS__) && defined(macintosh)
1078     #include <time.h>
1079 #endif
1080     /*silent gabby compilers*/
1081     struct tm;
1082     WXDLLIMPEXP_BASE size_t wxStrftime(wxChar *s, size_t max,
1083                                   const wxChar *fmt, const struct tm *tm);
1084 #endif /* wxNEED_WX_TIME_H */
1085
1086 #ifndef wxCtime
1087 #include <time.h>
1088 WXDLLIMPEXP_BASE wxChar *wxCtime(const time_t *timep);
1089 #endif
1090
1091
1092 /* missing functions in some WinCE versions */
1093 #ifdef _WIN32_WCE
1094 #if (_WIN32_WCE < 300)
1095 WXDLLIMPEXP_BASE void *calloc( size_t num, size_t size );
1096 #endif
1097 #endif /* _WIN32_WCE */
1098
1099 /* multibyte to wide char conversion functions and macros */
1100
1101 #if wxUSE_WCHAR_T
1102     /* multibyte<->widechar conversion */
1103     WXDLLIMPEXP_BASE size_t wxMB2WC(wchar_t *buf, const char *psz, size_t n);
1104     WXDLLIMPEXP_BASE size_t wxWC2MB(char *buf, const wchar_t *psz, size_t n);
1105
1106     #if wxUSE_UNICODE
1107         #define wxMB2WX wxMB2WC
1108         #define wxWX2MB wxWC2MB
1109         #define wxWC2WX wxStrncpy
1110         #define wxWX2WC wxStrncpy
1111     #else
1112         #define wxMB2WX wxStrncpy
1113         #define wxWX2MB wxStrncpy
1114         #define wxWC2WX wxWC2MB
1115         #define wxWX2WC wxMB2WC
1116     #endif
1117 #else /* !wxUSE_UNICODE */
1118 /* Why is this here?
1119 #error ha */
1120     /* No wxUSE_WCHAR_T: we have to do something (JACS) */
1121     #define wxMB2WC wxStrncpy
1122     #define wxWC2MB wxStrncpy
1123     #define wxMB2WX wxStrncpy
1124     #define wxWX2MB wxStrncpy
1125     #define wxWC2WX wxWC2MB
1126     #define wxWX2WC wxMB2WC
1127 #endif
1128
1129 /*
1130     RN:  The following are not normal versions of memcpy et al., rather
1131     these are either char or widechar versions depending on
1132     if unicode is used or not.
1133 */
1134
1135 #ifdef __cplusplus
1136
1137     //
1138     //  RN: We could do the usual tricky compiler detection here,
1139     //  and use their variant (such as wmemchr, etc.).  The problem
1140     //  is that these functions are quite rare, even though they are
1141     //  part of the current POSIX standard.  In addition, most compilers
1142     //  (including even MSC) inline them just like we do right in their
1143     //  headers.
1144     //
1145     #if wxUSE_UNICODE
1146         #include <string.h> //for mem funcs
1147
1148         //implement our own wmem variants
1149         inline wxChar* wxTmemchr(const wxChar* s, wxChar c, size_t l)
1150         {
1151             for(;l && *s != c;--l, ++s) {}
1152
1153             if(l)
1154                 return (wxChar*)s;
1155             return NULL;
1156         }
1157
1158         inline int wxTmemcmp(const wxChar* sz1, const wxChar* sz2, size_t len)
1159         {
1160             for(; *sz1 == *sz2 && len; --len, ++sz1, ++sz2) {}
1161
1162             if(len)
1163                 return *sz1 < *sz2 ? -1 : *sz1 > *sz2;
1164             else
1165                 return 0;
1166         }
1167
1168         inline wxChar* wxTmemcpy(wxChar* szOut, const wxChar* szIn, size_t len)
1169         {
1170             return (wxChar*) memcpy(szOut, szIn, len * sizeof(wxChar));
1171         }
1172
1173         inline wxChar* wxTmemmove(wxChar* szOut, const wxChar* szIn, size_t len)
1174         {
1175             return (wxChar*) memmove(szOut, szIn, len * sizeof(wxChar));
1176         }
1177
1178         inline wxChar* wxTmemset(wxChar* szOut, const wxChar cIn, size_t len)
1179         {
1180             wxChar* szRet = szOut;
1181
1182             while (len--)
1183                 *szOut++ = cIn;
1184
1185             return szRet;
1186         }
1187
1188     #else //!wxUSE_UNICODE
1189     #   define wxTmemchr memchr
1190     #   define wxTmemcmp memcmp
1191     #   define wxTmemcpy memcpy
1192     #   define wxTmemmove memmove
1193     #   define wxTmemset memset
1194     #endif
1195
1196 #endif /*__cplusplus*/
1197
1198
1199 #endif /* _WX_WXCHAR_H_ */
1200