[wxWidgets.git] / include / wx / wxchar.h

/////////////////////////////////////////////////////////////////////////////
// Name:        wxchar.h
// Purpose:     Declarations common to wx char/wchar_t usage (wide chars)
// Author:      Joel Farley
// Modified by:
// Created:     1998/06/12
// RCS-ID:      $Id$
// Copyright:   (c) wxWindows copyright
// Licence:     wxWindows licence
/////////////////////////////////////////////////////////////////////////////

#ifndef _WX_WXCHAR_H_
#define _WX_WXCHAR_H_

//#ifdef __GNUG__
//#pragma interface "wxchar.h"
//#endif

// only do SBCS or _UNICODE
#if defined (_MBCS )
#error "MBCS is not supported by wxChar"
#endif

// set wxUSE_UNICODE to 1 if UNICODE or _UNICODE is defined
#if defined(_UNICODE) || defined(UNICODE)
#undef wxUSE_UNICODE
#define wxUSE_UNICODE 1
#else
#ifndef wxUSE_UNICODE
#define wxUSE_UNICODE 0
#endif
#endif

// and vice versa: define UNICODE and _UNICODE if wxUSE_UNICODE is 1...
#if wxUSE_UNICODE
#ifndef _UNICODE
#define _UNICODE
#endif
#ifndef UNICODE
#define UNICODE
#endif
#endif

// Windows (VC++) has broad TCHAR support
#if defined(__VISUALC__) && defined(__WIN32__)

#define HAVE_WCSLEN 1

#include <tchar.h>
#if wxUSE_UNICODE // temporary - preserve binary compatibility
typedef  _TCHAR      wxChar;
typedef  _TSCHAR     wxSChar;
typedef  _TUCHAR     wxUChar;
#else
#define wxChar char
#define wxSChar signed char
#define wxUChar unsigned char
#endif
   // wchar_t is available
#undef wxUSE_WCHAR_T
#define wxUSE_WCHAR_T 1

   // ctype.h functions
#define  wxIsalnum   _istalnum
#define  wxIsalpha   _istalpha
#define  wxIsctrl    _istctrl
#define  wxIsdigit   _istdigit
#define  wxIsgraph   _istgraph
#define  wxIslower   _istlower
#define  wxIsprint   _istprint
#define  wxIspunct   _istpunct
#define  wxIsspace   _istspace
#define  wxIsupper   _istupper
#define  wxIsxdigit  _istxdigit
#define  wxTolower   _totlower
#define  wxToupper   _totupper

   // locale.h functons
#define  wxSetlocale _tsetlocale

   // string.h functions
#define  wxStrcat    _tcscat
#define  wxStrchr    _tcschr
#define  wxStrcmp    _tcscmp
#define  wxStrcoll   _tcscoll
#define  wxStrcpy    _tcscpy
#define  wxStrcspn   _tcscspn
#define  wxStrftime  _tcsftime
#define  wxStricmp   _tcsicmp
#define  wxStrlen_   _tcslen // used in wxStrlen inline function
#define  wxStrncat   _tcsncat
#define  wxStrncmp   _tcsncmp
#define  wxStrncpy   _tcsncpy
#define  wxStrpbrk   _tcspbrk
#define  wxStrrchr   _tcsrchr
#define  wxStrspn    _tcsspn
#define  wxStrstr    _tcsstr
#define  wxStrtod    _tcstod
// is there a _tcstok[_r] ?
#define  wxStrtol    _tcstol
#define  wxStrtoul   _tcstoul
#define  wxStrxfrm   _tcsxfrm

   // stdio.h functions
#define  wxFgetc     _fgettc
#define  wxFgetchar  _fgettchar
#define  wxFgets     _fgetts
#define  wxFopen     _tfopen
#define  wxFputc     _fputtc
#define  wxFputchar  _fputtchar
#define  wxFprintf   _ftprintf
#define  wxFreopen   _tfreopen
#define  wxFscanf    _ftscanf
#define  wxGetc      _gettc
#define  wxGetchar   _gettchar
#define  wxGets      _getts
#define  wxPerror    _tperror
#define  wxPrintf    _tprintf
#define  wxPutc      _puttc
#define  wxPutchar   _puttchar
#define  wxPuts      _putts
#define  wxRemove    _tremove
#define  wxRename    _trename
#define  wxScanf     _tscanf
#define  wxSprintf   _stprintf
#define  wxSscanf    _stscanf
#define  wxTmpnam    _ttmpnam
#define  wxUngetc    _tungetc
#define  wxVfprint   _vftprintf
#define  wxVprintf   _vtprintf
#define  wxVsscanf   _vstscanf
#define  wxVsprintf  _vstprintf

   // stdlib.h functions
#if !wxUSE_UNICODE
#define  wxAtof      atof
#endif
#define  wxAtoi      _ttoi
#define  wxAtol      _ttol
#define  wxGetenv    _tgetenv
#define  wxSystem    _tsystem

   // time.h functions
#define  wxAsctime   _tasctime
#define  wxCtime     _tctime

// #elif defined(XXX)
   // #include XXX-specific files here
   // typeddef YYY wxChar;

   // translate wxZZZ names

#elif defined(__BORLANDC__) && defined(__WIN32__)

// Borland C++ 4.52 doesn't have much tchar support
// maybe Borland C++ 5.02 has, can't check right now
// but I'll use the Win32 API instead here

#include <tchar.h>
#if wxUSE_UNICODE // temporary - preserve binary compatibility
typedef  _TCHAR      wxChar;
typedef  _TSCHAR     wxSChar;
typedef  _TUCHAR     wxUChar;
#else
#define wxChar char
#define wxSChar signed char
#define wxUChar unsigned char
#endif
   // wchar_t is available
#undef wxUSE_WCHAR_T
#define wxUSE_WCHAR_T 1

#define wxNEED_WX_CTYPE_H
// #define  wxStrtok    strtok_r // Borland C++ 4.52 doesn't have strtok_r
#define wxNEED_WX_STRING_H
#define wxNEED_WX_STDIO_H
#define wxNEED_WX_STDLIB_H
#define wxNEED_WX_TIME_H
#define wxNEED_WCSLEN

#else//!TCHAR-aware compilers

// check whether we should include wchar.h or equivalent
#if wxUSE_UNICODE
 #undef wxUSE_WCHAR_T
 #define wxUSE_WCHAR_T 1 // wchar_t *must* be available in Unicode mode
