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