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