#elif !defined(wxUSE_WCHAR_T)
 #if defined(__VISUALC__) && (__VISUALC__ < 900)
  #define wxUSE_WCHAR_T 0 // wchar_t is not available for MSVC++ 1.5
 #elif defined(__UNIX__)
  #if defined(HAVE_WCSTR_H) || defined(HAVE_WCHAR_H) || defined(__FreeBSD__)
   #define wxUSE_WCHAR_T 1
  #else
   #define wxUSE_WCHAR_T 0
  #endif
 #elif defined(__GNUWIN32__) && !defined(__MINGW32__) // Cygwin (not Mingw32) doesn't have wcslen.h, needed in buffer.h
  #define wxUSE_WCHAR_T 0
 #elif defined(__BORLANDC__) // WIN16 BC++
  #define wxUSE_WCHAR_T 0
 #elif defined(__WATCOMC__)
  #define wxUSE_WCHAR_T 0
 #else
  // add additional compiler checks if this fails
  #define wxUSE_WCHAR_T 1
 #endif
#endif//wxUSE_UNICODE

#if wxUSE_WCHAR_T
 #ifdef HAVE_WCSTR_H
  #include <wcstr.h>
 #else
  #ifndef __FreeBSD__
   #include <wchar.h>
  #else
   #include <stdlib.h>
   #define wxNEED_WCSLEN
  #endif
 #endif
#endif

// check whether we are doing Unicode
#if wxUSE_UNICODE

#include <wctype.h>

// this is probably glibc-specific
#if defined(__WCHAR_TYPE__)

typedef __WCHAR_TYPE__          wxChar;
typedef signed __WCHAR_TYPE__   wxSChar;
typedef unsigned __WCHAR_TYPE__ wxUChar;

#define _T(x)                   L##x

   // ctype.h functions (wctype.h)
#define  wxIsalnum   iswalnum
#define  wxIsalpha   iswalpha
#define  wxIsctrl    iswcntrl
#define  wxIsdigit   iswdigit
#define  wxIsgraph   iswgraph
#define  wxIslower   iswlower
#define  wxIsprint   iswprint
#define  wxIspunct   iswpunct
#define  wxIsspace   iswspace
#define  wxIsupper   iswupper
#define  wxIsxdigit  iswxdigit

#if defined(__GLIBC__) && (__GLIBC__ == 2) && (__GLIBC_MINOR__ == 0)
    // /usr/include/wctype.h incorrectly declares translations tables which
    // provokes tons of compile-time warnings - try to correct this
    #define  wxTolower(wc)   towctrans((wc), (wctrans_t)__ctype_tolower)
    #define  wxToupper(wc)   towctrans((wc), (wctrans_t)__ctype_toupper)
#else
    #define  wxTolower   towlower
    #define  wxToupper   towupper
#endif // gcc/!gcc

   // string.h functions (wchar.h)
#define  wxStrcat    wcscat
#define  wxStrchr    wcschr
#define  wxStrcmp    wcscmp
#define  wxStrcoll   wcscoll
#define  wxStrcpy    wcscpy
#define  wxStrcspn   wcscspn
#define  wxStrlen_   wcslen // used in wxStrlen inline function
#define  wxStrncat   wcsncat
#define  wxStrncmp   wcsncmp
#define  wxStrncpy   wcsncpy
#define  wxStrpbrk   wcspbrk
#define  wxStrrchr   wcsrchr
#define  wxStrspn    wcsspn
#define  wxStrstr    wcsstr
#define  wxStrtod    wcstod
#define  wxStrtok    wcstok
#define  wxStrtol    wcstol
#define  wxStrtoul   wcstoul
#define  wxStrxfrm   wcsxfrm

// glibc doesn't have wc equivalents of the other stuff
#define wxNEED_WX_STDIO_H
#define wxNEED_WX_STDLIB_H
#define wxNEED_WX_TIME_H

#else//!glibc
#error   "Please define your compiler's Unicode conventions in wxChar.h"
#endif
#else//!Unicode

#include <ctype.h>
#include <string.h>

#if 0 // temporary - preserve binary compatibilty
typedef char            wxChar;
typedef signed char     wxSChar;
typedef unsigned char   wxUChar;
#else
#define wxChar char
#define wxSChar signed char
#define wxUChar unsigned char
#endif

#ifdef __FreeBSD__
 #undef _T
#endif
#define _T(x)           x

   // ctype.h functions
#define  wxIsalnum   isalnum
#define  wxIsalpha   isalpha
#define  wxIsctrl    isctrl
#define  wxIsdigit   isdigit
#define  wxIsgraph   isgraph
#define  wxIslower   islower
#define  wxIsprint   isprint
#define  wxIspunct   ispunct
#define  wxIsspace   isspace
#define  wxIsupper   isupper
#define  wxIsxdigit  isxdigit
#define  wxTolower   tolower
#define  wxToupper   toupper

   // locale.h functons
#define  wxSetlocale setlocale

   // string.h functions
// #define  wxStricmp   strcasecmp

// Taken from string.h since it tests for platform more correctly
// portable strcasecmp/_stricmp
inline int WXDLLEXPORT wxStricmp(const char *psz1, const char *psz2)
{
#if     defined(__VISUALC__) || ( defined(__MWERKS__) && defined(__INTEL__) )
  return _stricmp(psz1, psz2);
#elif     defined(__SC__)
  return _stricmp(psz1, psz2);
#elif     defined(__SALFORDC__)
  return stricmp(psz1, psz2);
#elif defined(__BORLANDC__)
  return stricmp(psz1, psz2);
#elif defined(__WATCOMC__)
  return stricmp(psz1, psz2);
#elif   defined(__UNIX__) || defined(__GNUWIN32__)
  return strcasecmp(psz1, psz2);
#elif defined(__MWERKS__) && !defined(__INTEL__)
  register char c1, c2;
  do {
    c1 = tolower(*psz1++);
    c2 = tolower(*psz2++);
  } while ( c1 && (c1 == c2) );

  return c1 - c2;
#else
  // almost all compilers/libraries provide this function (unfortunately under
  // different names), that's why we don't implement our own which will surely
  // be more efficient than this code (uncomment to use):
  /*
    register char c1, c2;
    do {
      c1 = tolower(*psz1++);
      c2 = tolower(*psz2++);
    } while ( c1 && (c1 == c2) );

    return c1 - c2;
  */

  #error  "Please define string case-insensitive compare for your OS/compiler"
#endif  // OS/compiler
}

// #define  wxStrtok    strtok_r // this needs a configure check

   // leave the rest to defaults below
#define wxNEED_WX_STRING_H
#define wxNEED_WX_STDIO_H
#define wxNEED_WX_STDLIB_H
#define wxNEED_WX_TIME_H

