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