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