#endif//Unicode
#endif//TCHAR-aware compilers

// define wxStricmp for various compilers without Unicode possibilities
#if !defined(wxStricmp) && !wxUSE_UNICODE
#if defined(__BORLANDC__) || defined(__WATCOMC__) || defined(__SALFORDC__)
    #define wxStricmp stricmp
#elif defined(__SC__) || defined(__VISUALC__) || (defined(__MWERKS) && defined(__INTEL__))
    #define wxStricmp _stricmp
#elif defined(__UNIX__) || defined(__GNUWIN32__)
    #define wxStricmp strcasecmp
#elif defined(__MWERKS__) && !defined(__INTEL__)
    // use wxWindows' implementation
#else
    // if you leave wxStricmp undefined, wxWindows' implementation will be used
    #error  "Please define string case-insensitive compare for your OS/compiler"
#endif
#endif

// if we need to define for standard headers, and we're not using Unicode,
// just define to standard C library routines
#if !wxUSE_UNICODE
#ifdef wxNEED_WX_STRING_H
#define  wxStrcat    strcat
#define  wxStrchr    strchr
#define  wxStrcmp    strcmp
#define  wxStrcoll   strcoll
#define  wxStrcpy    strcpy
#define  wxStrcspn   strcspn
#define  wxStrdup    strdup
#define  wxStrlen_   strlen // used in wxStrlen inline function
#define  wxStrncat   strncat
#define  wxStrncmp   strncmp
#define  wxStrncpy   strncpy
#define  wxStrpbrk   strpbrk
#define  wxStrrchr   strrchr
#define  wxStrspn    strspn
#define  wxStrstr    strstr
#define  wxStrtod    strtod
#define  wxStrtol    strtol
#define  wxStrtoul   strtoul
#define  wxStrxfrm   strxfrm
#undef wxNEED_WX_STRING_H
#endif

#ifdef wxNEED_WX_STDIO_H
#define  wxFgetc     fgetc
#define  wxFgetchar  fgetchar
#define  wxFgets     fgets
#define  wxFopen     fopen
#define  wxFputc     fputc
#define  wxFputchar  fputchar
#define  wxFprintf   fprintf
#define  wxFreopen   freopen
#define  wxFscanf    fscanf
#define  wxGetc      getc
#define  wxGetchar   getchar
#define  wxGets      gets
#define  wxPerror    perror
#define  wxPrintf    printf
#define  wxPutc      putc
#define  wxPutchar   putchar
#define  wxPuts      puts
#define  wxRemove    remove
#define  wxRename    rename
#define  wxScanf     scanf
#define  wxSprintf   sprintf
#define  wxSscanf    sscanf
#define  wxTmpnam    tmpnam
#define  wxUngetc    ungetc
#define  wxVfprint   vfprintf
#define  wxVprintf   vprintf
#define  wxVsscanf   vsscanf
#define  wxVsprintf  vsprintf
#undef wxNEED_WX_STDIO_H
#endif

#ifdef wxNEED_WX_STDLIB_H
#define  wxAtof      atof
#define  wxAtoi      atoi
#define  wxAtol      atol
#define  wxGetenv    getenv
#define  wxSystem    system
#undef wxNEED_WX_STDLIB_H
#endif

#ifdef wxNEED_WX_TIME_H
#define  wxAsctime   asctime
#define  wxCtime     ctime
#define  wxStrftime  strftime
#undef wxNEED_WX_TIME_H
#endif
#endif //!Unicode

#if defined(wxNEED_WCSLEN) && wxUSE_UNICODE
#define wcslen wxStrlen
#undef wxNEED_WCSLEN
#endif

/// checks whether the passed in pointer is NULL and if the string is empty
WXDLLEXPORT inline bool wxIsEmpty(const wxChar *p) { return !p || !*p; }

#ifndef wxNEED_WX_STRING_H
/// safe version of strlen() (returns 0 if passed NULL pointer)
WXDLLEXPORT inline size_t wxStrlen(const wxChar *psz)
   { return psz ? wxStrlen_(psz) : 0; }
#endif

#if wxUSE_WCHAR_T
// multibyte<->widechar conversion
WXDLLEXPORT size_t wxMB2WC(wchar_t *buf, const char *psz, size_t n);
WXDLLEXPORT size_t wxWC2MB(char *buf, const wchar_t *psz, size_t n);
#if wxUSE_UNICODE
#define wxMB2WX wxMB2WC
#define wxWX2MB wxWC2MB
#define wxWC2WX wxStrncpy
#define wxWX2WC wxStrncpy
#else
#define wxMB2WX wxStrncpy
#define wxWX2MB wxStrncpy
#define wxWC2WX wxWC2MB
#define wxWX2WC wxMB2WC
#endif
#else
// No wxUSE_WCHAR_T: we have to do something (JACS)
#define wxMB2WC wxStrncpy
#define wxWC2MB wxStrncpy
#define wxMB2WX wxStrncpy
#define wxWX2MB wxStrncpy
#define wxWC2WX wxWC2MB
#define wxWX2WC wxMB2WC
#endif

WXDLLEXPORT bool wxOKlibc(); // for internal use

// if libc versions are not available, use replacements defined in wxchar.cpp
#ifndef wxStrdup
WXDLLEXPORT wxChar * wxStrdup(const wxChar *psz);
#endif

#ifndef wxStricmp
WXDLLEXPORT int      wxStricmp(const wxChar *psz1, const wxChar *psz2);
#endif

#ifndef wxStrtok
WXDLLEXPORT wxChar * wxStrtok(wxChar *psz, const wxChar *delim, wxChar **save_ptr);
#endif

#ifndef wxSetlocale
WXDLLEXPORT wxChar * wxSetlocale(int category, const wxChar *locale);
#endif

#ifdef wxNEED_WCSLEN // for use in buffer.h
WXDLLEXPORT size_t   wcslen(const wchar_t *s);
#endif

#ifdef wxNEED_WX_CTYPE_H
WXDLLEXPORT int wxIsalnum(wxChar ch);
WXDLLEXPORT int wxIsalpha(wxChar ch);
WXDLLEXPORT int wxIsctrl(wxChar ch);
WXDLLEXPORT int wxIsdigit(wxChar ch);
WXDLLEXPORT int wxIsgraph(wxChar ch);
WXDLLEXPORT int wxIslower(wxChar ch);
WXDLLEXPORT int wxIsprint(wxChar ch);
WXDLLEXPORT int wxIspunct(wxChar ch);
WXDLLEXPORT int wxIsspace(wxChar ch);
WXDLLEXPORT int wxIsupper(wxChar ch);
WXDLLEXPORT int wxIsxdigit(wxChar ch);
WXDLLEXPORT int wxTolower(wxChar ch);
WXDLLEXPORT int wxToupper(wxChar ch);
#endif

