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