#ifdef wxNEED_WX_STRING_H
WXDLLEXPORT wxChar * wxStrcat(wxChar *dest, const wxChar *src);
WXDLLEXPORT wxChar * wxStrchr(const wxChar *s, wxChar c);
WXDLLEXPORT int      wxStrcmp(const wxChar *s1, const wxChar *s2);
WXDLLEXPORT int      wxStrcoll(const wxChar *s1, const wxChar *s2);
WXDLLEXPORT wxChar * wxStrcpy(wxChar *dest, const wxChar *src);
WXDLLEXPORT size_t   wxStrcspn(const wxChar *s, const wxChar *reject);
WXDLLEXPORT size_t   wxStrlen(const wxChar *s);
WXDLLEXPORT wxChar * wxStrncat(wxChar *dest, const wxChar *src, size_t n);
WXDLLEXPORT int      wxStrncmp(const wxChar *s1, const wxChar *s2, size_t n);
WXDLLEXPORT wxChar * wxStrncpy(wxChar *dest, const wxChar *src, size_t n);
WXDLLEXPORT wxChar * wxStrpbrk(const wxChar *s, const wxChar *accept);
WXDLLEXPORT wxChar * wxStrrchr(const wxChar *s, wxChar c);
WXDLLEXPORT size_t   wxStrspn(const wxChar *s, const wxChar *accept);
WXDLLEXPORT wxChar * wxStrstr(const wxChar *haystack, const wxChar *needle);
WXDLLEXPORT double   wxStrtod(const wxChar *nptr, wxChar **endptr);
WXDLLEXPORT long int wxStrtol(const wxChar *nptr, wxChar **endptr, int base);
WXDLLEXPORT unsigned long int wxStrtoul(const wxChar *nptr, wxChar **endptr, int base);
WXDLLEXPORT size_t   wxStrxfrm(wxChar *dest, const wxChar *src, size_t n);
#endif

#ifdef wxNEED_WX_STDIO_H
#include <stdio.h>
#include <stdarg.h>
WXDLLEXPORT int      wxPrintf(const wxChar *fmt, ...);
WXDLLEXPORT int      wxVprintf(const wxChar *fmt, va_list argptr);
WXDLLEXPORT int      wxFprintf(FILE *stream, const wxChar *fmt, ...);
WXDLLEXPORT int      wxVfprintf(FILE *stream, const wxChar *fmt, va_list argptr);
WXDLLEXPORT int      wxSprintf(wxChar *buf, const wxChar *fmt, ...);
WXDLLEXPORT int      wxVsprintf(wxChar *buf, const wxChar *fmt, va_list argptr);
WXDLLEXPORT int      wxSscanf(const wxChar *buf, const wxChar *fmt, ...);
WXDLLEXPORT int      wxVsscanf(const wxChar *buf, const wxChar *fmt, va_list argptr);
#endif

#ifndef wxAtof
WXDLLEXPORT double   wxAtof(const wxChar *psz);
#endif

#ifdef wxNEED_WX_STDLIB_H
WXDLLEXPORT int      wxAtoi(const wxChar *psz);
WXDLLEXPORT long     wxAtol(const wxChar *psz);
WXDLLEXPORT wxChar * wxGetenv(const wxChar *name);
WXDLLEXPORT int      wxSystem(const wxChar *psz);
#endif

#endif
  //_WX_WXCHAR_H_
Commit	Line	Data
e35d0039 JS	1	/////////////////////////////////////////////////////////////////////////////
	2	// Name: wxchar.h
	3	// Purpose: Declarations common to wx char/wchar_t usage (wide chars)
	4	// Author: Joel Farley
	5	// Modified by:
	6	// Created: 1998/06/12
	7	// RCS-ID: $Id$
	8	// Copyright: (c) wxWindows copyright
	9	// Licence: wxWindows licence
	10	/////////////////////////////////////////////////////////////////////////////
	11
	12	#ifndef _WX_WXCHAR_H_
	13	#define _WX_WXCHAR_H_
	14
88ac883a VZ	15	//#ifdef __GNUG__
	16	//#pragma interface "wxchar.h"
	17	//#endif
e35d0039 JS	18
	19	// only do SBCS or _UNICODE
	20	#if defined (_MBCS )
	21	#error "MBCS is not supported by wxChar"
	22	#endif
	23
853d7d3d OK	24	// set wxUSE_UNICODE to 1 if UNICODE or _UNICODE is defined
	25	#if defined(_UNICODE) \|\| defined(UNICODE)
	26	#undef wxUSE_UNICODE
	27	#define wxUSE_UNICODE 1
	28	#else
	29	#ifndef wxUSE_UNICODE
	30	#define wxUSE_UNICODE 0
	31	#endif
	32	#endif
	33
	34	// and vice versa: define UNICODE and _UNICODE if wxUSE_UNICODE is 1...
	35	#if wxUSE_UNICODE
	36	#ifndef _UNICODE
	37	#define _UNICODE
	38	#endif
	39	#ifndef UNICODE
	40	#define UNICODE
	41	#endif
	42	#endif
	43
34f9227c	44	// Windows (VC++) has broad TCHAR support
3f4a0c5b	45	#if defined(__VISUALC__) && defined(__WIN32__)
e35d0039	46
a23fd0e1 VZ	47	#define HAVE_WCSLEN 1
a23fd0e1 VZ	48
e35d0039	49	#include <tchar.h>
1cfecdda	50	#if wxUSE_UNICODE // temporary - preserve binary compatibility
e35d0039	51	typedef _TCHAR wxChar;
3f4a0c5b	52	typedef _TSCHAR wxSChar;
e35d0039	53	typedef _TUCHAR wxUChar;
1cfecdda OK	54	#else
	55	#define wxChar char
	56	#define wxSChar signed char
	57	#define wxUChar unsigned char
	58	#endif
81d425f6 OK	59	// wchar_t is available
	60	#undef wxUSE_WCHAR_T
	61	#define wxUSE_WCHAR_T 1
e35d0039 JS	62
	63	// ctype.h functions
	64	#define wxIsalnum _istalnum
	65	#define wxIsalpha _istalpha
	66	#define wxIsctrl _istctrl
	67	#define wxIsdigit _istdigit
	68	#define wxIsgraph _istgraph
	69	#define wxIslower _istlower
	70	#define wxIsprint _istprint
	71	#define wxIspunct _istpunct
	72	#define wxIsspace _istspace
	73	#define wxIsupper _istupper
	74	#define wxIsxdigit _istxdigit
	75	#define wxTolower _totlower
	76	#define wxToupper _totupper
	77
	78	// locale.h functons
	79	#define wxSetlocale _tsetlocale
	80
	81	// string.h functions
	82	#define wxStrcat _tcscat
	83	#define wxStrchr _tcschr
	84	#define wxStrcmp _tcscmp
	85	#define wxStrcoll _tcscoll
	86	#define wxStrcpy _tcscpy
	87	#define wxStrcspn _tcscspn
	88	#define wxStrftime _tcsftime
853d7d3d OK	89	#define wxStricmp _tcsicmp
853d7d3d OK	90	#define wxStrlen_ _tcslen // used in wxStrlen inline function
e35d0039 JS	91	#define wxStrncat _tcsncat
	92	#define wxStrncmp _tcsncmp
	93	#define wxStrncpy _tcsncpy
	94	#define wxStrpbrk _tcspbrk
	95	#define wxStrrchr _tcsrchr
	96	#define wxStrspn _tcsspn
	97	#define wxStrstr _tcsstr
	98	#define wxStrtod _tcstod
e97a90f0	99	// is there a _tcstok[_r] ?
e35d0039 JS	100	#define wxStrtol _tcstol
	101	#define wxStrtoul _tcstoul
	102	#define wxStrxfrm _tcsxfrm
	103
	104	// stdio.h functions
	105	#define wxFgetc _fgettc
	106	#define wxFgetchar _fgettchar
	107	#define wxFgets _fgetts
	108	#define wxFopen _tfopen
	109	#define wxFputc _fputtc
	110	#define wxFputchar _fputtchar
	111	#define wxFprintf _ftprintf
	112	#define wxFreopen _tfreopen
	113	#define wxFscanf _ftscanf
	114	#define wxGetc _gettc
	115	#define wxGetchar _gettchar
	116	#define wxGets _getts
	117	#define wxPerror _tperror
	118	#define wxPrintf _tprintf
	119	#define wxPutc _puttc
	120	#define wxPutchar _puttchar
	121	#define wxPuts _putts
	122	#define wxRemove _tremove
	123	#define wxRename _trename
	124	#define wxScanf _tscanf
	125	#define wxSprintf _stprintf
	126	#define wxSscanf _stscanf
	127	#define wxTmpnam _ttmpnam
	128	#define wxUngetc _tungetc
	129	#define wxVfprint _vftprintf
	130	#define wxVprintf _vtprintf
ea1395db	131	#define wxVsscanf _vstscanf
e35d0039 JS	132	#define wxVsprintf _vstprintf
	133
	134	// stdlib.h functions
a982ddd2 OK	135	#if !wxUSE_UNICODE
	136	#define wxAtof atof
	137	#endif
e35d0039 JS	138	#define wxAtoi _ttoi
	139	#define wxAtol _ttol
	140	#define wxGetenv _tgetenv
	141	#define wxSystem _tsystem
	142
	143	// time.h functions
	144	#define wxAsctime _tasctime
	145	#define wxCtime _tctime
	146
	147	// #elif defined(XXX)
	148	// #include XXX-specific files here
	149	// typeddef YYY wxChar;
	150
	151	// translate wxZZZ names
	152
853d7d3d OK	153	#elif defined(__BORLANDC__) && defined(__WIN32__)
	154
	155	// Borland C++ 4.52 doesn't have much tchar support
	156	// maybe Borland C++ 5.02 has, can't check right now
	157	// but I'll use the Win32 API instead here
	158
	159	#include <tchar.h>
	160	#if wxUSE_UNICODE // temporary - preserve binary compatibility
	161	typedef _TCHAR wxChar;
	162	typedef _TSCHAR wxSChar;
	163	typedef _TUCHAR wxUChar;
	164	#else
	165	#define wxChar char
	166	#define wxSChar signed char
	167	#define wxUChar unsigned char
	168	#endif
81d425f6 OK	169	// wchar_t is available
	170	#undef wxUSE_WCHAR_T
	171	#define wxUSE_WCHAR_T 1
853d7d3d	172
57f6da0d	173	#define wxNEED_WX_CTYPE_H
853d7d3d OK	174	// #define wxStrtok strtok_r // Borland C++ 4.52 doesn't have strtok_r
	175	#define wxNEED_WX_STRING_H
	176	#define wxNEED_WX_STDIO_H
	177	#define wxNEED_WX_STDLIB_H
	178	#define wxNEED_WX_TIME_H
	179	#define wxNEED_WCSLEN
	180
81d425f6	181	#else//!TCHAR-aware compilers
34f9227c	182
81d425f6 OK	183	// check whether we should include wchar.h or equivalent
81d425f6 OK	184	#if wxUSE_UNICODE
a89ae1e4 OK	185	#undef wxUSE_WCHAR_T
a89ae1e4 OK	186	#define wxUSE_WCHAR_T 1 // wchar_t must be available in Unicode mode
81d425f6	187	#elif !defined(wxUSE_WCHAR_T)
a89ae1e4 OK	188	#if defined(__VISUALC__) && (__VISUALC__ < 900)
	189	#define wxUSE_WCHAR_T 0 // wchar_t is not available for MSVC++ 1.5
	190	#elif defined(__UNIX__)
31276cb5	191	#if defined(HAVE_WCSTR_H) \|\| defined(HAVE_WCHAR_H) \|\| defined(__FreeBSD__)
a89ae1e4 OK	192	#define wxUSE_WCHAR_T 1
	193	#else
	194	#define wxUSE_WCHAR_T 0
	195	#endif
6776a0b2 JS	196	#elif defined(__GNUWIN32__) && !defined(__MINGW32__) // Cygwin (not Mingw32) doesn't have wcslen.h, needed in buffer.h
6776a0b2 JS	197	#define wxUSE_WCHAR_T 0
25889d3c JS	198	#elif defined(__BORLANDC__) // WIN16 BC++
	199	#define wxUSE_WCHAR_T 0
	200	#elif defined(__WATCOMC__)
	201	#define wxUSE_WCHAR_T 0
a89ae1e4 OK	202	#else
	203	// add additional compiler checks if this fails
	204	#define wxUSE_WCHAR_T 1
	205	#endif
	206	#endif//wxUSE_UNICODE
81d425f6 OK	207
81d425f6 OK	208	#if wxUSE_WCHAR_T
31276cb5 RR	209	#ifdef HAVE_WCSTR_H
	210	#include <wcstr.h>
	211	#else
	212	#ifndef __FreeBSD__
	213	#include <wchar.h>
	214	#else
	215	#include <stdlib.h>
	216	#define wxNEED_WCSLEN
	217	#endif
	218	#endif
554936c8	219	#endif
65d77246	220
34f9227c OK	221	// check whether we are doing Unicode
	222	#if wxUSE_UNICODE
	223
34f9227c OK	224	#include <wctype.h>
	225
	226	// this is probably glibc-specific
	227	#if defined(__WCHAR_TYPE__)
	228
	229	typedef __WCHAR_TYPE__ wxChar;
	230	typedef signed __WCHAR_TYPE__ wxSChar;
	231	typedef unsigned __WCHAR_TYPE__ wxUChar;
	232
	233	#define _T(x) L##x
	234
	235	// ctype.h functions (wctype.h)
	236	#define wxIsalnum iswalnum
	237	#define wxIsalpha iswalpha
	238	#define wxIsctrl iswcntrl
	239	#define wxIsdigit iswdigit
	240	#define wxIsgraph iswgraph
	241	#define wxIslower iswlower
	242	#define wxIsprint iswprint
	243	#define wxIspunct iswpunct
	244	#define wxIsspace iswspace
	245	#define wxIsupper iswupper
	246	#define wxIsxdigit iswxdigit
0fea8a59	247
c1160779	248	#if defined(__GLIBC__) && (__GLIBC__ == 2) && (__GLIBC_MINOR__ == 0)
0fea8a59 VZ	249	// /usr/include/wctype.h incorrectly declares translations tables which
	250	// provokes tons of compile-time warnings - try to correct this
	251	#define wxTolower(wc) towctrans((wc), (wctrans_t)__ctype_tolower)
	252	#define wxToupper(wc) towctrans((wc), (wctrans_t)__ctype_toupper)
	253	#else
	254	#define wxTolower towlower
	255	#define wxToupper towupper
	256	#endif // gcc/!gcc
34f9227c OK	257
	258	// string.h functions (wchar.h)
	259	#define wxStrcat wcscat
	260	#define wxStrchr wcschr
	261	#define wxStrcmp wcscmp
	262	#define wxStrcoll wcscoll
	263	#define wxStrcpy wcscpy
	264	#define wxStrcspn wcscspn
853d7d3d	265	#define wxStrlen_ wcslen // used in wxStrlen inline function
34f9227c OK	266	#define wxStrncat wcsncat
	267	#define wxStrncmp wcsncmp
	268	#define wxStrncpy wcsncpy
	269	#define wxStrpbrk wcspbrk
	270	#define wxStrrchr wcsrchr
	271	#define wxStrspn wcsspn
	272	#define wxStrstr wcsstr
	273	#define wxStrtod wcstod
	274	#define wxStrtok wcstok
	275	#define wxStrtol wcstol
	276	#define wxStrtoul wcstoul
	277	#define wxStrxfrm wcsxfrm
e35d0039	278
34f9227c	279	// glibc doesn't have wc equivalents of the other stuff
e97a90f0 OK	280	#define wxNEED_WX_STDIO_H
	281	#define wxNEED_WX_STDLIB_H
	282	#define wxNEED_WX_TIME_H
34f9227c	283
853d7d3d	284	#else//!glibc
e35d0039 JS	285	#error "Please define your compiler's Unicode conventions in wxChar.h"
e35d0039 JS	286	#endif
34f9227c	287	#else//!Unicode
e35d0039	288
e97a90f0 OK	289	#include <ctype.h>
	290	#include <string.h>
	291
1cfecdda	292	#if 0 // temporary - preserve binary compatibilty
3f4a0c5b VZ	293	typedef char wxChar;
	294	typedef signed char wxSChar;
	295	typedef unsigned char wxUChar;
1cfecdda OK	296	#else
	297	#define wxChar char
	298	#define wxSChar signed char
	299	#define wxUChar unsigned char
	300	#endif
e35d0039	301
31276cb5 RR	302	#ifdef __FreeBSD__
	303	#undef _T
	304	#endif
3f4a0c5b	305	#define _T(x) x
e35d0039 JS	306
	307	// ctype.h functions
	308	#define wxIsalnum isalnum
	309	#define wxIsalpha isalpha
	310	#define wxIsctrl isctrl
	311	#define wxIsdigit isdigit
	312	#define wxIsgraph isgraph
	313	#define wxIslower islower
	314	#define wxIsprint isprint
	315	#define wxIspunct ispunct
	316	#define wxIsspace isspace
	317	#define wxIsupper isupper
	318	#define wxIsxdigit isxdigit
	319	#define wxTolower tolower
	320	#define wxToupper toupper
	321
	322	// locale.h functons
	323	#define wxSetlocale setlocale
	324
	325	// string.h functions
25889d3c JS	326	// #define wxStricmp strcasecmp
	327
	328	// Taken from string.h since it tests for platform more correctly
	329	// portable strcasecmp/_stricmp
	330	inline int WXDLLEXPORT wxStricmp(const char psz1, const char psz2)
	331	{
	332	#if defined(__VISUALC__) \|\| ( defined(__MWERKS__) && defined(__INTEL__) )
	333	return _stricmp(psz1, psz2);
	334	#elif defined(__SC__)
	335	return _stricmp(psz1, psz2);
	336	#elif defined(__SALFORDC__)
	337	return stricmp(psz1, psz2);
	338	#elif defined(__BORLANDC__)
	339	return stricmp(psz1, psz2);
	340	#elif defined(__WATCOMC__)
	341	return stricmp(psz1, psz2);
	342	#elif defined(__UNIX__) \|\| defined(__GNUWIN32__)
	343	return strcasecmp(psz1, psz2);
	344	#elif defined(__MWERKS__) && !defined(__INTEL__)
	345	register char c1, c2;
	346	do {
	347	c1 = tolower(*psz1++);
	348	c2 = tolower(*psz2++);
	349	} while ( c1 && (c1 == c2) );
	350
	351	return c1 - c2;
	352	#else
	353	// almost all compilers/libraries provide this function (unfortunately under
	354	// different names), that's why we don't implement our own which will surely
	355	// be more efficient than this code (uncomment to use):
	356	/*
	357	register char c1, c2;
	358	do {
	359	c1 = tolower(*psz1++);
	360	c2 = tolower(*psz2++);
	361	} while ( c1 && (c1 == c2) );
	362
	363	return c1 - c2;
	364	*/
	365
	366	#error "Please define string case-insensitive compare for your OS/compiler"
	367	#endif // OS/compiler
	368	}
	369
853d7d3d OK	370	// #define wxStrtok strtok_r // this needs a configure check
	371
	372	// leave the rest to defaults below
	373	#define wxNEED_WX_STRING_H
	374	#define wxNEED_WX_STDIO_H
	375	#define wxNEED_WX_STDLIB_H
	376	#define wxNEED_WX_TIME_H
	377
	378	#endif//Unicode
	379	#endif//TCHAR-aware compilers
	380
	381	// define wxStricmp for various compilers without Unicode possibilities
	382	#if !defined(wxStricmp) && !wxUSE_UNICODE
	383	#if defined(__BORLANDC__) \|\| defined(__WATCOMC__) \|\| defined(__SALFORDC__)
	384	#define wxStricmp stricmp
	385	#elif defined(__SC__) \|\| defined(__VISUALC__) \|\| (defined(__MWERKS) && defined(__INTEL__))
	386	#define wxStricmp _stricmp
	387	#elif defined(__UNIX__) \|\| defined(__GNUWIN32__)
	388	#define wxStricmp strcasecmp
	389	#elif defined(__MWERKS__) && !defined(__INTEL__)
	390	// use wxWindows' implementation
	391	#else
	392	// if you leave wxStricmp undefined, wxWindows' implementation will be used
	393	#error "Please define string case-insensitive compare for your OS/compiler"
	394	#endif
	395	#endif
	396
	397	// if we need to define for standard headers, and we're not using Unicode,
	398	// just define to standard C library routines
	399	#if !wxUSE_UNICODE
	400	#ifdef wxNEED_WX_STRING_H
e35d0039 JS	401	#define wxStrcat strcat
	402	#define wxStrchr strchr
	403	#define wxStrcmp strcmp
	404	#define wxStrcoll strcoll
	405	#define wxStrcpy strcpy
	406	#define wxStrcspn strcspn
e97a90f0	407	#define wxStrdup strdup
853d7d3d	408	#define wxStrlen_ strlen // used in wxStrlen inline function
e35d0039 JS	409	#define wxStrncat strncat
	410	#define wxStrncmp strncmp
	411	#define wxStrncpy strncpy
	412	#define wxStrpbrk strpbrk
	413	#define wxStrrchr strrchr
	414	#define wxStrspn strspn
	415	#define wxStrstr strstr
	416	#define wxStrtod strtod
e35d0039 JS	417	#define wxStrtol strtol
	418	#define wxStrtoul strtoul
	419	#define wxStrxfrm strxfrm
853d7d3d OK	420	#undef wxNEED_WX_STRING_H
853d7d3d OK	421	#endif
e35d0039	422
853d7d3d	423	#ifdef wxNEED_WX_STDIO_H
e35d0039 JS	424	#define wxFgetc fgetc
	425	#define wxFgetchar fgetchar
	426	#define wxFgets fgets
	427	#define wxFopen fopen
	428	#define wxFputc fputc
	429	#define wxFputchar fputchar
	430	#define wxFprintf fprintf
	431	#define wxFreopen freopen
	432	#define wxFscanf fscanf
	433	#define wxGetc getc
	434	#define wxGetchar getchar
	435	#define wxGets gets
	436	#define wxPerror perror
	437	#define wxPrintf printf
	438	#define wxPutc putc
	439	#define wxPutchar putchar
	440	#define wxPuts puts
	441	#define wxRemove remove
	442	#define wxRename rename
	443	#define wxScanf scanf
	444	#define wxSprintf sprintf
	445	#define wxSscanf sscanf
	446	#define wxTmpnam tmpnam
	447	#define wxUngetc ungetc
	448	#define wxVfprint vfprintf
	449	#define wxVprintf vprintf
ea1395db	450	#define wxVsscanf vsscanf
e35d0039	451	#define wxVsprintf vsprintf
853d7d3d OK	452	#undef wxNEED_WX_STDIO_H
853d7d3d OK	453	#endif
e35d0039	454
853d7d3d	455	#ifdef wxNEED_WX_STDLIB_H
e97a90f0	456	#define wxAtof atof
e35d0039 JS	457	#define wxAtoi atoi
	458	#define wxAtol atol
	459	#define wxGetenv getenv
	460	#define wxSystem system
853d7d3d OK	461	#undef wxNEED_WX_STDLIB_H
853d7d3d OK	462	#endif
e35d0039	463
853d7d3d	464	#ifdef wxNEED_WX_TIME_H
e35d0039 JS	465	#define wxAsctime asctime
e35d0039 JS	466	#define wxCtime ctime
34f9227c	467	#define wxStrftime strftime
853d7d3d	468	#undef wxNEED_WX_TIME_H
34f9227c	469	#endif
853d7d3d	470	#endif //!Unicode
e35d0039	471
853d7d3d OK	472	#if defined(wxNEED_WCSLEN) && wxUSE_UNICODE
	473	#define wcslen wxStrlen
	474	#undef wxNEED_WCSLEN
	475	#endif
e35d0039 JS	476
e35d0039 JS	477	/// checks whether the passed in pointer is NULL and if the string is empty
49828363	478	WXDLLEXPORT inline bool wxIsEmpty(const wxChar p) { return !p \|\| !p; }
e35d0039	479
853d7d3d	480	#ifndef wxNEED_WX_STRING_H
e35d0039	481	/// safe version of strlen() (returns 0 if passed NULL pointer)
49828363	482	WXDLLEXPORT inline size_t wxStrlen(const wxChar *psz)
853d7d3d	483	{ return psz ? wxStrlen_(psz) : 0; }
34f9227c	484	#endif
e35d0039	485
81d425f6	486	#if wxUSE_WCHAR_T
e97a90f0	487	// multibyte<->widechar conversion
49828363 RD	488	WXDLLEXPORT size_t wxMB2WC(wchar_t buf, const char psz, size_t n);
49828363 RD	489	WXDLLEXPORT size_t wxWC2MB(char buf, const wchar_t psz, size_t n);
e97a90f0 OK	490	#if wxUSE_UNICODE
	491	#define wxMB2WX wxMB2WC
	492	#define wxWX2MB wxWC2MB
	493	#define wxWC2WX wxStrncpy
	494	#define wxWX2WC wxStrncpy
639a9fb5	495	#else
e97a90f0 OK	496	#define wxMB2WX wxStrncpy
	497	#define wxWX2MB wxStrncpy
	498	#define wxWC2WX wxWC2MB
	499	#define wxWX2WC wxMB2WC
	500	#endif
0f3e3e0c JS	501	#else
	502	// No wxUSE_WCHAR_T: we have to do something (JACS)
	503	#define wxMB2WC wxStrncpy
	504	#define wxWC2MB wxStrncpy
	505	#define wxMB2WX wxStrncpy
	506	#define wxWX2MB wxStrncpy
	507	#define wxWC2WX wxWC2MB
	508	#define wxWX2WC wxMB2WC
81d425f6	509	#endif
0f3e3e0c	510
49828363	511	WXDLLEXPORT bool wxOKlibc(); // for internal use
e97a90f0 OK	512
	513	// if libc versions are not available, use replacements defined in wxchar.cpp
	514	#ifndef wxStrdup
49828363	515	WXDLLEXPORT wxChar * wxStrdup(const wxChar *psz);
e97a90f0 OK	516	#endif
e97a90f0 OK	517
0841bffa	518	#ifndef wxStricmp
49828363	519	WXDLLEXPORT int wxStricmp(const wxChar psz1, const wxChar psz2);
0841bffa OK	520	#endif
0841bffa OK	521
e97a90f0	522	#ifndef wxStrtok
49828363	523	WXDLLEXPORT wxChar * wxStrtok(wxChar psz, const wxChar delim, wxChar **save_ptr);
e97a90f0 OK	524	#endif
	525
	526	#ifndef wxSetlocale
49828363	527	WXDLLEXPORT wxChar * wxSetlocale(int category, const wxChar *locale);
e97a90f0 OK	528	#endif
e97a90f0 OK	529
853d7d3d	530	#ifdef wxNEED_WCSLEN // for use in buffer.h
49828363	531	WXDLLEXPORT size_t wcslen(const wchar_t *s);
853d7d3d OK	532	#endif
853d7d3d OK	533
57f6da0d	534	#ifdef wxNEED_WX_CTYPE_H
49828363 RD	535	WXDLLEXPORT int wxIsalnum(wxChar ch);
	536	WXDLLEXPORT int wxIsalpha(wxChar ch);
	537	WXDLLEXPORT int wxIsctrl(wxChar ch);
	538	WXDLLEXPORT int wxIsdigit(wxChar ch);
	539	WXDLLEXPORT int wxIsgraph(wxChar ch);
	540	WXDLLEXPORT int wxIslower(wxChar ch);
	541	WXDLLEXPORT int wxIsprint(wxChar ch);
	542	WXDLLEXPORT int wxIspunct(wxChar ch);
	543	WXDLLEXPORT int wxIsspace(wxChar ch);
	544	WXDLLEXPORT int wxIsupper(wxChar ch);
	545	WXDLLEXPORT int wxIsxdigit(wxChar ch);
	546	WXDLLEXPORT int wxTolower(wxChar ch);
	547	WXDLLEXPORT int wxToupper(wxChar ch);
57f6da0d OK	548	#endif
57f6da0d OK	549
853d7d3d	550	#ifdef wxNEED_WX_STRING_H
49828363 RD	551	WXDLLEXPORT wxChar * wxStrcat(wxChar dest, const wxChar src);
	552	WXDLLEXPORT wxChar * wxStrchr(const wxChar *s, wxChar c);
	553	WXDLLEXPORT int wxStrcmp(const wxChar s1, const wxChar s2);
	554	WXDLLEXPORT int wxStrcoll(const wxChar s1, const wxChar s2);
	555	WXDLLEXPORT wxChar * wxStrcpy(wxChar dest, const wxChar src);
	556	WXDLLEXPORT size_t wxStrcspn(const wxChar s, const wxChar reject);
	557	WXDLLEXPORT size_t wxStrlen(const wxChar *s);
	558	WXDLLEXPORT wxChar * wxStrncat(wxChar dest, const wxChar src, size_t n);
	559	WXDLLEXPORT int wxStrncmp(const wxChar s1, const wxChar s2, size_t n);
	560	WXDLLEXPORT wxChar * wxStrncpy(wxChar dest, const wxChar src, size_t n);
	561	WXDLLEXPORT wxChar * wxStrpbrk(const wxChar s, const wxChar accept);
	562	WXDLLEXPORT wxChar * wxStrrchr(const wxChar *s, wxChar c);
	563	WXDLLEXPORT size_t wxStrspn(const wxChar s, const wxChar accept);
	564	WXDLLEXPORT wxChar * wxStrstr(const wxChar haystack, const wxChar needle);
	565	WXDLLEXPORT double wxStrtod(const wxChar nptr, wxChar *endptr);
	566	WXDLLEXPORT long int wxStrtol(const wxChar nptr, wxChar *endptr, int base);
	567	WXDLLEXPORT unsigned long int wxStrtoul(const wxChar nptr, wxChar *endptr, int base);
	568	WXDLLEXPORT size_t wxStrxfrm(wxChar dest, const wxChar src, size_t n);
853d7d3d OK	569	#endif
853d7d3d OK	570
e97a90f0	571	#ifdef wxNEED_WX_STDIO_H
c1160779	572	#include <stdio.h>
e97a90f0	573	#include <stdarg.h>
49828363 RD	574	WXDLLEXPORT int wxPrintf(const wxChar *fmt, ...);
	575	WXDLLEXPORT int wxVprintf(const wxChar *fmt, va_list argptr);
	576	WXDLLEXPORT int wxFprintf(FILE stream, const wxChar fmt, ...);
	577	WXDLLEXPORT int wxVfprintf(FILE stream, const wxChar fmt, va_list argptr);
	578	WXDLLEXPORT int wxSprintf(wxChar buf, const wxChar fmt, ...);
	579	WXDLLEXPORT int wxVsprintf(wxChar buf, const wxChar fmt, va_list argptr);
	580	WXDLLEXPORT int wxSscanf(const wxChar buf, const wxChar fmt, ...);
	581	WXDLLEXPORT int wxVsscanf(const wxChar buf, const wxChar fmt, va_list argptr);
e97a90f0 OK	582	#endif
e97a90f0 OK	583
a982ddd2	584	#ifndef wxAtof
49828363	585	WXDLLEXPORT double wxAtof(const wxChar *psz);
a982ddd2 OK	586	#endif
	587
	588	#ifdef wxNEED_WX_STDLIB_H
49828363 RD	589	WXDLLEXPORT int wxAtoi(const wxChar *psz);
	590	WXDLLEXPORT long wxAtol(const wxChar *psz);
	591	WXDLLEXPORT wxChar * wxGetenv(const wxChar *name);
	592	WXDLLEXPORT int wxSystem(const wxChar *psz);
639a9fb5 OK	593	#endif
639a9fb5 OK	594
e35d0039 JS	595	#endif
e35d0039 JS	596	//_WX_WXCHAR_H_